/subagent-make

subagent-make is a Codex skill for coordinated parallel implementation. It decomposes a work slice into independent builder assignments, delegates those slices to subagents, and uses one top-level agent to integrate, verify, and report the final result.

The skill is designed for implementation work where a single-pass agent is likely to move too slowly or miss cross-slice integration concerns: feature work, multi-layer changes, refactors with clear acceptance criteria, test expansion, and implementation plans that can be split safely.

Requirements

• Codex with custom skill support.
• Subagent support enabled in the Codex environment.
• Access to the repository, files, issue, spec, or implementation brief being built.
• A build target that can be expressed as acceptance criteria.

What It Does

• Resolves a work slice, issue, PRD, planning doc, or plain request into a build target.
• Writes a shared build contract before delegation.
• Splits work into independent slices based on acceptance criteria, ownership boundaries, components, or layers.
• Spawns up to six implementation subagents when the work can be split cleanly.
• Requires each builder to report changes, tests, risks, assumptions, and integration notes.
• Integrates builder output through one top-level agent instead of pasting reports together.
• Runs final verification and a focused integrator self-review before reporting.

Slice Model

The orchestrator prefers vertical slices tied to user-visible behavior and acceptance criteria. When that is not practical, it can fall back to bounded components, modules, backend/API/frontend/data/test slices, or short spikes that unblock implementation.

Useful builder archetypes include:

1. Foundation and contracts
2. Backend or domain logic
3. Frontend or UI
4. Data, migrations, or persistence
5. Tests and verification
6. Documentation and developer experience

The skill does not force six builders. It uses fewer when the work cannot be split cleanly.

Safety Model

Builders should work in isolated worktrees, branches, or patch outputs. They should not all edit the same working tree in parallel.

The top-level agent owns integration and must:

• inspect dirty working tree state before delegation
• preserve unrelated user changes
• define shared contracts and coordination points
• inspect every builder diff or patch before integrating
• reject, rewrite, or drop weak work
• run final verification where available
• avoid committing or pushing unless explicitly asked

Builders may run local checks relevant to their slice, but they should not install dependencies, mutate global state, start long-running services, access production systems, or use networked tools unless the build contract explicitly permits it.

Invocation

Use the skill explicitly when asking Codex to build a work slice:

Use $subagent-make to implement the dashboard filtering feature from docs/filtering-plan.md

or:

/subagent-make build issue #123 with parallel builders, then integrate and verify

It can also operate from a local planning document, a GitHub issue, a PRD, or a plain request once Codex has converted it into clear acceptance criteria.

Output Modes

The skill supports five output modes:

• build: decompose, delegate, integrate, verify, and report
• plan: produce the build contract and delegation plan only
• full: final delivery plus concise per-builder appendix
• patches-only: builders produce isolated patches and reports; parent does not integrate
• single-agent-fallback: use the same discipline without spawning subagents

Default mode is build.

Example Output

Changes
- Added account-level dashboard filters across the API query, filter state model, and table UI.
- Added regression coverage for persisted filters and empty-result behavior.

Verification
- npm test -- dashboard-filter: passed
- npm run typecheck: passed

Residual Risk
- No material residual risk identified.

Summary
Implemented the dashboard filtering slice end to end and verified the relevant tests and typecheck pass.

Install

Clone or copy this repository into your Codex skills directory:

mkdir -p ~/.codex/skills
git clone https://github.com/jarryd/subagent-make.git ~/.codex/skills/subagent-make

Then restart Codex so the skill is discovered.

If the skill is already installed, update it with:

cd ~/.codex/skills/subagent-make
git pull

Repository Layout

.
├── LICENSE
├── SKILL.md
├── README.md
├── agents/
│   └── openai.yaml
└── assets/
    └── subagent-make-icon.svg

SKILL.md is the runtime instruction file Codex loads when the skill triggers. agents/openai.yaml provides UI metadata for the Codex app.

Design Notes

This skill is intentionally focused on making and integrating, not review. It gives builders clear ownership boundaries, but the useful output is the integrated working tree owned by the top-level agent. Builder reports are inputs to integration, not the final product.

License

MIT. See LICENSE.