CHAPTERS
- 0:00 – 4:59
Five people, 10 weeks: zero docs, perma-Zoom, and “just ship it”
Eddie Kim and Claire Vo set the stakes: Gusto Cofounder went from zero code to a tier-one launch in 10 weeks with four engineers and one designer. They emphasize how radically the team stripped process down to accelerate learning and shipping.
- •Cofounder built by 5 people in 10 weeks at a 1,000+ person R&D org
- •No meetings/specs/Figma/Jira/standups—process defined by what they removed
- •Perma-Zoom as the single coordination mechanism
- •Fast iteration enabled by Claude Code lowering the cost of code
- 4:59 – 8:58
The layover prototype: how Cofounder started from a Claude Code riff
Eddie explains the origin story: during a delayed trip home, he used a five-hour layover to prototype an idea with Claude Code. That prototype sparked internal interest, leading to a small group forming around the concept and pushing it to production.
- •Idea wasn’t on any roadmap; emerged from personal tinkering
- •Prototype built during a long layover using Claude Code
- •Shared via Loom; interest spread organically among senior ICs and a designer
- •Initial prototype evolved, but triggered the 10-week sprint
- 8:58 – 12:51
Anchor Week whiteboard to build sprint: the only “spec” they wrote
The team gathered during Gusto’s Anchor Week, reserved a room, and whiteboarded the core app structure. That photo became the sole durable artifact—everything else lived in code and ongoing discussion.
- •Anchor Week session used to align quickly and start building
- •A single whiteboard sketch served as the product blueprint
- •Team focused on core primitives (chat, tasks/automations, artifacts)
- •Deliberate refusal to create traditional documentation
- 12:51 – 14:50
Building without PMs: product decisions made in code review
Claire presses on how scope decisions happened with no product manager. Eddie describes a collective PM model where features are proposed as real pull requests, debated live, and either merged or deleted immediately.
- •Everyone acted as a PM; decisions made via discussion and demos
- •PRs functioned as both spec and implementation proposal
- •Immediate code review in the perma-Zoom enabled rapid decisions
- •Deleting fully-built features became normal because code cost is low
- 14:50 – 17:16
The “trash-can method”: deleting good code and rebuilding from scratch
They dig into a new reality: it’s now rational to discard working implementations or even rebuild V2 from zero. Eddie shares the emotional shift from protecting his prototype to embracing a clean restart for better architecture.
- •Trash code/close PRs is acceptable when iteration is cheap
- •Claire’s model: ship V1, then rebuild V2 cleanly if needed
- •Eddie’s prototype was deleted in favor of a new TypeScript/Worker approach
- •Cultural shift: less attachment to code, more attachment to outcomes
- 17:16 – 19:10
Minimal agent stack: Cloudflare Workers + Vercel AI SDK (and little else)
Eddie outlines Cofounder’s surprisingly simple technical architecture. Instead of complex agent frameworks, they rely on Cloudflare Workers for the agent loop and Vercel AI SDK, treating “memory” and planning as straightforward tools and data fields.
- •Cloudflare Worker runs the agent loop
- •Vercel AI SDK provides streaming/model flexibility
- •No heavy third-party harnesses for memory/planning
- •“Memory” implemented as a tool writing to a DB column
- 19:10 – 22:04
Shipping to production from day one: feature flags, fake UX, then “breathe life”
They describe a production-first workflow: a hidden page behind a feature flag was continuously improved in place. The designer shipped a fully ‘fake’ UI early, while engineers progressively replaced canned responses with real data/models until the prototype became real product.
- •Hidden production page behind feature flags as the integration surface
- •Designer shipped a fake front-end with canned responses first
- •Engineers built data models/agent loop in parallel and wired it in incrementally
- •Work progressed by “chipping marble”: always imperfect, steadily better
- 22:04 – 27:36
A designer becomes a top engineer: mentorship, reviews, and throughput
Eddie highlights designer Katie Kovalcin’s transformation into a highly productive engineer, ranking in the 94th percentile in PR throughput across Gusto. The key enablers were technical curiosity plus consistent engineering mentorship and fast, serious code reviews.
- •Katie ranked 94th percentile in PR throughput across the org
- •Code quality remained high despite non-traditional background
- •Engineers invested in pairing, review, and teaching Claude prompting
- •Cultural lesson: prioritize reviewing non-engineer PRs to compound impact
- 27:36 – 29:30
Startup intensity inside a big company: speed, fun, and small-team leverage
They reflect on how the approach felt like early startup days—everyone coding, minimal swim lanes, and high ownership. Eddie notes the pace required nights/weekends, but the team’s enthusiasm and tight feedback loops made it enjoyable and effective.
- •Throwback to early Gusto: designers coding, fewer swim lanes
- •High intensity (nights/weekends) emerged from passion, not mandates
- •Perma-Zoom enabled nine-minute median PR review time on the team
- •Small team size was intentionally protected early to keep velocity
- 29:30 – 32:28
Demo: Cofounder over SMS (and why messaging channels matter)
Eddie demonstrates interacting with Cofounder via text message to handle real HR actions, like approving time off. They discuss why SMS/Slack-first workflows fit small business operators and how messaging changes UX constraints (latency, streaming, clarity).
- •Cofounder supports SMS and Slack as primary interfaces
- •Same tools power web and messaging interactions
- •Example: approve an employee’s time off request via SMS
- •Messaging channels reshape product design for busy operators
- 32:28 – 36:38
Demo: running a real payroll from a Google Sheet with connectors
Eddie walks through a realistic payroll workflow where owners do “work before the work” in spreadsheets. Cofounder uses connectors (e.g., Google Sheets) to pull data, compute bonuses/tips rules, populate payroll, and ask for final confirmation to submit.
- •Customer example: massage spa using Mindbody exports + spreadsheet rules
- •Cofounder pulls sheet data, runs calculations, updates payroll entries
- •Rules include bonuses per upsell and pooled tip splitting
- •Stops for human confirmation before submitting payroll
- 36:38 – 39:39
Live coding workflow: Claude Code + evals + PRs as the delivery loop
Eddie shows how he uses Claude Code to fix a real customer issue by starting from a GitHub issue, writing a failing eval, implementing a fix, and proving it passes. The core discipline is reviewing what the agent writes—especially prompts/evals—before opening a PR for human review.
- •Prompt Claude Code with a GitHub issue link and desired approach
- •Write failing eval first, then fix, then prove with passing evals
- •Evals became the practical form of test-driven work for AI behaviors
- •Human judgment remains critical in reviewing prompts, evals, and changes
- 39:39 – 43:13
Recap: prototype fast, keep the team tiny, and make permission explicit
Claire summarizes the playbook: prototype to gain conviction, form teams around pull/interest, keep teams small, and remove heavyweight process. Eddie adds a key scaling insight: if a cofounder isn’t on the team, leadership must explicitly grant (and enforce) permission to skip docs and work differently.
- •Prototype to create belief and momentum
- •Team formed around who leaned in and was excited
- •Small team size as a force multiplier; expansion comes later
- •Explicit permission is required to break process norms without founders
- 43:13 – 50:48
Lightning round: docs for zero-to-one, leaders shipping real code, and prompting style
They close with rapid-fire takes: docs are largely unnecessary for zero-to-one work, and executives should move beyond prototypes to shipping reviewed production code. Eddie shares that hands-on tool use (e.g., OpenClaw) drove key insights, and he prefers polite prompts to encourage pushback and alternatives.
- •Docs ‘dead’ for many zero-to-one projects; agents may write docs for agents
- •Leaders should ship production-quality code, not just prototypes
- •Using AI products directly unlocks strategy and UX insight (OpenClaw example)
- •Prompting: be polite/open-ended to invite challenge; Claire uses a firm ‘No’ when needed
- 50:48 – 51:51
Where to find Cofounder: waitlist and feedback loop
Eddie shares where listeners can access Cofounder and invites signups and feedback. Claire closes the episode with subscription and review calls-to-action.
- •Cofounder available at gusto.com/cofounder via waitlist
- •Access granted within days; feedback encouraged
- •Claire offers to try beta and send product feedback/PRs
- •Show wrap-up: like/subscribe, comments, and podcast platforms
