$24,000 and Two Weeks

A developer named Theo just ported the entire TypeScript compiler to Rust. He spent about $24,000 in Claude API calls and it took roughly two weeks. The result passes all 181,711 tests and type-checks code 1.6 times faster than Microsoft’s own Go version. Oh, and Theo says he never read a single line of the generated code.

That paragraph should stop you in your tracks. Not because of the technical achievement — though porting a compiler is genuinely hard — but because of what happened before it worked.

The $400,000 failure

Before Claude touched this project, Theo had already been at it for five months using other AI models. He ran automated coding loops with GPT-5.6 Sol and GPT-6 Astra. Those agents generated over 1.3 million lines of Rust code. The total API bill crossed $400,000. And the result stalled at about 84% compatibility. Close enough to be tantalizing. Not close enough to ship.

Five months. Four hundred thousand dollars. A million lines of code. And it didn’t work.

Then he switched to Claude Opus 5.5. The model looked at the existing codebase, judged it unrecoverable, and started from scratch. It produced a working first version in ten hours. Within two weeks, it passed every single ported test.

I’ve been building with Claude daily for over a year. I use it for everything from writing books to developing my poker trainer to deploying this website. But this story hit differently. Not because it’s about Claude specifically — though I won’t pretend that doesn’t matter to me — but because it crystallizes something I’ve been trying to articulate for months.

Model choice is the new skill

The same task can be impossible with one model and trivial with another. That’s the lesson buried in these numbers. This wasn’t a matter of tweaking prompts or adjusting temperature settings. One family of models generated a million lines of dead-end code. A different model threw it all away and solved the problem in a fraction of the time and cost.

For anyone who builds with AI, this changes the calculus. We tend to pick a model and stick with it. We learn its quirks, build our workflows around its strengths, and optimize our prompts for how it thinks. That’s fine for daily work. But for ambitious projects — the kind where you’re pushing into territory you haven’t mapped yet — the most important decision might not be what you prompt. It might be who you prompt.

After thirty years in cybersecurity, I know that choosing the right tool for the job isn’t a nice-to-have. It’s the whole game. A penetration tester who only knows one framework will miss vulnerabilities that a different approach would catch in minutes. The same principle applies now to AI-assisted building. Your model is your instrument. Know more than one.

What $24,000 buys you in 2026

Let’s put the cost in perspective. Twenty-four thousand dollars to port a compiler that millions of developers depend on. A compiler. The thing that turns human-readable code into something machines can execute. This is core infrastructure, not a weekend side project.

A traditional engineering team doing this port manually would need multiple senior Rust developers working for months, possibly years. The budget would run into the millions when you factor in salaries, benefits, code review, debugging, and testing. And there’s no guarantee it would perform better than what Claude produced.

I think about this in terms of my own work. I self-published two books. The first one took a year of my life. The second, with Claude as my collaborator, took a fraction of that. But a compiler port? That’s orders of magnitude more complex than anything I’ve attempted. And someone just did it for the cost of a used car.

We keep talking about AI democratizing creation. This is what that actually looks like. Not making easy things easier. Making previously impossible things possible for people who have vision but not a hundred-person engineering team.

The part that should make you uncomfortable

“I’ve never read a line of this code.” That’s what Theo wrote in his README. He directed the AI, evaluated the outputs by running tests, and shipped the result. But he never read the code itself.

This is the frontier we’re standing on right now. The code works. It passes 181,711 tests. It runs faster than the official version. But the person who shipped it can’t explain why any particular function does what it does. He knows what the system does. He doesn’t know how it does it.

For some people, that’s disqualifying. For others, it’s just how things work now. I land somewhere in the middle. When I use Claude to help build my poker trainer, I read the code. I understand the logic. I make architectural decisions. But I also know there are pieces — utility functions, UI components, data transformations — where I trust the output because the tests pass, not because I reviewed every line.

The honest answer is that this is how we already work with most software. You don’t read the source code of your database engine or your operating system kernel. You trust it because it works, because others have tested it, because the results are verifiable. AI-generated code is heading to the same place. The question isn’t whether you personally read it. The question is whether the verification is rigorous enough to earn trust.

What this means for the rest of us

You don’t need to port a compiler. That’s not the point. The point is the ratio. $24,000 and two weeks versus $400,000 and five months of failure. A 94% cost reduction and a project that actually works. That ratio applies everywhere.

If you’re building an app, a tool, a content system, or automating part of your business — the gap between what’s possible and what you can afford just collapsed again. The projects that felt too ambitious last month might be within reach this month. Not because you got smarter or richer. Because the tools got that much better, that much faster.

I keep coming back to a question I ask in my book: what would you build if the only limit were your imagination? Every week that question gets less hypothetical. Every week the answer gets bigger.

So what’s the project you’ve been putting off because it seemed too big? Because the cost just dropped again.