How a tiny team ships agency-scale systems in weeks

A custom billing engine that retired Wodify. A 31-screen signage fleet across four stores. A sync that makes PushPress and GoHighLevel behave like one tool. A native iOS app on TestFlight. Each of those used to mean an agency, a six-month timeline, and a floor of engineers. We shipped them with a tiny team, in weeks each, and we still run them in production. People assume the catch is corners cut. It is not. The catch is the workflow changed.

Here is the honest version of how that works, including the parts that are not magic.

We embed first, then build

The fastest way to waste AI is to point it at a vague idea. So before any code, we sit with the business and learn how it actually runs. For Persistence Athletics that meant the real dues schedule, what happens when a member travels or gets hurt, how the coaching method generates a week of programming. For Craft Cannabis it meant which screens hang where, which run a check-in queue, which show a menu, and how often inventory drifts from the boards.

That knowledge is what we turn into software. It is also what makes the AI useful. A model can write a Stripe integration in an afternoon. It cannot know that this gym needs a pause-and-resume flow and a payment-method gate so dues do not silently fail. We bring the second part. The model handles the volume.

Claude Code and Codex do different jobs

We do not use one AI for everything. They are good at different things, and treating them as interchangeable is how you get slop.

• Claude Code is the builder that lives in the repo. It reads the whole codebase, runs commands, writes and edits files across a project, and holds the architecture in its head. It is what carries a feature from "member portal" to working code wired into the real backend.
• Codex is the second pair of eyes and the parallel worker. We hand it the tightly-scoped pieces, the refactors, the test passes, the "go check this" jobs, so the main thread keeps moving on the hard part.
• Both are wrong sometimes. The whole workflow is built around catching that, not pretending it does not happen.

Small, verifiable steps beat big prompts

The biggest mistake people make with these tools is asking for too much at once. "Build me a gym platform" produces a confident pile of code that almost works, which is worse than useless. We work in small steps with a check at the end of each one: build the billing cron, run it against the Stripe sandbox, confirm an invoice actually fires, then move on.

That is why we run a dual prod and dev setup on every project. The Persistence stack has separate instances so we ship and test without touching live members. The billing engine was tested against a sandbox for a week of real prod-shaped scenarios (double-tax bugs, webhook duplicates, default payment-method edge cases) before a single member's card was charged. AI writes fast. The discipline is in refusing to trust it until you have watched it work.

The compounding part: we operate what we build

Shipping fast would be a gimmick if the systems rotted after launch. They do not, because the same team that built them runs them in production. Craft's 31 Fire TV devices auto-update silently every day and we push to all of them from one dashboard over VPN. DRiV's sync runs unattended under systemd behind Caddy, restarts itself, comes back after a reboot. Persistence ships new features every week to a live beta.

Operating it is also what keeps the AI honest over time. When you are the one getting paged, you do not let the model leave you a mess you cannot debug at 11pm. The code stays clean, documented, and owned, because we are the ones who have to live in it next week.

What actually makes it fast

• Real domain knowledge up front, so the AI is solving the right problem instead of a generic one.
• One connected system per client instead of six tools stitched with Zapier, so there is less integration glue to babysit.
• Small steps with a verification at the end of each, run against a dev environment that mirrors prod.
• Claude Code for the deep build, Codex for the parallel and scoped work, a human reviewing both.
• Operating the thing afterward, which forces quality and turns a launch into something that compounds.

The honest caveats

This is not a button you press. The AI hallucinates APIs, picks the plausible-wrong approach, and writes code that compiles and is still subtly broken. We caught a double-tax bug and a Stripe Link surprise in billing forensics, not from the model volunteering them. None of that is a reason to skip the tools. It is the reason a human stays in the loop, reads the diffs, and tests against reality. The speed comes from the model doing the typing and the searching and the boilerplate. The judgment is still ours.

We build it, then we run it. The AI made one focused team ship what used to take a floor of engineers. It did not replace the judgment about what to build or whether it actually works.

That is the whole trick. Not a secret prompt. A workflow: learn the business, build in small verifiable steps, use the right model for the right job, keep a human on the diffs, and operate what you ship so it gets better instead of decaying. Do that, and a tiny team really can ship agency-scale systems in weeks. Your business, on autopilot.

Wondering what one system would replace for you?