Skip to content
All writing

How a tiny team ships agency-scale systems in weeks

Our own billing that replaced Wodify. 31 store screens across four stores. An iPhone app in beta. 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. People assume the catch is cut corners. It is not. The catch is that the way of working changed.

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

We learn the business 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, our own gym, that meant the real dues schedule, what happens when a member travels or gets hurt, and how the coaching method builds a week of training. For a four-store retailer it meant which screens hang where, what each one shows, and how often stock drifts from the boards.

That knowledge is what we turn into software. It is also what makes the AI useful. A model can connect to Stripe in an afternoon. It cannot know that this gym needs pause and resume, and a check so dues never fail quietly. We bring that 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 the same is how you get sloppy work.

  • Claude Code is the builder that lives in the codebase. It reads the whole project, runs commands, writes and edits files, and keeps the design in its head. It carries a feature from an idea like "member portal" to working code wired into the real system.
  • Codex is the second pair of eyes and the extra pair of hands. We give it the tightly scoped pieces: clean-ups, test passes and "go check this" jobs, so the main work keeps moving on the hard part.
  • Both are wrong sometimes. The whole way we work is built around catching that, not pretending it does not happen.

Small, checkable steps beat big prompts

The biggest mistake people make with these tools is asking for too much at once. "Build me a gym platform" gives you 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 Sunday billing, run it with test cards, confirm an invoice really goes out, then move on.

That is why every project has a live copy and a test copy. The gym's system has both, so we ship and test without touching live members.

Before a single member's card was charged, the billing ran for a week against test payments, in cases shaped like real ones: tax added twice, the same payment notice arriving twice, odd card setups.

AI writes fast. The discipline is refusing to trust it until you have watched it work.

The part that adds up: we run what we build

Shipping fast would be a gimmick if the systems fell apart after launch. They do not, because the same team that built them runs them. The retailer's 31 store screens update themselves every day, and we update all of them from one dashboard. Persistence ships new features every week to a live beta.

Running it is also what keeps the AI honest over time. When you are the one who gets the call, you do not let the model leave you a mess you cannot fix 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 knowledge of the business up front, so the AI solves the right problem instead of a generic one.
  • One connected system per client instead of six tools stitched together, so there is less glue to look after.
  • Small steps with a check at the end of each, run on a test copy that matches the live one.
  • Claude Code for the deep build, Codex for the scoped work on the side, and a person reviewing both.
  • Running the thing afterward, which forces quality and makes a launch the start, not the end.

The honest caveats

This is not a button you press. The AI makes up things that don't exist, picks the plausible wrong approach, and writes code that runs and is still quietly broken. We found the tax-added-twice bug and a surprise with Stripe Link by digging through the billing ourselves, not because the model told us.

None of that is a reason to skip the tools. It is the reason a person stays in the loop, reads every change and tests against reality. The speed comes from the model doing the typing, the searching and the routine code. 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 way of working: learn the business, build in small checkable steps, use the right model for the right job, keep a person on every change, and run what you ship so it gets better instead of older.

Do that, and a tiny team really can ship agency-scale systems in weeks. Your business, on autopilot.

Tell us what eats your week.

A free 20-minute call. We'll show you what we would take off your plate.

Book a call