Skip to main content
command CX Codex

develop · coco-research — Claude Code command: what it does, how to install

develop runs a multi-agent build and bugfix pipeline that shards file edits across specialized agents and validates changes with regression evidence.

MIT ★ 328 updated 2026-10-29

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/commands/develop.md
Open on GitHub

What develop does

The develop command coordinates an agent workflow split into multiple layers. L1 agents inspect project dependencies and integration spots using brownfield_map.py. Next, L2 agents receive strictly isolated file ownership boundaries (YOUR FILES vs DO NOT TOUCH), preventing parallel agents from overwriting the same code.

Quality verification relies on automated execution gates. The pipeline runs run_gate.py to capture baseline test runs and coverage metrics. Then, prove_red.py checks added tests inside a temporary worktree to guarantee they actually fail prior to applying the fix.

Without the Python scripts located under ~/.claude/skills/team-gate/scripts/, the execution gates fail immediately. Agents also require bypassPermissions mode to modify files and execute the test runner.

What it helps with

  • shard module modifications across parallel agents without file conflicts
  • verify that newly written tests fail before the fix is applied
  • automate pre-commit regression checks and test coverage measurements
  • structure repository context before delegating tasks to coding agents

Example prompts for the agent

  • /team develop Build a rate-limiting middleware for API routes
  • /team develop Fix concurrent write race condition in the session store

How to install develop

Manually: put the files in place

.claude/commands/develop.md

Call it with /develop. For all projects use ~/.claude/commands/

Questions about develop

How to install develop in Claude Code?

Add the command definition file directly at .claude/commands/develop.md in your project.

What does the develop command do?

It coordinates a layered multi-agent pipeline that analyzes architecture, assigns strict file scopes to sub-agents, and validates all code with automated test gates.

What is the purpose of prove_red.py in the pipeline?

The script reverts implementation code in a temporary worktree to prove newly added tests go red on original code, eliminating false-positive test cases.

Source text

develop.md · MIT
---
description: "Use when the user runs /team develop, or the team router picks action develop, to build or fix code through a multi-agent pipeline. Shards files across L2 agents, then reviews with captured regression evidence."
---
# /team develop: Build Pipeline

> Called by team.md router when action is `develop`.

## Role Selection Bias

| Layer | Preferred Roles | Count |
|-------|----------------|-------|
| L1 | technical-analyst, security-analyst | 2 |
| L2 | senior-backend-eng, senior-frontend-eng, senior-cloud-architect, qa-test-architect, senior-data-eng, sre-devops, mcp-integration, performance-eng (if perf-related) | 3-5 (domain-dependent) |
| L3 | domain-accuracy, doc-quality, security-analyst (if api/backend/infrastructure), architecture-reviewer (if `.arch/index.json` exists) | 2-5 |
| L4 | principal-architect | 1 |

### Domain-Specific Selection

- `backend` only → senior-backend-eng + qa-test-architect + (senior-cloud-architect if `infrastructure`)
- `frontend` only → senior-frontend-eng + qa-test-architect + (senior-ux-designer if `product`)
- `backend` + `frontend` → senior-backend-eng + senior-frontend-eng + qa-test-architect
- `data` → senior-data-eng + senior-backend-eng
- `mobile` → senior-mobile-eng + qa-test-architect
- `infrastructure` → senior-cloud-architect + sre-devops
- `integrations` → mcp-integration + senior-backend-eng

## Stage 1: Brownfield Map

```
python3 ~/.claude/skills/team-gate/scripts/brownfield_map.py --for "<the feature or fix in words>" --repo-root .
```
exit 0: continue; read `.team-ship/BROWNFIELD-MAP.md` before reading any code.
exit 1: not used; a map is not a pass or fail judgement.
exit 2: UNVERIFIED; quote the gate file's summary (gates/handoff-1-map.json).

No develop-pipeline aggregator exists to require this gate file; the map is the first step by instruction.

## Pipeline Customization

### Layer 1: Research
L1 agents focus on the following areas.
- File mapping for the feature scope
- Existing patterns and conventions to follow
- Dependencies and integration points
- Security considerations for the feature

### Layer 2: Execution

1. Run `run_gate.py discover` then `run_gate.py run` for the baseline, before any Layer 2 agent commits.

```
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . discover
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . run
```
exit 0: continue and quote each gate file's summary (gates/7-discover.json, gates/8.json), and record gates/8.json's head field now as the base for the red-green proof; that file is rewritten by the Regression Tests run.
exit 1: BLOCK; for the command that stopped, quote its gate file's summary and loop back to Layer 2 execution.
exit 2: UNVERIFIED; for the command that stopped, quote its gate file's summary; the suite is not confirmed passing until the gate passes or an override receipt names the gate.

L2 agents receive file ownership boundaries (I10), covering the following areas.
- Orchestrator divides scope into non-overlapping file groups
- Each agent's prompt includes the following block.
  ```
  YOUR FILES: [list]
  DO NOT TOUCH: [files owned by other agents]
  ```
- Agents commit atomically per feature/fix

**Architecture context is advisory, not an allocation mechanism.**

```
python3 ~/.claude/skills/team-gate/scripts/arch_gate.py --repo-root .
```
exit 0: continue and quote `.arch/ARCH-GATE.json`; inline the component table from `.arch/INDEX.md` into each L2 prompt (max 25 lines) so agents know where each component's code lives.
exit 1: BLOCK; a REMOVE verdict, quote the reason from `.arch/ARCH-GATE.json`.
exit 2: UNVERIFIED; the index is absent (no .arch/index.json, which the script reports as not found), the pin is behind HEAD, or drift is unreconciled; omit the component-table block from each L2 prompt rather than quoting it.

Do **not** derive `YOUR FILES` from the index. The index sits at C4-Container altitude
while work is sharded at module altitude, and the two do not line up: in this repository
a legal five-component index assigns `skills/`, 1,087 files, to a single component. A
typical feature also spans three components at once. Scope-based splitting stays
authoritative for ownership; the index only tells an agent which boundary it is working
inside.

**Toolkit integration:**
- Check team:toolkit.md for "Code Implementation" entry
- If Superpowers pipeline recommended → agent follows brainstorm → plan → execute pattern
- If GSD active → agent reads `.planning/` context and follows phase conventions

**Permission Mode:** `bypassPermissions`, agents need to create/edit files and run tests.

### Regression Tests

Run after all Layer 2 agents complete, before Layer 3, per the Test Evidence Protocol (`team:evidence.md`).

```
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . discover
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . run
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . coverage
```
exit 0: continue and quote each gate file's summary (gates/7-discover.json, gates/8.json, gates/10.json).
exit 1: BLOCK; for the command that stopped, quote its gate file's summary and loop back to Layer 2 execution.
exit 2: UNVERIFIED; for `coverage`, no pytest-shaped command gives NOT_APPLICABLE, which still blocks unless an override receipt names gate "coverage"; for any other command that stopped, the suite is not confirmed passing until the gate passes or an override receipt names the gate.

Provision what CI provisions. When something cannot be provisioned, record "override integration: <reason>" in your own words as the human, and run_gate's skip rule decides the rest.

prove_red runs each test added since the base green at HEAD, reverts the implementation paths in a throwaway worktree and proves it goes red for the right reason; a never-red or invalid-red classification is BLOCK with the reason quoted from gates/9.json.

```
python3 ~/.claude/skills/team-gate/scripts/prove_red.py prove --base <the head recorded at the baseline step> --repo-root .
python3 ~/.claude/skills/team-gate/scripts/prove_red.py recheck --repo-root .
```
exit 0: continue and quote each gate file's summary (gates/9.json, gates/9-recheck.json).
exit 1: BLOCK; quote the reason from gates/9.json, or from gates/9-recheck.json for a changed or removed proved test, and loop back to Layer 2 execution.
exit 2: UNVERIFIED; for the command that stopped, quote its gate file's summary; the suite is not confirmed passing until the gate passes or an override receipt names the gate.

```
python3 ~/.claude/skills/team-gate/scripts/run_gate.py --repo-root . evidence
```
exit 0: continue and quote `.team-ship/EVIDENCE.md`.
exit 1: not used; evidence exits 0 or 2.
exit 2: UNVERIFIED; the suite is not confirmed passing until the gate passes or an override receipt names the gate.

Surface skips and failures explicitly in REVIEW-PACKAGE.md (with the skip count and any `UNVERIFIED` surface): never hide them inside a "passed" summary.

### Layer 3: Review
L3 agents focus on the following areas.
- Code correctness and edge cases (domain-accuracy)
- Test coverage adequacy: confirmed by the Regression Tests gate above, via `EVIDENCE.md`, not by reading test descriptions
- Architecture alignment with existing patterns
- Security review of auth, data handling, API boundaries (security-analyst, if selected)

## GSD Integration (C4)

When `.planning/` exists, the following applies.
- Read ROADMAP.md for phase context
- L2 agents follow GSD conventions: atomic commits, SUMMARY.md, STATE.md updates
Output is compatible with `/gsd-verify-work`.

© coco-research · MIT · coco-research/coco

Similar slash commands

All slash commands for Agent setup: memory, context, orchestration →

develop by other authors comes first.

develop Rohit Ghumare Runs structured feature development through research, planning, testing checkpoints, and strict verification before committing. CX Codex +1 ★ 2,966repo stars regression-hunt trailofbits regression-hunt — a skill for Claude Code that investigates regressions in PRs and commits. It coordinates error-hunting campaigns and resumes saved progress. CX Codex +1 685installs incident-response-test-automator Seth Hobson incident-response-test-automator writes unit, integration, regression and security tests around a bug fix, then runs the whole suite and reports coverage. CX Codex ★ 42,780repo stars test-automator VoltAgent test-automator — a subagent for writing and improving automated tests. Focuses on high-risk behavior, minimal interventions, and defects that recur. CX Codex ★ 6,505repo stars develop-ai-functions-example vercel The develop-ai-functions-example skill helps build and run AI SDK function examples for provider checks, feature demos, bug reproduction, and test fixtures. CX Codex +1 21installs eval-harness affaan-m eval-harness — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that brings eval-driven development into every agent session: success criteria go in before any code, results are scored with pass@k and pass^k. CX Codex +1 6,500installs autoresearch uditgoenka The autoresearch skill changes code, checks it against a metric, then keeps or discards the result. Separate commands cover debugging, security audits, and other workflows. CX Codex +1 2,700installs

From the same set82

The whole set →
coco-ads Turns your project code into a short launch video (15–25 seconds). Triggers on /coco-ads or phrases like "make a launch video". CX Codex +1 ★ 328repo stars mermaid The command renders Mermaid diagrams (flowcharts, sequence, state, class, ER, XY charts) as SVG, standalone HTML, or terminal ASCII. CX Codex +1 ★ 328repo stars maker-mdap maker-mdap — a Claude Code skill for designing long LLM workflows with fine-grained decomposition, voting, and rejection of suspicious outputs. CX Codex +1 ★ 328repo stars arch Command to build and validate .arch/index.json, which maps each architecture component to the files implementing it. Detects when files and component descriptions have drifted apart. CX Codex +1 ★ 328repo stars data-specialist data-specialist — a subagent for exploratory data analysis, machine learning workflows, and SQL query tuning across PostgreSQL, MySQL, SQL Server, and Oracle. CX Codex ★ 328repo stars media-use media-use is a skill for HyperFrames projects that finds music, sound effects, icons and logos, creates voiceover, and edits existing footage. CX Codex +1 ★ 328repo stars brain:init brain:init is a Claude Code skill that sets up project_brain.db in the project directory and extracts structured memory from CLAUDE.local.md, docs, and notes. CX Codex +1 ★ 328repo stars pmstudio-sync The pmstudio-sync skill turns changes in source files into proposed updates for linked PRDs, decks, and notes. It waits for approval before editing. CX Codex +1 ★ 328repo stars

Project sponsors

Companies that keep this analytics open