Skip to content
All writing

September 8, 2026

How I ship production software solo, with a team of AI agents

For most of my career, being a solo developer meant a hard ceiling on scope. There are only so many hours in a night, and every feature competes with every other feature for them. Over the last year that ceiling moved — not because I started working more hours, but because I stopped working alone.

I now run much of my development through a governed team of AI agents: specialists for backend, frontend, testing, schema review, and financial-logic auditing, coordinated by an orchestrator and held to hard quality gates. The clearest proof of what that unlocks is an entire ERP I built with it.

The problem with "AI-assisted" as most people do it

Most developers use AI the way you would use a very fast autocomplete: ask, paste, move on. That helps, but it does not change what one person can ship. The output is only as structured as the conversation, and nothing stops a confident-but-wrong suggestion from landing in your codebase.

The shift that mattered for me was treating AI less like autocomplete and more like a team I manage — with roles, responsibilities, and review steps I would expect from human engineers.

A team of specialists, not one generalist

Instead of one all-purpose assistant, I run a set of narrow agents, each with a single job:

  • A backend specialist and a frontend specialist that each own their side of a feature
  • A schema reviewer that guards database migrations before they ever run
  • A financial-logic auditor that checks accounting correctness on anything touching the ledger
  • A test writer that treats coverage as a deliverable, not an afterthought
  • An orchestrator that sequences the work and decides what is actually ready to accept

Governance is the whole game

The agents do not get to merge whatever they produce. Every night of work runs through a fixed playbook with hard gates — a financial audit, a schema check, a frontend review, an audit-trail check, and a general-ledger reconciliation — and nothing is accepted until it passes.

Autonomy without gates is just a faster way to make a mess. The gates are what make the speed safe, and they are why I trust the output enough to put it in front of a paying client.

What it actually produced

The clearest output so far is a multi-site manufacturing ERP I built solo over roughly 30 weeks:

  • Over 1,000 commits and more than 5,000 automated tests
  • 32 backend modules — procurement, manufacturing, inventory, sales, receivables, treasury, and a full general-ledger engine
  • An append-only ledger, an immutable audit trail, and enforced three-way matching — accounting standards an auditor would recognize
  • 38 architecture decision records documenting why each call was made

What I would tell another developer

Agentic development is not magic, and it is not hands-off. It is management. A few things that made the difference for me:

  • Give your agents narrow roles — a generalist assistant produces generalist results
  • Put the review where the risk is; for me that is money and data, so those get their own auditors
  • Make quality gates automatic and non-negotiable — judgment you have to remember is judgment you will skip at 3 a.m.
  • Keep humans on the irreversible decisions: production deploys and anything that leaves the building