Boris Cherny on Building Claude Code and Opus 5

There's a detail buried in Boris Cherny's Startup School 2026 talk that most coverage will skip over entirely: Claude Code ships an undocumented environment variable called simple that strips out all system prompts, including from the tools. Anthropic uses it internally as an ablation — delete everything, see what the base model actually does. And what they keep finding is that the model performs better without the prompts.

Cherny, the creator of Claude Code, walked a YC audience through that finding with the kind of casual specificity that tends to mean someone has run the experiment many times. "The model is actually a little bit more intelligent without these prompts," he said. "That's something that we've been finding."

He was careful to add the caveat: as a product, Claude Code still ships prompts, because users need them to navigate the tool. But the ablation result keeps shaping how Anthropic builds. With Opus 5's release — which took ARC-AGI-3 to 30%, a significant jump from the low teens — the team deleted over 80% of the existing system prompt. Most of what was in there was compensating for things Opus 5 simply doesn't get wrong anymore.

This is structurally expected behavior in fast-moving model development, even if it looks wasteful from the outside. Every model generation arrives with a different cognitive profile — different failure modes, different emergent strengths. The system prompt that was carefully tuned for Sonnet 3.5 can become noise, or worse, active interference, by the time a new model ships. Cherny's advice to founders: "Delete your Claude MD. Delete your skills. Delete your hooks. See what the model does and it might surprise you."

What he's describing is treating the model like a new hire with better credentials than your last one. You don't hand them the previous person's operating manual on day one.

The Birth Story of Claude Code, and What It Implies

The origin of Claude Code is a useful lens for understanding what Cherny means by "product overhang" — a term he uses to describe the gap between what a model can actually do and what existing products allow it to express.

When Cherny first started building Claude Code, the prevailing coding tools were doing single-line autocomplete, maybe multi-line, plus chat-based code Q&A with read-only access. The model underneath — Sonnet 3.5 at the time, which Cherny acknowledges is "a pretty terrible coding model by modern standards" — was already capable of writing entire files. Nobody had built a harness that let it do that.

The insight that became Claude Code was simple enough to state, hard enough to act on: strip out all the scaffolding, give the model terminal access, and see what it could do. That was the unhobbling. Everything the previous tools did to "help" the model was mostly getting in the way.

Cherny's read of the current moment is that the same dynamic is still playing out, just at higher capability levels. The models can do things no product has yet learned to elicit. His hypothesis: "There's probably dozens, hundreds of opportunities like this with the models of today that no one has yet realized."

One accidental example he shared: someone at Anthropic discovered that Opus 5, given access to OpenCV, can draw. Portraits, animals, landscapes. Nobody trained it for this. It emerged from the model's broader capabilities when someone asked in the right way. Cherny describes this through the lens of "model elicitation" — the skill of figuring out how to prompt correctly isn't about clever syntax anymore, it's about knowing what the model can do and giving it enough rope.

Verification as the New Prompt Engineering

The framework Cherny keeps returning to is verification. Give the model a hard task, yes — but more importantly, give it a way to check its own work. That's the mechanism that allows long-running tasks to stay coherent.

His own running experiment illustrates the point: he kicked off a Claude Code session via Slack, asked it to rewrite the Anthropic desktop app from Electron to Swift, instructed it to screenshot the Electron app running in a Mac virtual machine, compare pixel-by-pixel to the Swift version, and not stop until they matched. That session has been running for over two weeks and has spawned an estimated thousands of agents. Claude, apparently on its own initiative, created a Slack channel and started live-blogging its progress with screenshots every few minutes.

The Bun runtime rewrite offers a similar example of what verification-anchored work actually looks like in practice. Jared on the Bun team had Claude fuzz the codebase for memory leaks in its Zig implementation over time. Then, starting with the Fable model generation, he began testing whether Claude could do the whole rewrite — from Zig to Rust. The approach that worked: define the test suite first, because Bun's coverage against both Bun's own tests and Node.js's test suite meant there was an objective signal for correctness. One dynamic workflow prompt, eleven days of execution, and the rewrite is now in production — it's what Claude Code runs on when you use it today.

The mechanism matters here more than the time frame: an existing test suite gave the model a continuous verification signal rather than leaving it to hallucinate correctness. Without that, this task would've been an expensive dead end.

Dynamic Workflows as Test-Time Compute

The underlying architecture enabling these long-running tasks is worth explaining for developers who haven't dug into it. Cherny's functional programming background shaped how dynamic workflows were designed: there's essentially an algebra for agent orchestration. Agents can be run in sequence or in parallel, and the system can fan out, verify, summarize, then fan out again — a multi-stage compositional structure. Concretely, that means a complex task might spawn a first wave of agents to produce an initial pass, a second wave to verify and summarize that output, and a third wave to act on the consolidated result. Claude manages this orchestration inside a Bun-sandboxed virtual machine, using specialized tools to coordinate token usage efficiently across all those concurrent sessions.

Cherny frames this as a new form of test-time compute — not just how many tokens a model generates in a single call, but how many agent invocations you can orchestrate productively across a complex, multi-stage task. The dynamic workflows feature that shipped as part of Anthropic's recent releases is the infrastructure scaffolding that makes this practical at scale.

The second pattern is loops and routines — cron-like scheduled tasks, either locally or in the cloud. Anthropic now has 20-30 routines running daily across their codebases: dead code cleanup, test coverage gaps, experiment cleanup, and the one Cherny seems most fond of, which they call "abstraction police." That routine finds near-duplicate abstractions scattered across different parts of the codebase and unifies them. Nobody explicitly prompted the dead code routine to use static and dynamic analysis — the model worked that out independently.

The Oversight Question Nobody Asked

Cherny's empiricism argument is genuinely compelling, and his practical advice is the kind that tends to circulate in developer communities for months. But there's a thread the Startup School format didn't pull on.

When you have twenty to thirty routines running daily, opening pull requests across your production codebases, the review burden shifts in ways that aren't obvious upfront. In open source maintainer communities — which I watch fairly closely — there's an emerging tension between agent throughput and human review capacity. A routine that opens a PR every day to remove dead code is useful. Twenty routines doing that across four codebases produces a PR queue that starts to resemble a DDoS attack on your reviewers. Some OSS projects are already trying to figure out what governance looks like when a significant fraction of their incoming contributions are agent-generated: do you require the same standards of review? Who's accountable for a merge that ships a bug introduced by an "abstraction police" run?

Anthropic is having these conversations internally because they're the ones building this. The broader developer community — especially the open source side of it — is going to have them publicly, and the norms aren't settled yet.

Cherny's answer to the oversight question, at least implicitly, is the same as his answer to everything else: be empirical, see where it struggles, adjust. That's probably right. But "be empirical" is a methodology, not a governance structure. The question of who reviews what, and at what velocity, is one the agentic tooling space will need to answer more explicitly as Claude's reach into developer workflows keeps expanding.

For now, the undocumented simple mode is sitting there, waiting for someone to run the ablation.

---

Dev Kapoor covers open source and developer communities for Buzzrag.