I Built a $640K SaaS Product in 5 Months

I started using Claude to write code in April 2025. At first I thought it was useful for prototypes, the kind of thing you’d throw together to prove a concept and then rebuild properly. By July I thought it was good enough for an MVP. By October I stopped qualifying it entirely and started building Voice Legacy, a production AI platform that interviews people about their lives and weaves those conversations into structured biographies.

Five months, 541 commits, and 80,000 lines of production code later, I ran a full development cost estimate on the codebase using industry-standard productivity rates and 2025-2026 market data. The engineering value came back at approximately $640,000. My total spend on Claude was about $3,000.

I need to be specific about my background because “non-engineer builds software” can mean a lot of things. I’m a product manager. I’ve been one for 20 years across eBay, Ariba and Xtime. Before that I was a mechanical engineering student at Purdue who took C and Java classes in the early 2000s. I understood loops and functions and data structures. I could read code. But I never built software professionally. I went into product management and I stayed there for two decades.

So when I say I’m not an engineer, I don’t mean I’m non-technical. I mean I haven’t written any code since George W. Bush was in his first term. I had enough foundation to know what a database index does, why you hash passwords, and roughly what an API endpoint looks like. That foundation mattered more than any single tool.

Andrej Karpathy coined “vibe coding” to describe accepting AI-generated code without really examining it. That’s fine for throwaway demos. What I did was different, and the distinction matters if you’re thinking about trying this yourself.

I learned how agentic AI systems work, not by writing the implementations, but by reading about the architectures and understanding enough to evaluate what Claude was producing. I kept tasks small and well-defined. I reviewed what went in. When something smelled wrong I’d spend an hour reading documentation before letting Claude proceed.

I’d call it structured AI-assisted development. The difference between vibe coding and what I do is the difference between using autocomplete and pair programming with a senior engineer who types 10,000 words per minute and never gets tired but also never pushes back unless you ask.

You talk to an AI agent called the Collaborator. It interviews you about your life the way a good journalist would, following threads, asking follow-ups, circling back to things you mentioned three sessions ago. It’s a conversation, not a questionnaire.

Behind that conversation, seven more specialized AI agents are working a pipeline:

The Memory Keeper pulls out people, dates, and places. The Story Extractor identifies narrative arcs within what you said. The Memory Weaver takes fragments from across multiple sessions and consolidates them into coherent stories. Theme Discovery finds patterns you might not see yourself, recurring threads about resilience or family obligation or wanderlust that run through your whole life. The Biographer synthesizes everything into a full biography and flags the gaps. The Ghostwriter produces polished chapter narratives. And the Portal Designer creates a themed public website where your family can read and share the whole thing.

Each agent runs on a different AI model matched to the complexity of its task. The Collaborator needs to be fast and warm, so it runs on Sonnet. The Biographer needs to hold an entire life in context and find the through-lines, so it runs on Opus. The extraction agents just need to be accurate and cheap, so they run on Haiku.

The technical stack is React and TypeScript on the frontend, Express and Node.js on the backend, PostgreSQL with pgvector for semantic search across stories, Firebase for auth, Stripe for payments, Resend for transactional email, Cartesia for voice synthesis, and OpenAI for embeddings and speech-to-text. Eight AI agents, 70 API endpoints, 30 pages, 61 database migrations.

I built this because when my father died, I had two voicemails and a lifetime of questions I’d never asked. Voice Legacy exists so other families don’t end up in that same position.

I didn’t just count lines of code. I audited the codebase to separate real production logic from scripts, dead code, copy-pasted vendor libraries, and a backup directory that inflated the raw count by 184,000 lines. I wanted defensible numbers, not impressive ones.

Core production logic: about 50,000 lines. That breaks down to 18,500 lines of React/TypeScript frontend across 30 pages and 81 components. 14,200 lines of Express backend covering 70 API endpoints, 14 AI agent tools, services, and middleware. 4,400 lines of AI system prompts across 38 files, each one tuned through dozens of iterations. 4,500 lines of SQL migrations representing the full schema evolution. 5,100 lines of email templates and 3,200 of CSS.

Another 30,000 lines of legitimate supporting code. Migration scripts, test harnesses, evaluation frameworks, deployment utilities, CMS schemas.

About 14,000 lines I threw out of the count. Dead code from an older architecture, UI library components I didn’t write, build artifacts, demo mockups.

Total honest codebase: roughly 80,000 lines.

For context, Zoom is reportedly around 60,000 lines. TikTok’s recommendation engine sits at about 80,000. A standard SaaS boilerplate ships with 15,000. So Voice Legacy is in the neighborhood of applications with real complexity, which honestly surprised me. I also know there’s bloat in there. I have one React page that’s 4,245 lines and should probably be 1,500. A senior engineer would refactor it in a day. I haven’t gotten to it yet.

I used industry-standard productivity rates for a senior full-stack developer with 5+ years of experience. AI agent logic and prompt engineering gets 12 lines per hour because that work involves iterative tuning, failure analysis, and a lot of testing against real conversations. API routes and business logic get 22 lines per hour. Frontend pages and components get 35. Database migrations and email templates land somewhere in between.

For the 50,000 lines of core production logic, that works out to roughly 2,800 base coding hours. The supporting code adds about 900 more. Then you apply the overhead that every real software project carries: architecture and design at 18%, debugging at 28%, code review at 12%, documentation at 12%, integration testing at 22%, and a learning curve premium of 15% for specialized tech like pgvector, Cartesia’s streaming voice API, and multi-model AI orchestration.

That gives approximately 4,300 human development hours total.

The $150/hour rate comes from current market data I pulled from ZipRecruiter, Glassdoor, Arc.dev, and Index.dev. It’s the going rate for a US-based senior developer with AI and full-stack specialization. Not Bay Area premium, not offshore discount. Standard US market for someone who can actually build what this codebase contains.

4,300 hours at $150 is roughly $640,000 in engineering value. If you staff this the way a growth-stage company would, with a PM, designer, QA engineer, engineering manager, DevOps person, and tech writer, the fully loaded team cost runs north of $1.4 million.

I analyzed all 541 git commits across 145 calendar days and clustered them into work sessions by grouping anything within a 4-hour window. That gave me 122 distinct sessions totaling about 225 hours of active Claude time. This was full-time work for me, not a side project.

| Metric | Number |

|--------|--------|

| Human equivalent hours | 4,300 |

| Claude active hours | 225 |

| Speed multiplier | 19x |

| Engineering value produced | ~$640,000 |

| Claude cost (subscription + API) | ~$3,000 |

| ROI | ~213x |

| Value per Claude hour | ~$2,844 |

A single senior developer working full-time at a lean startup, which in practice means about 26 hours of actual coding per week once you subtract standups, Slack, meetings, one-on-ones, and context switching, would need about 3.2 years to write this codebase from scratch. I did it in 5 months with an AI that cost me less than my monthly coffee habit.

I didn’t prompt Claude the way an engineer would. I prompted it the way a product manager would.

When I needed to build login functionality, I didn’t say “create a middleware function that validates a Firebase JWT token and attaches the decoded user to req.user.” I said something more like: “I’m building a login system using Firebase. Here are all the user types and what each one should be able to access. Here are the edge cases I can think of: what happens if a session expires mid-conversation, what happens if someone shares a link while logged out, what if two users are on the same device. Every database call and every API route should be scoped to the authenticated user so there’s zero chance of one person seeing another person’s data. Walk me through your approach before you write anything.”

That’s PM language. I described the behavior I wanted, the user experience I expected, and the failure modes I was worried about. I didn’t need to know what a JWT token was called to describe that no user should ever see another user’s stories. The technical vocabulary came later, after Claude explained its approach and I could connect the PM concept to the engineering concept.

This turned out to be the whole trick. Product managers spend their careers learning to describe complex systems in terms of user behavior, acceptance criteria, and edge cases. That’s exactly what AI needs to produce good code. Every prompt I wrote was basically a user story with detailed acceptance criteria, and Claude executed against it the same way a developer would execute against a well-written spec.

When I wanted to understand what Claude had built, I’d paste entire files or large sections back into a new conversation and say “explain this to me in English, walk me through what happens in order, and tell me why each piece is there.” I did this constantly with anything involving orchestration or sequencing, where the order things happen matters more than what each individual piece does. Understanding the flow of data through eight AI agents, for instance, matters a lot more than understanding the syntax of any one function.

Claude makes mistakes. It over-engineers things. It introduces subtle bugs. It will happily write a silent fallback where it should throw an error, and it won’t tell you unless you ask. I treated it like a talented but overconfident junior engineer: trust the output enough to use it, verify enough to sleep at night.

Now for what I got wrong. The codebase has bloat. My server.js is 4,678 lines, which is embarrassing. Some React pages are over 1,000 lines that should be broken into smaller components. Test coverage is thinner than I’d like. A CodeRabbit analysis of AI-co-authored pull requests found they contained 1.7x more major issues and 2.74x higher rates of security vulnerabilities compared to human-written code. I’ve done security audits, I validate inputs, I encrypt sensitive data, but I’d be an idiot to claim the code is flawless.

It doesn’t need to be flawless. It needs to work, handle user data responsibly, and be structured well enough that a real engineering team can build on it when the time comes. By those standards it’s holding up.

Y Combinator said 25% of their Winter 2025 batch had codebases that were 95% AI-generated. As of 2026, 92% of US developers use AI coding tools daily. Those numbers are only going in one direction.

Good engineers are more valuable than ever because the ones who know how to use AI tools are producing 10x to 20x what they could before. But the interesting thing is that the gap between “person with ideas and domain expertise” and “person who can build software” is shrinking fast.

If you have product sense, just enough technical literacy to understand what’s being built, and the discipline to keep AI focused on small well-defined tasks instead of letting it freestyle, you can build production software. Real software with real users and real payments and real complexity.

Henry Robinson is the founder of Voice Legacy, an AI-powered platform for preserving life stories. He’s been a product manager for 20 years and started building with Claude Code in April 2025.