agentsclimarketplace

Feature crew

Skill thesoze/claude-code-skills/skills/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

Install
npx -y skills add thesoze/claude-code-skills --skill feature-crew

Assembled 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)

  1. Orchestrator delegates, never codes. You plan phases, spawn subagents, verify artifacts, enforce gates. Code/tests/specs are written by subagents.
  2. Files > chat for cross-agent state. Every subagent reads inputs from specs/<slug>/*.md and writes outputs back to specs/<slug>/*.md. Never rely on chat history to carry state across phases.
  3. Triage before spawning. Classify every request before choosing the crew. Right-sized crew or nothing.
  4. Fresh-context reviewer. The reviewer subagent has no memory of the build. Same for security when spawned.
  5. Gates are real. No "skip this one." Document skips in state.json with reason.
  6. Human-in-the-loop at decision points. Not every step. Pause for scope-binding, architectural decisions, post-build verification, dismissed findings.
  7. 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

#PhaseActorInputOutput
0Intakeorchestratoruser requestrequest.md
1Triagefeature-crew-triage (haiku)request.mdcrew_plan.json
2Discoveryorchestrator + bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/detect_stack.shrepo statediscovery.md (inventory + stack profile)
3Specfeature-crew-pmrequest.md, discovery.mdspec.md
—Gate 1orchestratorspec.mdapproval or pushback
4Designfeature-crew-architectspec.md, discovery.mddesign.md, optional adr-NNN-*.md
—Gate 2orchestratordesign.md, ADRsapproval or pushback
4bUX (conditional)feature-crew-uxspec.md, design.mdux-plan.md
5Planorchestratordesign.md, spec.mdplan.md (ordered task list)
5bPlan-critiqueengineer subagent (read-only)plan.md, design.md, spec.mdcritique block appended to plan.md
6Buildfeature-crew-engineer-* (worktree for L/XL)plan.md, design.md, spec.mdcode diff
—Gate 3orchestrator (machine)lint + typecheck + build + testspass/fail
7Testfeature-crew-testerspec.md ONLY (no code)test-plan.md + test files; then runs
8Security (conditional)feature-crew-securityspec.md, design.md, diffsecurity-review.md
9DevOps (conditional)feature-crew-devopsdesign.md, diffmigration scripts, rollback plan
10Reviewfeature-crew-reviewer (fresh ctx)spec.md, design.md, diffreview.md
—Gate 4orchestrator + userreview.mdall CRITICAL fixed; WARN dismissals justified
11Docs (conditional)feature-crew-docsspec.md, diffREADME, CHANGELOG entry, API docs
12Shiporchestrator + usereverythingcommit 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:

SizeLOC / filesDefault crew
XS<20 LOC, 1 fileengineer + reviewer
S<100 LOC, 1–3 filesengineer + tester + reviewer
M<500 LOC, ≤10 filespm-lite + engineer + tester + reviewer
L<2000 LOC, ≤30 filespm + architect + engineer(s) + tester + reviewer + docs
XL≥2000 LOC or cross-servicefull cast

Overrides (risk wins):

  • risk ≥ high OR 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 CRITICAL findings must be fixed (new build + test + review cycle).
  • All WARN findings must be fixed OR dismissed with a one-line justification appended to review.md under ## Dismissed.
  • SUGGEST findings 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 for specs/<slug>/state.json, request.md, plan.md, and final commit message. Never for product code.
  • Agent (subagent spawn) — primary tool. Each subagent gets a scoped tools: 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):

SizeCap
S3
M5
L8
XL10

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":

  1. Read the most recently updated state.json.
  2. Print: Resuming <slug> at phase=<phase>, iteration=<n>. Last update: <timestamp>.
  3. Ask: "Continue from <phase>, restart phase, rollback one phase, or abort this feature?"
  4. 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:

  1. Have I resolved the {{stack.*}} variables from state.json?
  2. Is the subagent reading its inputs from files, not from my prompt?
  3. Have I given it the exact output file path to write to?
  4. Does its tools: allowlist match what it actually needs (reviewers: no Write)?
  5. Is it the right model for the role (haiku for triage, sonnet for most, opus for architect/security/reviewer)?
  6. For reviewer/security: is the context fresh (no build history)?
  7. 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 — creates specs/<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:

  1. bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/detect_stack.sh → cache.
  2. Read references/gotchas.md.
  3. Create specs/<slug>/ via bash ${CLAUDE_PLUGIN_ROOT}/skills/feature-crew/scripts/new_feature.sh <slug>.
  4. Write request.md verbatim.
  5. Spawn triage. Read crew_plan.json. Override if heuristics disagree.
  6. Announce plan to user: size, risk, crew, which gates will be auto vs human.
  7. Begin Discovery.

End-of-feature checklist

Before writing commit message:

  1. All gates passed and logged in state.json.
  2. review.md has zero unaddressed CRITICAL findings.
  3. changelog.md entry written (if surface includes user-visible).
  4. state.phase = "ship".
  5. PR body written from references/templates/pr-body.md using spec summary, design summary, test summary, and review summary.

That's the skill. Keep it files-first, gates-honest, crew-right-sized.

Keep looking

Skills are one crate of 608,475. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.