Methodology
Anyone can say they use AI to build software. This page shows the actual system: how work gets broken down and handed to agents, the quality gates every change has to pass, and the decisions I never delegate. It's the process behind shipping AutoSAM solo, 90 feature modules and 2,000+ automated tests in under a year, and it's the same process I bring to client work.
I do not hand an AI a feature request and hope. Work is decomposed into bounded tasks and dispatched to subagents, each with a scoped context and an explicit contract for what it may read and modify.
A written context-budget protocol: agents stay under hard context ceilings, with checkpointing when a task outgrows its budget
A dispatch decision tree that says when work must be delegated instead of done inline
A model-routing table: deep-reasoning models for correctness-critical work, fast models for mechanical edits
Long work drains through a queue with a journal, so an autonomous run leaves an auditable trail instead of a mystery diff.
Agents produce code; gates decide whether it survives. Before any change lands, it passes an 8-point gate I run without exception.
TypeScript compilation, zero errors
Scoped lint, zero errors on touched files
Architecture meta-tests: no cross-feature dependency cycles, banned query patterns, schema-drift checks
Accessibility checks on the PDF pipeline
The full unit-test suite
A logic review of the diff
A user-journey coherence check
End-to-end browser tests
There is no CI server behind this; the discipline is self-imposed and self-run before every commit, which is harder to sustain and therefore worth saying out loud.
Learn more: the AutoSAM build and the Marvin.com modernization.
Where the human sits
AI-role clarity, plainly: agents write most first-draft code under my direction. I own the architecture, the task decomposition, the review of every diff, and every decision the gates cannot make (is this the right feature, is this the right boundary, does this journey make sense). Validation is mechanical where possible (the gates) and manual where it must be (logic and journey review). When an agent's output fails a gate, it gets reworked or reverted; the gate never gets loosened to let a change through.
Why this matters to a client
The honest pitch is throughput with receipts. This system is how one engineer delivered a platform-scale build in months, and the receipts are in the artifact: test counts, architecture invariants, and a documented process rather than adjectives. It is also how I deliver client work in weeks instead of a quarter. The failure modes are real too: agents drift on underspecified tasks, and context limits punish sloppy decomposition. The system exists precisely because the failure modes are real.
