Every engagement I run is delivered by a fleet of AI agents with me as the senior engineer in the loop — the same setup I use for my own products, running every day in production. This is not a prediction piece about how development might change; it is a description of a system that exists, what it is made of, and the control layers that make it safe enough to bill clients through.
The shape of the fleet
- A control plane owns the work. Projects and repositories live in a database; a reconciler watches open issues and dispatches them as tasks to agent sessions. Work arrives as issues, leaves as pull requests — the same contract a human team uses, which is exactly why it composes with one.
- Coding agents implement. Claude Code and Codex sessions pick up tasks in isolated worktrees, plan first on anything non-trivial, and produce branches with tests. Multiple agents run in parallel on independent streams; a merge coordinator keeps them out of each other's way.
- Reviewer agents attack. Finished work gets adversarial review — a different model, prompted to refute, not confirm. Findings are verified before they surface, so review output is signal, not noise. Cross-model review catches what self-review structurally cannot.
- Schedulers keep the lights on. Cron agents run daily reports, content pipelines, monitoring sweeps, and cleanup jobs. The unglamorous majority of the fleet's work is recurring operations, not feature development.
- Remote control closes the loop. Every session reports to a Telegram channel; the operator can answer a blocked agent, approve a decision, or redirect work from a phone. The fleet never waits long, and it never proceeds past a decision that belongs to a human.
The gates that make it safe
Speed without gates just ships defects faster. The system is conservative exactly where it counts:
- Tests gate merges. Typecheck, lint, tests, and build must be green before work is even presented for review — "works on the agent's machine" is not a state that exists.
- Humans gate irreversibility. Deploys, migrations, anything customer-visible or destructive stops at a human checkpoint. Agents propose; the operator disposes.
- Verification is empirical. Agents prove changes against the running application — the same discipline as the safety checklist I apply to other people's AI-built code, because the failure patterns do not care whose fleet generated them.
- Everything is a PR. Full diff, full history, revertable. The fleet leaves the same paper trail a disciplined team does, which is what makes its output auditable at all.
What this means if you are hiring one engineer
The economics are simple to state: one senior engineer with a well-built fleet delivers at a pace that used to need a team, while every line still passes through senior judgment. That is the model behind my AI automation engagements and the delivery speed of the fixed-fee reviews. And it is buildable in your organization: the AI Automation Roadmap maps exactly where agents would pay back first in your operation. The deeper technical write-ups of the fleet itself live at antrix.dev.
Frequently asked questions
Is AI-generated code safe to ship to production?
Unreviewed, no — and the failure patterns are predictable enough that I published a checklist of them. Inside a gated system, yes: agent output that must pass tests, adversarial review by a second model, and a human decision before merge ships at a defect rate I am comfortable staking my reputation on. The safety is in the harness, not the model.
What does an AI agent fleet actually consist of?
A control plane that turns work items into agent sessions; coding agents (Claude Code, Codex) doing implementation in isolated branches or worktrees; reviewer agents adversarially checking the work; schedulers and workers running recurring jobs; and a remote-control channel so the operator can supervise from anywhere. The parts are mundane — queues, cron, git, CI. The leverage is in how they gate each other.
Does AI-assisted development actually make delivery faster?
Yes, with a caveat that matters: it makes senior engineers dramatically faster, because the bottleneck moves from typing to judgment — specifying, reviewing, and catching what the agents miss. Hand the same fleet to someone who cannot evaluate the output and it produces polished-looking risk at unprecedented speed. That asymmetry is the whole economics of the approach.
Written by Andrej Dragojevic, Stripe Certified Professional Billing Architect.