More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Subagent-Driven Development

    1

    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

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Subagent-Driven Development

    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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Git

    Permissions

    Terminal / Shell
    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    The failure modes are addressed structurally. Briefs come from a template so context is complete but bounded; reviews are two-axis and done by fresh eyes, not the implementer; fix rounds have a hard escalation table instead of spinning; and the ledger makes progress durable across restarts. "Work through the plan" has none of those guarantees — it has hope.

    The coordinator rules on it, using the spec as the binding authority, and records the decision, the reasoning, and what it costs if wrong. You can audit and override any ruling from the ledger. Only four things stop the run: destructive or irreversible operations, security-sensitive actions, shared side effects like merges and publishes, and a plan so broken that every path is a guess.

    It runs, but the setup — worktree, ledger, pre-flight — costs more than it returns at that size. The method pays off from roughly four tasks up, or at any size when the work must survive restarts or be audited later. The skill itself includes a selection table for deciding when to use it and when to just do the work directly.

    New in Agents & Orchestration