Claude Code plugins: TDD and git-tracking

Optimizing Claude Code: Three Plugins Instead of 39 Agents

A developer with 3,000+ hours of hands-on experience in Claude Code replaced a monolithic system—comprising 39 agents, 38 skills, and 25 slash commands—with just three plugins. This shift dramatically simplified maintenance and adaptation to Anthropic’s rapid updates, including the expansion of the context window to 1 million tokens. The new approach minimizes over-engineering and prioritizes seamless integration of battle-tested tools.

Previously, the Orchestrator Kit tackled context degradation by isolating sub-agents: each ran in its own context and returned results, preserving the cleanliness of the main session. But frequent API updates, emerging agent patterns, and the massive growth in context capacity rendered that architecture unnecessarily complex.

Problems with Monolithic Agent Systems

Maintaining 39 agents required manual updates after every Claude Code release. Skills and slash commands quickly became outdated—losing optimization for new capabilities. The biggest catalyst? The jump from 100K to 900K free tokens: context isolation no longer made strategic sense.

Key drawbacks:

• Pattern obsolescence: Agents written in October 2025 didn’t leverage the new Agent tool API introduced in January.
• Manual verification: Testing all 25 commands after each update took hours.
• Infrastructure bloat: Engineering focus shifted from building features to keeping the stack alive.

This is the classic trap: yesterday’s solution becomes tomorrow’s bottleneck.

Superpowers: Enforcing TDD as a Discipline

Jesse Vincent’s Superpowers plugin embeds rigorous software development discipline directly into Claude Code. Instead of ad-hoc coding, it enforces a strict sequence: brainstorming → planning → test-driven development (TDD) → code review → verification.

For a task like “Add JWT authentication”:

• Claude runs brainstorming: clarifies requirements and proposes implementation options.
• Moves to writing-plans: breaks work into focused 2–5 minute tasks.
• Runs mandatory TDD cycles: RED (failing test), GREEN (minimal working code), REFACTOR (cleanup).

The TDD rule is non-negotiable: production code is written only after a failing test confirms the feature is missing. This prevents model hallucinations from slipping into shipped logic.

Verification Before Completion

The verification-before-completion skill mandates four steps:

• Define the command used to verify the result.
• Execute it fresh—not from cache.
• Analyze the full output, not just snippets.
• Explicitly confirm success.

Without this, Claude often declared “done” based on assumptions—not evidence.

Beads: Git-Backed Task Tracking

Steve Yegge’s Beads stores tasks as versioned git files—ensuring persistence across sessions. Key commands:

• bd create -t feature "JWT authentication" — creates a task and commits it.
• bd ready — lists unblocked, actionable tasks.
• bd prime — restores project state at session start.

Advantages:

• Multi-terminal safety: Exclusive locks prevent race conditions.
• Dependency graph: Automatic ordering and blocking logic.
• Git history: Full audit trail of decisions—no loss during context compression.

This replaces sprawling spec files and fragile plan.json, making navigation intuitive and reliable.

Template Bridge: Unified Template Integration & Catalog

Our custom Template Bridge plugin unifies Superpowers and Beads via the unified-workflow skill. The workflow:

• Create an epic: bd create -t epic "JWT authentication".
• Run brainstorming and planning.
• Break down into dependency-aware subtasks:

bd create "tokens table schema"
bd create "verification middleware"
bd dep add middleware tokens

• bd ready refreshes the readiness dashboard.

The template-catalog gives instant access to 413+ prebuilt agents from [davila7/claude-code-templates](https://github.com/davila7/claude-code-templates), organized across 26 categories. Install any agent on demand: npx claude-code-templates@latest --agent security/security-auditor --yes. Agents are fetched fresh and auto-cleaned after use—zero local storage overhead.

Why It Matters

• Scalability: Three plugins instead of 102 components means automatic updates from maintainers—not manual patching.
• TDD enforcement: Red-Green-Refactor as a hard requirement cuts hallucination-induced bugs at the root.
• Persistence: Git-backed task tracking preserves session continuity and full project history.
• Flexibility: Templates load dynamically—no local repo bloat or version drift.
• Efficiency: Focus stays on methodology and outcomes—not infrastructure upkeep.

Approach Comparison

| Aspect | Orchestrator Kit | New Plugin Stack |

|--------|------------------|------------------|

| Components | 39 agents + 38 skills + 25 commands | 3 plugins + 2 skills + 1 command |

| Updates | Manual | Automatic |

| Context handling | Sub-agent isolation | 900K-token window + git persistence |

| Methodology | Optional | Enforced TDD + verification |

The new stack solves the same problems—but with far less operational overhead, evolving naturally alongside Claude Code’s rapid innovation.

— Editorial Team