By evanklem
Orchestrates a complete TDD-driven development loop from brainstorming through implementation with checkpointed context management, parallel coder/overseer review, and root-cause debugging — all triggered by a single phrase.
Implementation subagent for one decomposed unit of work in the evanflow-coder-overseer pattern. Uses vertical-slice TDD per evanflow-tdd. Tool-restricted to prevent any git ops or destructive actions — you cannot accidentally commit, push, or modify state outside your task scope.
Read-only review subagent for one coder's output (or for cross-coder integration review) in the evanflow-coder-overseer pattern. Reports findings; never fixes. Tool-restricted to prevent any modifications — Read/Grep/Glob only, no Edit/Write/Bash. The role separation is the QA signal.
Clarify intent, propose 2-3 approaches, embedded grill to stress-test the chosen path. Use before any creative work — new features, components, behavior changes, design questions. Mockup-only requests use mockup quick-mode (no spec/plan ceremony).
Orchestrate parallel implementation with coder/overseer pairs. Coders implement decomposed tasks using evanflow-tdd; overseers review each coder's output for bugs, gaps, errors, AND cohesion violations against a shared contract. A final integration overseer checks cross-coder cohesion. Use for plans with 3+ truly independent tasks that share an interface contract.
Manage long-session context to prevent drift and degradation. Strategies for proactive summarization, branch isolation, and /clear decisions. Invoke when context feels heavy, when accuracy starts slipping, or proactively after a major phase boundary. Addresses the
Root-cause discipline for bugs, test failures, and unexpected behavior. Embedded grill on the hypothesis before writing fix code. Use when encountering any bug, failing test, or behavior that doesn't match expectation.
Design a module's interface using parallel sub-agents producing radically different designs ("design it twice"). Compare on depth, simplicity, and efficiency. Embedded grill on the synthesized choice. Use when designing a new API, exploring interface options, or deciding the shape of a refactor before writing code.
Executes bash commands
Hook triggers when Bash tool is used
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A TDD-driven iterative feedback loop for software development with Claude Code.
16 cohesive skills + 2 custom subagents walk an idea from brainstorm through implementation, with checkpoints throughout where you stay in control. One entry point: say "let's evanflow this" and the orchestrator runs the loop.
brainstorm → plan → execute (vertical-slice TDD per task) → iterate → STOP
└─ sequential, or parallel coder/overseer
TDD is not a separate phase after execute — it's the discipline inside each code-writing task. Execute is the harness (task tracking, blockers, quality checks); evanflow-tdd is what runs inside any task that produces production code.
The loop is conductor, not autopilot: real checkpoints at design approval, plan approval, and after iteration. The agent stops short of every git operation and waits for your direction. No auto-commits. No forced ceremony. No "must invoke a skill" tax.
The recommended path — Claude Code's plugin marketplace:
/plugin marketplace add evanklem/evanflow
/plugin install evanflow@evanflow
Restart, then try:
"Let's evanflow this — I want to add a small feature that does X."
evanflow-go fires and walks the loop. The git-guardrails hook auto-activates with the plugin (no settings.json edit needed). Skills appear under the evanflow: namespace (e.g., /evanflow:evanflow-go).
See Installation below for two alternative paths.
The loop is built around discipline that compounds across iterations, not single-shot generation. Every step has a checkpoint that gates the next:
For plans with 3+ truly independent units, the loop forks into a parallel coder/overseer orchestration: one coder per unit (using vertical-slice TDD with a RED checkpoint), one overseer per coder (read-only review subagent that can't modify code), plus an integration overseer that runs named integration tests at every touchpoint. The integration tests are the executable contract — interfaces can't drift if both sides have to satisfy the same passing test.
Each rule below cites the source it came from. If a citation is missing, the rule is opinion from running the loop on real projects, not research — labeled as such.
npx claudepluginhub evanklem/evanflow --plugin evanflowAutonomous development orchestration with parallel TDD execution
Opinionated 5-phase development lifecycle for Claude Code — language-agnostic, repo-local bin/* delegation
Test-driven development methodology with red-green-refactor cycles and code review
Persona-driven AI development team: orchestrator, team agents, review agents, skills, slash commands, and advisory hooks for Claude Code
Test-driven development skill that enforces red-green-refactor, one test at a time
Implement code from /deep-plan sections with TDD, code review, and git workflow