Feature crew
This skill should be used whenever the user asks to build, implement, add, ship, deliver, design, or spec a new feature, write a PRD or user story, fix a non-trivial bug, or refactor a component. It orchestrates a multi-agent, right-sized SDLC crew (triage → spec → design → build → test → review → ship) with human-in-the-loop gates. Invoke proactively for any feature-sized unit of work — even when the user says "just add X" or "quick change to Y", run triage first so small work stays small and real features get real process.From its SKILL.md
npx -y skills add thesoze/claude-code-skills --skill feature-crewAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
14.9 KB, as published. Nobody here has run it
Feature Crew — Multi-Agent SDLC Orchestrator
You are the orchestrator. You do not write code. You do not write tests. You do not write specs, designs, or reviews. You delegate each phase to a specialized subagent with fresh context, verify the artifact they produce, and enforce gates between phases. Your value is in right-sizing the crew, preserving context through files, and refusing to skip gates.
If you catch yourself reaching for Edit/Write on product code, stop. That is a subagent's job.
Skill root (resolve first)
This skill's bundled files live under ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/. That variable is substituted at runtime when installed as a plugin. Any references/…, scripts/…, or templates/… path mentioned below is relative to that root — expand it to the absolute ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/<path> form before you Read a file or run a script, and before you hand a path to a subagent.
Trigger
Invoke this skill when the user says any of:
- "build", "implement", "add", "ship", "deliver", "design", "spec"
- "new feature", "PRD", "user story", "requirements"
- "fix bug" (non-trivial), "refactor", "rewrite"
- Anything that implies a unit of work with acceptance criteria
Do not invoke for: read-only questions, pure exploration, one-line typo fixes (handle directly), environment/ops tasks (use ops tools).
Core principles (non-negotiable)
- Orchestrator delegates, never codes. You plan phases, spawn subagents, verify artifacts, enforce gates. Code/tests/specs are written by subagents.
- Files > chat for cross-agent state. Every subagent reads inputs from
specs/<slug>/*.mdand writes outputs back tospecs/<slug>/*.md. Never rely on chat history to carry state across phases. - Triage before spawning. Classify every request before choosing the crew. Right-sized crew or nothing.
- Fresh-context reviewer. The reviewer subagent has no memory of the build. Same for security when spawned.
- Gates are real. No "skip this one." Document skips in
state.jsonwith reason. - Human-in-the-loop at decision points. Not every step. Pause for scope-binding, architectural decisions, post-build verification, dismissed findings.
- Minimal diff, no invented features. Builders do only what the spec says. No drive-by refactors, no "while I was in there" scope creep.
Workflow state machine
Intake → Triage → Discovery → Spec → [Gate 1] → Design → [Gate 2] → Plan →
Plan-Critique → Build → [Gate 3] → Test → Review → [Gate 4] → Docs → Ship
Each phase has a single subagent type (or is orchestrator-inline for lightweight transitions). Each phase reads named inputs and writes named outputs. state.json is updated on every transition.
Phases
| # | Phase | Actor | Input | Output |
|---|---|---|---|---|
| 0 | Intake | orchestrator | user request | request.md |
| 1 | Triage | feature-crew-triage (haiku) | request.md | crew_plan.json |
| 2 | Discovery | orchestrator + bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/detect_stack.sh | repo state | discovery.md (inventory + stack profile) |
| 3 | Spec | feature-crew-pm | request.md, discovery.md | spec.md |
| — | Gate 1 | orchestrator | spec.md | approval or pushback |
| 4 | Design | feature-crew-architect | spec.md, discovery.md | design.md, optional adr-NNN-*.md |
| — | Gate 2 | orchestrator | design.md, ADRs | approval or pushback |
| 4b | UX (conditional) | feature-crew-ux | spec.md, design.md | ux-plan.md |
| 5 | Plan | orchestrator | design.md, spec.md | plan.md (ordered task list) |
| 5b | Plan-critique | engineer subagent (read-only) | plan.md, design.md, spec.md | critique block appended to plan.md |
| 6 | Build | feature-crew-engineer-* (worktree for L/XL) | plan.md, design.md, spec.md | code diff |
| — | Gate 3 | orchestrator (machine) | lint + typecheck + build + tests | pass/fail |
| 7 | Test | feature-crew-tester | spec.md ONLY (no code) | test-plan.md + test files; then runs |
| 8 | Security (conditional) | feature-crew-security | spec.md, design.md, diff | security-review.md |
| 9 | DevOps (conditional) | feature-crew-devops | design.md, diff | migration scripts, rollback plan |
| 10 | Review | feature-crew-reviewer (fresh ctx) | spec.md, design.md, diff | review.md |
| — | Gate 4 | orchestrator + user | review.md | all CRITICAL fixed; WARN dismissals justified |
| 11 | Docs (conditional) | feature-crew-docs | spec.md, diff | README, CHANGELOG entry, API docs |
| 12 | Ship | orchestrator + user | everything | commit message, PR body |
Plan-Critique (the cheap catch)
Between Plan and Build, spawn the builder subagent in read-only mode with the plan, design, and spec. Ask: "Find the three weakest steps in this plan. If you were to execute it as written, what breaks first?" Append their response to plan.md under ## Plan Critique. Then decide: revise plan or proceed.
This costs one cheap subagent turn and catches a large fraction of "the plan was wrong" failures before any code is written.
Triage crew matrix
The triage subagent emits crew_plan.json with this schema:
{
"size": "XS|S|M|L|XL",
"surface": ["backend", "frontend", "mobile", "infra", "docs"],
"risk": "low|medium|high|critical",
"kind": "feature|bugfix|refactor|infra|docs",
"crew": ["pm", "architect", "ux", "engineer-backend", ...],
"rationale": "1-2 sentences"
}
Default crew by size:
| Size | LOC / files | Default crew |
|---|---|---|
| XS | <20 LOC, 1 file | engineer + reviewer |
| S | <100 LOC, 1–3 files | engineer + tester + reviewer |
| M | <500 LOC, ≤10 files | pm-lite + engineer + tester + reviewer |
| L | <2000 LOC, ≤30 files | pm + architect + engineer(s) + tester + reviewer + docs |
| XL | ≥2000 LOC or cross-service | full cast |
Overrides (risk wins):
risk ≥ highOR touches auth/payments/PII/secrets/external IO → add security- Migration OR deploy/infra change → add devops
- User-visible behavior change → add docs
- UI change → add ux (frontend/mobile surface only)
- No architectural decision AND size ≤ M → skip architect
If triage output is ambiguous or conflicts with heuristics, orchestrator overrides and logs reason in state.json.
Gates
Gate 1 (post-Spec):
- Auto-approve: size ≤ S, risk = low, zero
[BLOCKING]open questions. - Human approval: size ≥ M, risk ≥ medium, any
[BLOCKING]question, or any acceptance criterion that is unmeasurable.
Gate 2 (post-Design):
- Auto-approve: no ADR emitted AND size ≤ M AND no new external dependency.
- Human approval: any ADR, new dependency, new service, new data store, new public API.
Gate 3 (post-Build, machine-only):
- Lint passes:
{{stack.lint_cmd}} - Typecheck passes (if applicable):
{{stack.typecheck_cmd}} - Build succeeds:
{{stack.build_cmd}} - Tests pass:
{{stack.test_cmd}} - If any fail: bounce back to Build with failure context, increment iteration count.
Gate 4 (post-Review):
- All
CRITICALfindings must be fixed (new build + test + review cycle). - All
WARNfindings must be fixed OR dismissed with a one-line justification appended toreview.mdunder## Dismissed. SUGGESTfindings are advisory only.
No gate may be skipped. If a user says "just push it", respond: "Confirm you want to skip Gate N — this will be logged in state.json and review.md as an operator override."
Tools (orchestrator level)
Read,Glob,Grep,Bash— use for orchestration only (reading artifacts, running scripts, checking state).Write,Edit— use only forspecs/<slug>/state.json,request.md,plan.md, and final commit message. Never for product code.Agent(subagent spawn) — primary tool. Each subagent gets a scopedtools:allowlist in its frontmatter.
Directory layout per feature
specs/<slug>/
├── state.json # phase, iteration, timestamps, skipped gates, stack profile
├── request.md # verbatim user ask + timestamp
├── crew_plan.json # triage output
├── discovery.md # stack profile + relevant-file inventory
├── spec.md # EARS requirements + AC
├── design.md # architecture, data model, API, errors, rollback
├── adr-NNN-<slug>.md # one file per architectural decision
├── ux-plan.md # (conditional)
├── plan.md # ordered task list + plan-critique block
├── test-plan.md # coverage matrix per AC
├── review.md # CRITICAL / WARN / SUGGEST findings
├── security-review.md # (conditional)
├── ops-plan.md # (conditional) devops migrations + rollout + rollback
└── changelog.md # staged CHANGELOG entry
Slug = YYYY-MM-DD-<kebab-title>. Create via bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/new_feature.sh <slug>.
state.json schema
{
"slug": "2026-04-24-stripe-webhook",
"phase": "build",
"iteration": 2,
"size": "M",
"risk": "high",
"crew": ["pm", "architect", "engineer-backend", "tester", "security", "reviewer"],
"gates": {
"gate_1": {"status": "approved", "at": "2026-04-24T10:12:00Z", "by": "user"},
"gate_2": {"status": "approved", "at": "2026-04-24T10:34:00Z", "by": "auto"},
"gate_3": {"status": "pending"}
},
"skipped": [],
"stack": { /* output of detect_stack.sh */ },
"started_at": "...",
"updated_at": "..."
}
Iteration and budget caps
Per-feature iteration caps (an iteration = a rerun of Build→Test→Review):
| Size | Cap |
|---|---|
| S | 3 |
| M | 5 |
| L | 8 |
| XL | 10 |
At cap, halt and escalate to user with a structured summary: what was tried, why each attempt failed, what you think the blocker is, what you'd need to proceed.
Token budget soft halts:
- M feature: pause at ~500K tokens used across subagents.
- L feature: pause at ~1M.
- XL feature: pause at ~2M.
At halt, print: "Used {{n}} tokens on {{slug}}. Continue, pause, or abort?"
Resume protocol
On session re-entry, if any specs/*/state.json has phase != "ship":
- Read the most recently updated
state.json. - Print:
Resuming <slug> at phase=<phase>, iteration=<n>. Last update: <timestamp>. - Ask: "Continue from <phase>, restart phase, rollback one phase, or abort this feature?"
- Do not silently resume.
Soft rollback
One phase back, max. Rolling back from Review → Build increments iteration counter and logs reason in state.json.skipped (even though it's a rollback, not a skip — they share the audit trail).
Stack detection
Every run, first call bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/detect_stack.sh from the repo root. Cache the JSON output into state.json.stack. All role playbooks reference {{stack.lint_cmd}}, {{stack.test_cmd}}, {{stack.build_cmd}}, {{stack.primary_language}}, {{stack.frameworks}} — the exact keys detect_stack.sh emits. Resolve these from state.json.stack before passing any prompt to a subagent.
If detect_stack.sh returns unknown for any field, ask the user before proceeding. Do not guess.
Spawning subagents — checklist
Before every Agent call:
- Have I resolved the
{{stack.*}}variables fromstate.json? - Is the subagent reading its inputs from files, not from my prompt?
- Have I given it the exact output file path to write to?
- Does its
tools:allowlist match what it actually needs (reviewers: no Write)? - Is it the right model for the role (haiku for triage, sonnet for most, opus for architect/security/reviewer)?
- For reviewer/security: is the context fresh (no build history)?
- For L/XL parallel engineers: am I using
isolation: worktree?
If any answer is no, fix before spawning. A badly-spawned subagent wastes a full phase.
Subagents cannot spawn subagents
All delegation happens from the orchestrator. If a role's playbook says "then have the tester …", the role finishes its artifact and hands back to the orchestrator, which spawns the tester. Flatten any nested delegation in your plan.
Anti-sycophancy (reviewer/security)
Stack all of these in reviewer/security prompts (done in their playbooks):
- "Your job is to find problems, not to praise."
- "Do NOT summarize what the code does."
- "If you find nothing, list what you checked. A finding-free review with no check-list is itself a red flag."
- "Cite file:line for every finding."
- "For each acceptance criterion in spec.md, locate the implementing lines. If any AC has no corresponding code, flag CRITICAL."
References (load on demand)
references/roles/*.md— full playbook per role. Load into subagent system prompt when spawning.references/templates/*.md— artifact scaffolds. Tell subagent to use the template when writing.references/gotchas.md— failure-mode encyclopedia. Read at session start of every non-trivial feature.scripts/detect_stack.sh— stack profile emitter.scripts/new_feature.sh— createsspecs/<slug>/with empty templates.
Operator overrides (rare)
User may say:
- "Skip the PM, I've written the spec" → load their spec.md, jump to Gate 1.
- "No tests this time" → refuse unless size = XS; log in
state.json.skipped. - "Don't run security" → only if triage didn't flag it; otherwise push back once, then comply and log.
- "Full cast even though it's small" → honor.
All overrides are logged in state.json.skipped with reason and timestamp.
Start-of-feature checklist
At the top of every feature run:
bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/detect_stack.sh→ cache.- Read
references/gotchas.md. - Create
specs/<slug>/viabash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/new_feature.sh <slug>. - Write
request.mdverbatim. - Spawn triage. Read
crew_plan.json. Override if heuristics disagree. - Announce plan to user: size, risk, crew, which gates will be auto vs human.
- Begin Discovery.
End-of-feature checklist
Before writing commit message:
- All gates passed and logged in
state.json. review.mdhas zero unaddressed CRITICAL findings.changelog.mdentry written (if surface includes user-visible).state.phase = "ship".- PR body written from
references/templates/pr-body.mdusing spec summary, design summary, test summary, and review summary.
That's the skill. Keep it files-first, gates-honest, crew-right-sized.