For two weeks, Claude Code ran a large migration on its own. Cloud routines built each phase, an independent reviewer gated every merge, a fixer answered every FAIL, and a watchdog caught whatever stalled. A human touched it only at the gates we chose.

It worked. More usefully, it broke in instructive ways, and every rule in the plugin exists because something went wrong without it.

Six lessons

  1. Scope the review, never the proof. Reviewers that ran only the tests for the changed lines passed broken builds. The analysis can focus on the latest changes, but the full test run can't be skipped.
  2. A reviewer that reads code will still miss what isn't there. Our gate passed a phase with 6 of 21 plan items undelivered (4 not done, 2 partial). Plan completeness is now a mandatory check, and a missing item counts as a defect.
  3. Fail safe when a service is absent. A data-retention job treated unsent warning emails as sent, so it would have deleted accounts without notice. The gate now checks this, and it has since caught a second case.
  4. Confirm security findings live. Our first weekly security sweep rated a finding HIGH from reading the code alone; a live check on staging showed it wasn't real. Serious findings are now reproduced before they're reported.
  5. "Waiting on you" lists grow without limit. Sessions now handle visual checks (screenshots plus a review agent), translations (a review agent), policy questions (logged rulings) and facts only the owner knows (derived, or worded so they're true without them). The human acts only at hard-limit gates, such as a production deploy.
  6. Review the plan before the code. Lessons 2 and 3 were really design problems that we found only after the build: plan items nobody delivered, and a fail-safe gap built into the design. Each one cost a fix round and a full re-review. Google's Elephant-Goldfish Model has the right idea: design with an agent that holds all the context (the elephant), then review with agents that have none of it (the goldfish). We adapted it so every phase plan is reviewed by four isolated agents (zoom-out, comprehension, critic, readiness) before anything is built, with no human approval step to wait on.

The plugin

We packaged the method as autodeliver, an open-source Claude Code plugin (MIT):

/plugin marketplace add Mgabr90/autonomous-delivery /plugin install autodeliver@autonomous-delivery

Try it in a minute, with no setup:

/autodeliver:review # an independent gate on your current changes; it runs your tests itself /autodeliver:design-review docs/plan.md # four fresh-eyes reviewers on a plan or spec

The full loop (/autodeliver:init) runs locally with subagents, or around the clock as Claude Code cloud routines fired by GitHub or Azure DevOps. It has profiles for software, docs, data, infra, migrations and research. It includes the design review, an independent gate, a fixer, a watchdog, stop guards, a security and drift sweep, a usage inspector and a staging-gate kit. A token log is on by default, and /autodeliver:report shows what each role costs.

See it run: autodeliver-demo is a small public repo where one phase went through the loop, with every design-review and gate verdict committed exactly as the agents wrote it. The design review caught all three defects planted in the starting code before any code was written, and the gate then passed in round 1. It's one small phase, not a benchmark, and the repo says so.

Contribute: the easiest contributions are a new profile, a lesson learned, or an example config for your stack. https://github.com/Mgabr90/autonomous-delivery

This post was drafted by Claude from our project notes and lessons log.