TL;DR
The short version
Four engineers and one designer rebuilt a tier-one Gusto product in 10 weeks by throwing out docs, Figma, Jira, and meetings. They kept one thing: a Zoom room running 24/7.
The point isn't the speed. It's what becomes cheap enough to throw away once writing code costs almost nothing, from the coordination process to the prototypes to a leader's distance from the work. Drawn from Eddie Kim, Gusto's CTO, on Claire Vo's How I AI.
Built on Eddie Kim's conversation with Claire Vo on How I AI, cross-checked against Gusto's own launch announcement.
It started on a missed flight
Eddie Kim, Gusto's CTO and co-founder, vibe-coded a prototype during a five-hour layover in London. By the time he landed in San Francisco he had a rough version of what became Gusto Cofounder, an AI agent that runs payroll and HR for small businesses.
The team was four engineers, Eddie counted himself as one, and one designer. No product manager. In a roughly 1,000-person R&D org, they peeled off five people and shipped a real product line in under a quarter.
Gusto company news, June 2026
They deleted the process, not the rigor
The method was defined by what they removed. The only structure they kept was a Zoom room running 24/7: people sat in it quietly, popped in to ask a question, pulled someone into a breakout to review code. The only documentation the whole project produced was one photo of a whiteboard.
We had no meetings. We had no text backs. We had no Figmas. We had no Jira board. We had no stand-ups, no retros. We had nothing.
Eddie Kim, CTO of Gusto
This isn't a story about working harder. It's about removing a coordination layer that existed to manage expensive work, once the work stopped being expensive.
The pull request became the spec
When code is cheap to write, you can decide what to build by building it. Their loop: write a feature as a real, review-ready pull request, not a draft. Discuss it live. Merge it, or close it and delete the code. "It's not slop," Eddie says of the discarded PRs. "You actually spent time to make sure this code works, and then you just close it sometimes."
Eddie felt the discomfort firsthand. On day one an engineer suggested rebuilding his prototype from scratch on a Cloudflare Worker. He didn't want to, it was his code, it was good code. They deleted it and started over, which he now calls the best decision they made.
The stack underneath is almost boring: Cloudflare Workers for the agent loop and the Vercel AI SDK, nothing else. "Memory to us is a tool that writes to a database column called memory," Eddie says.
Ship a fake, then breathe life into it
The most copyable tactic came from Katie, the designer. She shipped a faked experience to production: the real UI, behind a feature flag, returning the same canned response every time. Pure front end, no agent, no database.
Then engineers built the data models and the agent loop underneath and wired them to the front end that already existed. The UI stayed put while the canned answers quietly turned real. At any given time something in production was wrong, and over time it became right.
Katie, who isn't a trained engineer, landed in the 94th percentile of pull-request throughput across Gusto's entire R&D org. Eddie's explanation: engineers paired with her on prompting and on judging good code, instead of asking her to hand over Figmas. Median PR review on the team was about nine minutes.
The leadership lesson is the real one
It's tempting to read this as a process hack. Eddie pushes past that. A prototype, he warns, can make a leader under-appreciate how much real work production takes, so he went into individual-contributor mode for ten weeks and hit the 95th percentile on engineering throughput. "Don't just stop at a prototype if you're a leader. Actually be hands-on in merging real, reviewed, high-quality code."
He's also clear on why this is hard to copy. As a co-founder he had implicit permission to break every rule Gusto had. Other teams don't, so his fix is to make permission explicit, then go further: don't just allow teams to skip docs and Figma, forbid them.
The boundary matters. Eddie scopes the claim: docs are dead "for a subset of projects, more zero-to-one." This worked because the team was tiny, the project was new, and a founder was in the room. The transferable parts are smaller and safer. Ship a faked front end behind a flag and fill it in. Treat pull requests as the unit of decision. Review your non-engineers' code as fast as your engineers'. And if you lead, get your hands back on the work, because you can't design AI products you don't use.
