- Home
- Skills
- Agents & Orchestration
- Subagent-Driven Development
More screenshots
Works with the AI Agents you already use
Subagent-Driven Development
Execute a multi-task plan with fresh subagents per task: crafted briefs, two-axis review, bounded fix rounds, rulings instead of stalls, and a ledger that survives context loss.
$5
Subagent-Driven Development
Example session with this skill installed
I have a written 6-task plan to add rate limiting to our API: config schema, limiter middleware, route wiring, 429 responses, admin bypass, metrics. Run it with this method — show me how it actually goes, starting with the first task.
- Read your context and instructions
- Compiled the subagent-driven development
Pre-flight, before task 1 is dispatched: two plan defects found and ruled on now, not discovered mid-run. Task 2 specifies a fixed window; task 6's metrics assume a sliding window. Ruling: sliding window, because the spec's abuse case is a burst straddling the boundary; cost if wrong, recorded: one middleware rewrite. Task 4 never says where Retry-After is computed. Ruling: the limiter returns it; routes stay dumb.
Setup: worktree off the main branch, ledger created with six task blocks, base commit recorded before anything moves.
Task 1 (config schema) goes out with this brief — CONTEXT: task 1 of 6; nothing depends on it yet, everything depends on its key names. TASK: the plan text, verbatim. INTERFACES: none upstream; this task sets the rateLimit.* names that tasks 2–6 will consume. RULINGS: the window decision above; limits are per API key, not per IP. OUT OF SCOPE: middleware logic, which is task 2. DONE WHEN: schema validates, the defaults test passes, key names documented in the ledger.
Return: one commit, tests green, self-review attached. Review: spec compliance passes. One quality finding — the schema puts no upper bound on the configured limit, so a config typo could silently disable rate limiting in production. Fix round 1: bound added, validation test added. Re-review scoped to the finding: clean. Ledger updated — task 1 complete, finding and disposition recorded, ruling trail intact — and task 2 is dispatched immediately, its brief carrying the schema's key names in the INTERFACES block. No questions were sent to you; the two that would have stalled the run were decided in pre-flight and written down where you can audit them.
Connects securely to your tools. The creator never sees your data.
About this skill
Long implementation plans die in agent sessions the same way every time: one context tries to hold the whole project, details blur, an ambiguous task gets guessed at silently, a fix loop spins for an hour, and when the session restarts nobody can say which tasks are actually done. This skill is the coordination discipline that prevents all five failures.
You act as coordinator, not implementer. Each task goes to a fresh subagent with a brief built from a fixed template — the task text verbatim (never a drifting paraphrase), the interfaces earlier tasks established, ambiguities already ruled on, explicit out-of-scope fences, and done criteria. Each result gets reviewed on two axes by separate eyes: spec compliance and code quality. Fix rounds are bounded by a decision table — same implementer twice, then a fresh one, then a tier escalation, then the problem is the task or the plan, and the method says so. Ambiguities are ruled on by the coordinator and recorded, not escalated into day-long stalls; only four categories of decision are allowed to stop execution.
The spine of the method is the ledger: a durable file recording per task the base commit, commits produced, review findings with dispositions, and every ruling with its reasoning and its cost if wrong. Restart the session, compact the context — the ledger plus the git log reconstructs exactly where you are, so no completed task is ever re-dispatched. Model economics are handled explicitly too: tiers matched to roles, with the counterintuitive rule that the cheapest model often costs more in turns. A final whole-branch review on the strongest available model catches what per-task reviews structurally cannot.
This skill is a coordination method, not an agent platform: it requires an environment that can dispatch subagents and review diffs, and it will not rescue a bad plan — pre-flight catches contradictions, but a plan whose tasks are wrong produces well-organized wrong work, faithfully ledgered. It assumes git; the isolation and review steps have no equivalent in a folder of loose files. And the rulings-not-stalls default is a real trade: you get momentum and an audit trail instead of approval checkpoints, so for work where every step needs your sign-off, a check-in workflow fits better.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 24 days ago
Requires