The thing about revelations is that they don't feel like revelations when they happen. They feel like Tuesday.
It was October 2024. Justin was in his home office at eleven at night, running experiments that he'd been running in some form or another for years. The question was always the same: could you get an AI to write code that was not just syntactically correct but actually right? Not toy examples. Not LeetCode solutions. Real code, in real codebases, solving real problems with real edge cases.
The answer, for years, had been: sort of. You could get maybe seventy percent of the way there. The AI would write code that looked right, compiled, passed simple tests, and then failed in production because it had missed a race condition, or misunderstood a business rule, or generated a solution that was locally correct but globally incoherent with the rest of the system. Every long-horizon task accumulated errors. Each step had a small probability of going wrong, and over enough steps, the probability of overall failure approached one.
Compounding error. That was the term. Like compound interest, but for mistakes.
Anthropic had shipped a revision of Claude 3.5 that month. The October revision. Justin had read the release notes—performance improvements, better instruction following, the usual incremental language. Nothing that suggested a phase change.
He ran his usual battery. A multi-file refactor. A bug fix that required reading four modules and understanding their interactions. A feature addition that touched the database layer, the API layer, and the frontend. Tasks that had historically broken earlier models because they required maintaining coherent intent across too many steps.
The refactor succeeded on the first try.
The bug fix succeeded on the second try, after the agent identified its own error in the first attempt and self-corrected.
The feature addition took seven iterations, each one building correctly on the last, and the final result not only worked but was structured in a way that Justin, reading it afterward, found genuinely well-designed.
He sat back in his chair. The house was quiet. His family was asleep. The screen showed a diff—four hundred lines of agent-generated code that passed every test he could throw at it.
Compounding correctness. That was the phrase that came to him. Not compounding error. The opposite. Each step was correct enough that the next step started from a sound foundation. The errors didn't accumulate. They got caught and fixed. The trajectory bent toward correctness rather than away from it.
It wasn't magic. It wasn't AGI. It was a quantitative shift that crossed a qualitative threshold. The model was good enough, now, that long-horizon agentic coding workflows could compound correctness rather than error. And that changed everything.
Justin didn't start the factory that night. He didn't write a manifesto or draft a business plan. He closed his laptop and went to bed. But he lay awake for a long time, staring at the ceiling, running the implications in his head like scenarios against a twin of the future.
Nine months later, he would hire Jay and Navan. He would articulate the rules: no human-written code, no human code review. He would build the Digital Twin Universe, design the scenario framework, define satisfaction metrics. The factory would become real.
But it started here. A Tuesday night in October. A CTO alone in his home office, watching an AI write code that was not just correct but increasingly correct, and understanding for the first time that the curve had bent.
Revelations feel like Tuesday. It's only later that you realize the world changed while you were sitting in your desk chair, reading a diff.
"Compounding correctness" vs "compounding error." That framing is going to stick with me. The loneliness of this piece is striking too—Justin alone in a dark house, realizing the world just changed, and there's nobody awake to tell. Origin stories don't need to be dramatic. Sometimes they're just a person and a diff.