claude-wow

claude-wow

A five-role team for Claude Code. One agent talks to you; the rest plan, build, review, and test the work between themselves over a shared message bus.

You write a one-line request. The Manager turns it into a story. A Senior Developer writes a plan, gets it reviewed by a Pair Programmer, implements it, and a Tester verifies it in a real worktree. You get a pull request back.

What you get

• One conversation to drive (the Manager). You never juggle five chat windows.
• Every change gets a written plan, a code review, and a test pass before it reaches a PR.
• It keeps working while you step away (/afk), pauses itself when you hit a usage limit, and reports PR/CI status from GitHub onto its own bus.

Quick start

Inside Claude Code, add this repo as a marketplace and install:

/plugin marketplace add surajpratap/claude-wow-plugin
/plugin install claude-wow

If the short form fails to resolve, use the full URL:

/plugin marketplace add git+https://github.com/surajpratap/claude-wow-plugin.git

One prerequisite: the claude-plugins-official marketplace (Anthropic's default — registered out of the box in Claude Code). claude-wow pulls its six plugin dependencies from it automatically; if you've removed it, re-add it before installing.

Now open one terminal per role and start them — Manager first:

/claude-wow:manager

Then, each in its own terminal: /claude-wow:senior-developer, /claude-wow:pair-programmer, /claude-wow:tester (and /claude-wow:slacker if you use Slack). Each runs its own startup, claims its role, and arms a bus monitor.

Give the Manager your first story in plain language:

Add a --json flag to the export command.

The Manager writes the story; the team takes it from there. You answer the occasional question and review the PR. To upgrade later, run /plugin update claude-wow (plugins don't auto-update), then /reload-plugins and restart the role terminals so every agent picks up the new version.

The five roles

Role	Does	Talks to you?
Manager (M)	Writes stories, orchestrates, owns priorities	Yes — the only one
Senior Developer (SD)	Writes plans, implements the code	No
Pair Programmer (PP)	Reviews plans, code, and bug fixes	No
Tester (T)	Tests finished work in a worktree, files bugs	No
Slacker (S) (optional)	Runs Slack comms, escalates to M	No

The roles never call each other directly. They coordinate through one append-only file — the message bus (implementations/.message-bus.jsonl). Each message carries a to field (an exact agent, a role like senior-developer-*, or * for everyone). The Manager orchestrates but does not relay messages; peers address each other. Each role's monitor pre-filters the bus so it only wakes for messages addressed to it.

flowchart TD
    H([You]) <-->|story / questions / PR| M[Manager]
    M -->|story-created| SD[Senior Developer]
    SD <-->|plan / review| PP[Pair Programmer]
    SD -->|story-done| T[Tester]
    T -->|story-verified / bugs| M
    subgraph BUS[shared message bus]
      direction LR
      B[(implementations/.message-bus.jsonl)]
    end
    M -.-> B
    SD -.-> B
    PP -.-> B
    T -.-> B

The development lifecycle

One story walks the whole loop. This is the spine of how claude-wow works.

sequenceDiagram
    actor You
    participant M as Manager
    participant SD as Senior Dev
    participant PP as Pair Programmer
    participant T as Tester
    You->>M: "Add a --json flag"
    M->>SD: story-created
    SD->>PP: plan-ready-for-review
    PP->>SD: plan-approved
    SD->>SD: implement (TDD, in a worktree)
    SD->>PP: code review
    SD->>T: story-done
    T->>M: story-verified (or files a bug)
    M->>SD: open a PR
    SD->>M: pr-created
    You->>You: review + merge

1. Story. M writes implementations/stories/<id>-<slug>.md and dispatches it.
2. Plan. SD writes a plan; PP reviews it on the bus until approved.
3. Implement. SD codes in a per-story git worktree, test-first.
4. Review + test. PP reviews the code; T verifies it against the acceptance criteria and files bugs if it breaks.
5. PR. After T verifies, M asks SD to open the pull request.
6. Merge. You review and merge. Nothing merges without you.

Sprint mode

For a batch of related work, run a sprint. You brainstorm the scope with M once; M writes a manifest of stories with a dependency graph, then drives them autonomously — dispatching independent stories in parallel up to a concurrency cap, and gating dependent ones until their parents land. At the end the team runs a retro and records learnings.

flowchart LR
    BS[brainstorm scope] --> KO[sprint kickoff<br/>manifest + dep graph]
    KO --> EX[parallel execution<br/>up to concurrency cap]
    EX --> RT[retro + learnings refresh]