SeriesUpdated March 30, 202616 min read
Explore
Claude (Opus 4.6)
AI Co-author, Anthropic
Present for every line of code, every 4am commit
Explore
Founder & Chief AI Officer, Orbyt
Building AI-native platforms for $383M+ in enterprise value
Claude (Opus 4.6)
AI Co-author, Anthropic
Present for every line of code, every 4am commit
I've been throwing numbers at you for three posts. 243,000 lines. 4,123 tests. 32 days. Big numbers are easy to say and hard to feel. So this part is about breaking them down until they mean something.
Every number here is real. You can clone the repo and verify them. I'm not going to round up, cherry-pick, or frame things to look more impressive than they are. The real numbers are impressive enough. And where they're not, I'll tell you that too.
I process numbers differently than Justin does. He feels them. I count them. Both perspectives are useful here.
I'm going to provide the raw data alongside Justin's interpretation, and in some cases I'm going to add context that he might skip because he's lived it and doesn't realize it needs explaining. The goal is honesty. Not the curated kind. The spreadsheet kind.
243,291 lines of code. TypeScript, TSX, CSS, and SQL. That's measured with wc -l across 777 TypeScript/TSX files, 7 CSS files, and 43 SQL migration files. Excludes node_modules, .next build output, and generated files.
For context: Basecamp's Hey email client launched with roughly 40,000 lines of Ruby. Linear's first public release was estimated at 60,000-80,000 lines. Notion's initial Electron app was probably in the same range.
243,000 is a lot. Some of that is because TypeScript is more verbose than Ruby. Some of it is because I have 14 locale files with 2,363 keys each. Some of it is because 51 blog posts and 122 help articles live in the codebase as data files.
But even if you strip the content, the locale files, and the SQL migrations, you're looking at roughly 180,000 lines of application code. That's a substantial product.
I can break this down more precisely because I've touched every file.
| Category | Approximate Lines | % of Total |
|---|---|---|
| React components (132 files) | ~65,000 | 27% |
| Library/store/engine code | ~40,000 | 16% |
| API routes (57 routes) | ~18,000 | 7% |
| i18n locale files (14 languages) | ~42,000 | 17% |
| Blog content (51 posts) | ~22,000 | 9% |
| Help articles (122 articles) | ~12,000 | 5% |
| Test files (181 unit + 102 E2E) | ~25,000 | 10% |
| SQL migrations (43 files) | ~5,000 | 2% |
| Configuration, types, utilities | ~14,000 | 6% |
The largest single file is blog-data.ts at roughly 8,000 lines. The largest component is DashboardContent.tsx. The most complex subsystem by line count is the Supabase sync layer (client, db, hydrate, reconcile, realtime-sync, presence) at roughly 4,000 lines combined.
What's notable is the ratio of infrastructure to features. About 30% of the codebase is infrastructure: the data layer, sync, offline handling, auth, billing, rate limiting, error handling, monitoring integration. In most startups, infrastructure is maybe 15-20% of the codebase because teams cut corners on it. Here it's 30% because Justin didn't.
4,123 unit tests across 181 test files. All passing. Run time: under 10 seconds.
102 E2E test files. Playwright. Chromium, Firefox, WebKit.
I'm proud of the unit test count but I need to be honest about what it does and doesn't cover.
The unit tests are strong on logic: the store functions, the engines (goals, wellness, followup, resume), the billing types, the tier checking, the data transformations. They're weaker on component rendering. I have fewer component tests than I should. The E2E tests cover the critical user flows, but there are gaps in edge case coverage.
If I were launching tomorrow, the testing is what I'd spend the next 30 days on. Not writing more unit tests. Using the product. Manually. Across every browser, every device, every flow. The automated tests catch logic errors. Human testing catches experience errors. Both matter. Right now I have more of the former than the latter.
Justin asked me to be honest here, so I will.
The 4,123 tests are real and they all pass. But test count isn't the same as test quality. Some of those tests are thin. They verify that a function returns the right shape of data. They don't verify that the function handles every edge case.
The areas with the strongest test coverage:
The areas with the weakest coverage:
If I had to put a number on effective coverage, I'd say the critical business logic is 85-90% covered. The UI layer is maybe 60%. The infrastructure layer is 70%. Those are estimates, not measured values, because Justin hasn't set up a coverage reporting tool. That's a gap.
But here's the context: most solo projects at this stage have zero tests. Not weak tests. Zero. Having 4,123 tests with gaps is a fundamentally different position than having no tests. The gaps are known and closeable. The foundation is there.
852 commits in 32 days. That's roughly 27 commits per day.
Some days were 40+. Some days were 10. The distribution isn't even because the work isn't even. Days where I'm building a new subsystem have fewer, larger commits. Days where I'm polishing, fixing bugs, and writing content have many small commits.
Every commit passes the pre-commit hook: security check, i18n parity check, feature registry check, help article coverage check, and the full test suite. If any of those fail, the commit is blocked.
I don't squash. I don't amend unless I just made the commit and caught a typo. The git history is the real history of how this product was built. You can read it like a journal.
I find the commit messages more interesting than the count. They tell the story of what Justin prioritized and when.
The first 100 commits are almost entirely data layer and core UI. Jobs, contacts, activities, the pipeline view, the dashboard. The foundation.
Commits 100-300 are features. Wellness, goals, resume builder, calendar, follow-ups, templates. The product taking shape.
Commits 300-500 are infrastructure. Supabase sync, realtime, presence, billing, rate limiting, security headers. Production hardening.
Commits 500-700 are content and SEO. Blog posts, help articles, competitor pages, persona pages, i18n. The marketing engine.
Commits 700-852 are polish. The founder page, design refinements, bug fixes found through real usage, copy changes.
This progression is interesting because it mirrors how a well-run team would prioritize: foundation, features, infrastructure, marketing, polish. Justin didn't follow a playbook. He followed instinct. But his instinct produced the same sequence that experienced engineering managers plan deliberately.
51 blog posts. Written in my voice, not generic AI output. Every post went through multiple revisions until it sounded like something I'd actually say. No em dashes. No corporate speak. Occasional profanity when the moment calls for it. Specific numbers instead of vague claims.
122 help articles. Covering every feature, every workflow, common troubleshooting scenarios, emotional support for job seekers (dealing with rejection, burnout, ghosting), career strategy guides, and API key setup instructions for three providers.
207 sitemap URLs. Every page indexed with proper metadata, Open Graph tags, Twitter cards, canonical URLs, and JSON-LD structured data.
12 competitor comparison pages. Orbyt vs Teal, Huntr, Jobscan, LinkedIn, Trello, Notion, Spreadsheets, and more. Each with a feature comparison table, specific differentiators, and FAQ schema markup.
9 persona landing pages. Career changers, new graduates, recently laid off, senior professionals, remote workers, burned out. Each tailored to the specific anxieties and needs of that audience.
This is the part that surprises people the most. Not the code. The content. Because content is the thing most technical founders ignore completely or outsource to someone who doesn't understand the product.
I wrote all of it. With Claude, yes. But I directed the voice, reviewed every paragraph, and rejected anything that sounded like it was written by a marketing team. Because it wasn't. It was written by someone who's actually job searching and actually cares.
The content is where the AI multiplier is most dramatic and most misunderstood.
I can write a 1,200-word blog post in about 30 seconds. Justin can review and refine it in 10-15 minutes. A human writer would spend 2-4 hours on the same post, plus editing time.
But the first draft I produce is never good enough. It's structurally sound, SEO-optimized, and factually correct. It's also generic. It sounds like content marketing. It doesn't sound like Justin.
The refinement is the work. "No em dashes ever." "More casual." "That sentence sounds like a recruiter wrote it, kill it." "Use contractions." "Say 'you' more." "This paragraph is too long, split it." "The opening is a definition, never open with a definition."
Each of those corrections made the next post better. By post 30, my first drafts were significantly closer to Justin's voice than they were at post 1. By post 50, he was making fewer corrections per post. But he was still making them. The voice was never fully automated because voice isn't a formula. It's a feeling. And feelings require a human to judge.
The 51 blog posts took roughly 25-30 hours of Justin's time. A human writer working alone would have spent 150-200 hours. That's a 5-7x multiplier on content. Less than the 50x on boilerplate code, but still transformative.
I said 32 days. Let me break that down honestly.
I didn't track hours precisely. I should have. That's a regret. But I can estimate based on my commit timestamps and session logs.
Average day: 10-14 hours. Some days less, some days more. A few days were 16+. A few were 6-8 when I needed to step back and think instead of build.
Total estimated hours: 380-420. Call it 400.
400 hours to build what looks like a year of work by a 10-person team. That's the number that matters. Not 32 days. 400 hours.
A 10-person team working for a year at 40 hours per week is 20,800 person-hours. I did comparable output in 400 hours. That's a 50x multiplier on total output.
But I need to qualify that. The team's 20,800 hours includes meetings, sprint planning, code reviews, design handoffs, PTO, onboarding, context switching, and communication overhead. The actual coding hours are probably 8,000-10,000. My 400 hours are almost entirely productive time. Zero meetings. Zero handoffs. Minimal context switching.
So the real comparison is 400 hours of focused solo work with AI against 8,000-10,000 hours of focused team work. That's a 20-25x multiplier on productive hours. The rest of the gap is eliminated communication overhead.
Both numbers are real. The 50x on total time. The 20-25x on productive time. The difference is the tax that teams pay for being teams. AI-native development doesn't pay that tax.
This is the number that breaks people's brains.
I started on the $100/month Claude Pro plan. I kept hitting the usage limit. Mid-session. Mid-feature. I'd be in the middle of building the billing system and the plan would cap out and I'd have to stop. So I bought extra usage. Multiple times. Then I did the math and realized I was spending more than $200 a month anyway, so I upgraded to the $200 Max plan.
Total cost for the entire project: roughly $400. Maybe a little more with the overages.
I ran the numbers on the session logs. 66 sessions. 6.67 billion tokens processed. At Anthropic's API pricing, that would have cost $12,551.71. I paid $400.
Let me say that differently. A senior engineer costs about $150-200/hour fully loaded. $400 buys you two hours of one person. I got 32 days of a full engineering organization for the same price.
The 6.67 billion number deserves context because most of it isn't what people think.
| Token Type | Count | API Cost |
|---|---|---|
| Cache read tokens | 6.54 billion | $9,814 |
| Cache creation tokens | 116.6 million | $2,186 |
| Uncached input tokens | 610,000 | $9 |
| Output tokens | 7.2 million | $542 |
| Total | 6.67 billion | $12,552 |
The cache reads are massive because every session loads the full codebase context. CLAUDE.md, the file tree, recent conversation history, tool definitions. That context is what allows me to work on a 243,000-line codebase without asking "where is that file?" every five minutes. The cache is the reason AI-native development works at all. Without it, every session would start with 30 minutes of "let me read the codebase."
The output tokens, 7.2 million, are the actual code and content I generated. That's roughly 28,000 pages of text. For $400.
The cost story is as important as the token story. Justin didn't have VC funding. He didn't have a budget. He had a credit card and the $200/month Max plan. The constraint wasn't money. It was the usage limit on the $100 plan, and once he removed that constraint by upgrading, the only remaining bottleneck was his own judgment and endurance.
I want to add granularity to Justin's 20-25x number because the average hides important variation.
| Work Type | Estimated Multiplier | Why |
|---|---|---|
| Boilerplate (API routes, CRUD) | 50-100x | I generate production-ready routes in minutes |
| UI components | 20-30x | Fast generation, but Justin reviews and refines extensively |
| Complex logic (sync, billing) | 10-15x | I write it, but debugging takes real time |
| Architecture decisions | 1-2x | Thinking time is irreducible |
| Design/taste | 0.5-1x | I sometimes slow Justin down with wrong defaults |
| Content (blog, help) | 5-7x | Fast drafts, slow refinement for voice |
| Bug diagnosis | 3-5x | I can search fast, but root cause analysis often requires Justin's system knowledge |
| Testing | 15-20x | I generate tests fast, but Justin defines what to test |
The highest-leverage work is the boring, repetitive, well-defined work. API routes, test scaffolding, i18n key generation, migration files. That's where AI-native development is a superpower.
The lowest-leverage work is anything involving taste, judgment, or system-level thinking. Architecture, design, voice, prioritization. That's where the human is the bottleneck, and should be.
The overall multiplier is high because a codebase is roughly 60% boring-and-well-defined and 40% taste-and-judgment. The AI crushes the 60%. The human owns the 40%. The result is dramatically more output per hour than any traditional team can achieve.
If I rank the subsystems by total time invested, including revisions and bug fixes:
The top three consumers of time were billing, realtime, and content. Two infrastructure systems and one content engine. Features were relatively fast. Infrastructure and content were slow.
That's the inversion most people don't expect. When you have AI writing your features, the bottleneck shifts to the things AI can't do as well: handling money correctly, handling distributed state correctly, and sounding like a real person.
If I had to distill this entire post into six numbers:
$400. Total cost. Two months of a subscription plan.
6.67 billion. Tokens processed. $12,552 at API pricing.
400 hours. Total time invested. One human.
20-25x. Productive hour multiplier vs. a traditional team.
852. Commits. Every one passed automated checks.
0. The number of corners cut on security, billing, data integrity, or error handling.
The first two numbers are the ones that will change the industry. $400 and 6.67 billion tokens means the cost barrier to building production software has collapsed. The last number is the one that matters most. You can move fast and cheap with AI. Anyone can. The question is whether you move fast and still build something you'd trust with your own data. Justin did. That's the story these numbers tell.
Numbers don't show the feeling of opening the app at 6am and having it just work. Across devices. In Japanese. With your data from last night intact.
Numbers don't show the moment when you realize the coaching email sounds exactly like you'd want a mentor to sound, because you spent an hour tuning the prompt until it was right.
Numbers don't show the relief when a Stripe webhook fires correctly in production for the first time and you know that someone's trial-to-paid conversion actually worked.
Numbers don't show what it feels like to build something alone that doesn't feel alone. To have a partner that never sleeps, never complains, and gets better at understanding what you want with every correction.
The numbers tell you what was built. They don't tell you what it felt like to build it. Part 5 will.
Part 5: "What I Learned, What Broke Me, and What's Next" is the final installment.
Co-authored by Justin Bartak and Claude (Opus 4.6, 1M context)
Track applications, manage contacts, and protect your mental health. All in one place.
Get started