About a year ago I joined Kash. Since then I've built, near enough solo, a system of 55-plus microservices. Event-driven, with a stack of edge functions, infrastructure-as-code, the database schema underneath, and four Next.js apps on top. It spans payments, blockchain, AI and social, and it's built to enterprise-grade resiliency throughout, because it moves real money.
The old way, that's twenty-plus people across several pods, a couple of years, and millions in salaries. I've had help. A designer on the UI, a teammate on the on-chain protocol. But the architecture and most of the stack is one head and a lot of Claude Code.
People hear that and reach for the obvious read: AI writes code fast, so one person goes faster. That's not really it. Writing the code was never the slow part.
The slow part was always the coordination. A team big enough to do the work has to be big enough to carry the cost of being a team. Specs, reviews, the meeting to agree on what was already obvious to whoever was building the thing. That overhead sits on top of the actual work, and it scales worse than the work does. AI plus one operator just deletes it. No handoff, no alignment meeting. I track the whole programme in markdown files in the repos, no Jira, no Trello. The work moves at the speed of a decision rather than the speed of a standup.
I've been building this way since late 2024. Copy-pasting into a browser at first, then Cursor and the rest, eventually Claude Code, where I settled, because it just performs. It's light and runs in the terminal, so I can have thirty or forty sessions open at once and actually hold the throughput. The hard part isn't any single session. It's sequencing yourself across all of them so the deployments land clean.
What's actually the cap
The easy answer is capacity, how much of the system you can hold in your head. I don't buy it, or not for long. AI holds the context and keeps the architecture in mind for you. It's working memory bolted on the side, and it keeps getting bigger. What it doesn't hand you is judgement. Knowing what's worth building, which complexity earns its place. That's the cap that doesn't move. It was never a tooling problem in the first place.
Which is why the unlock isn't evenly shared. The five years I spent running things, away from the keyboard, are what told me what to build. AI did the building. Put the judgement in and the throughput is a step-change. Leave it out and no amount of tooling covers for it. The operators who can hold the shape of a system and direct the work pull away from the ones who can't, and that gap is only going to widen.