crew

Crew

A Claude Code plugin that turns one chat into a small, disciplined engineering team.

You stay in the lead window. Behind a single slash command, Crew spins up specialists — builder, reviewer, validator, researcher, deployer — with explicit ownership, scoped files, required artifacts, and review gates. No hidden swarm. No runaway agents. Just a legible team loop that leaves inspectable tracks.

Why Crew

Plain Claude Code is a great pair programmer, but on substantial work it tends to:

• wander into unrelated files,
• silently skip tests,
• forget what it decided yesterday,
• and hand you a ten-thousand-token monologue instead of a review.

Crew fixes this by making the team model explicit. One lead owns the conversation and synthesis. Specialists get bounded missions with required output artifacts. A reviewer gate stands between "builder says done" and "task is done." Memory lives in files under .claude/ — not in scrollback — so tomorrow's session starts oriented.

How It Works (30 seconds)

┌───────────────────────────────────────────────────────────────┐
│  You ──► /crew:build-feature "add JWT refresh rotation"       │
│           │                                                   │
│           ▼                                                   │
│   ┌─────────────┐   pre-scopes files, picks mode & pace       │
│   │    LEAD     │──► writes run brief → .claude/artifacts/    │
│   └─────┬───────┘                                             │
│         │ bounded handoff (files, scope, forbidden, tests)    │
│         ▼                                                     │
│   ┌─────────────┐   edits only owned files, adds tests        │
│   │   BUILDER   │──► completion handoff artifact              │
│   └─────┬───────┘                                             │
│         │ review request                                      │
│         ▼                                                     │
│   ┌─────────────┐   approved | approved_with_notes | rejected │
│   │  REVIEWER   │──► review artifact                          │
│   └─────┬───────┘                                             │
│         │                                                     │
│         ▼                                                     │
│   ┌─────────────┐   runs the feature, captures evidence       │
│   │  VALIDATOR  │──► validation artifact                      │
│   └─────┬───────┘                                             │
│         │                                                     │
│         ▼                                                     │
│        LEAD ──► final synthesis to you + written artifact     │
└───────────────────────────────────────────────────────────────┘

Five pieces make this work:

1. Explicit roles. Five durable specialist agents (builder, reviewer, validator, researcher, deployer) live in agents/. The lead is whichever session you ran a /crew:* command in.
2. Bounded handoffs. Every delegation carries files, call_sites, design_notes, and size (light or standard). Thin handoffs are a code smell — the lead pre-scopes with Explore/Plan before dispatching.
3. Review gate. Reviewer must sign off before work counts as done. Tests for changed behavior are the default deliverable; reviewer rejects by default if they're missing without a concrete reason.
4. File ownership. Claims protect overlapping edits. Approvals gate scope expansion. Both live under .claude/state/crew/.
5. Inspectable artifacts. Run briefs, handoffs, reviews, validations, and final syntheses are written to .claude/artifacts/crew/ as Markdown. Event logs append to .claude/logs/events.jsonl. The black box becomes translucent.

A Live Session

Here's a real run. The task: "Add a /health endpoint to a new Express server, with a supertest test." User typed /crew:build-feature, the lead did the rest.

The side panel in these screenshots is Claude Panel — a separate Claude Code plugin that gives Claude its own visual surface for status, plans, and focus. Not required for Crew; shown here because it makes a live run easier to follow.

1. Lead restates scope, picks mode, writes run brief

The lead reads the wake-up brief, echoes goal / mode / pace back, names what's in and out of scope, writes a run brief under .claude/artifacts/crew/runs/, and pre-scopes the files before dispatching anyone.

2. Builder runs in its own context, returns a completion handoff

Builder only sees its bounded mission: server.js, tests/health.test.js, plus the design_notes from the handoff. It edits, runs the tests, and reports back — changed files, test status, any help_request.

3. Reviewer signs off (or rejects)