Transcription
The engineer who created Claude Code sat down at Y Combinator this weekend, one day after Opus 5 shipped and told a room full of founders to delete their Claude MD files. Not tweak them, delete them.
Then he revealed that his own team deleted 80% of Claude Code's system prompt because the model got too smart for it. He shared the exact prompt he typed into Slack that has been running for two straight weeks. And he explained how an entire JavaScript runtime got rewritten in 11 days. We watched all 36 minutes, pulled the seven moments that actually change how you should build and fact-checked the wildest claims.
Moment one is the delete. That's Boris Churnney, the engineer who created Claude Code inside Anthropic and still runs it. He's on stage at Y Combinator's startup school with YC partner Diana, who one day after Opus 5 shipped and jumped the arc 3 benchmark from a previous best of under 8% to 30. The full talk is linked below and worth every minute. Here's what most people will scroll past.
Moment one, the interviewer brings up the new release and Boris confirms something almost nobody noticed in the patch notes. They deleted most of Claude Code's own system prompt. Listen to why.
>> I think something that a lot of people might not realize is, um, Claude Code as a product and as a harness is just always changing. We're always adding stuff. We're always deleting stuff. Every time that a new model comes out, we delete a bunch of the system prompt, change a bunch of the system prompt, we change the set of tools all the time, we change the prompts for the tools all the time. And the reason is, every model is very different. So something that you did for one model maybe three months ago, it just might not translate at all to the next model. And so one thing about Opus 5 is, it's just really intelligent. And a lot of the stuff in the system prompt was correcting for these behaviors that the model should have known, but, uh, it didn't. Now Opus 5 just does it. So, yeah, we deleted 80% of the system prompt. You can actually try deleting the rest of it too. Um, so when you run Claude Code, you can just do like, dash system prompt and set whatever system prompt you want if you want to experiment with it. And another thing that you can try is, um, simple mode. So this is actually this kind of undocumented feature. If you do Claude Code simple equals one, like this, uh, environment variable, and then you run Claude, it'll delete all the system prompts, including from the tools. And we actually use this as a sort of ablation to figure out, is the prompt useful? And what's interesting is that the model is actually a little bit more intelligent without these prompts.
Read that back. The instructions were not helping the model. They were compensating for older models, and Opus 5 made most of them dead weight. Boris even handed you the tools to test this yourself: a system prompt flag to replace the whole thing and an undocumented environment variable, `claude_code_simple=1`, that strips every built-in prompt, including the tools. Anthropic uses it as an ablation, and the model comes out slightly smarter. Every line you feed the model is read on every single turn. Lines have rent to pay.
Moment two. So that's what Anthropic does internally. Then the interviewer asks the question, "Everyone building with AI should hear. Should the rest of us do this too?" His answer has a schedule attached.
>> Should everyone in this room that's building AI products basically do that? Be comfortable and brave to press delete.
>> 100%. Yeah. And and for people that aren't building agentic products, but you're using Claude Code, every six months, delete your Claude.md, delete your skills, delete your hooks, see what the model does, and it might surprise you. And actually for Opus 5, this is something we really do recommend is just try deleting all of these things because the model might really just not need all those instructions that you needed for past models.
>> 100%. He says, "Every six months, delete your `claude.md`, your skills, your hooks, and watch what the model does." And when you rebuild, there's a method. Don't guess what instructions it needs. Delete everything. Use it. And only when it stumbles on the same thing repeatedly, do you add one line back. He calls the harness something you rederive per model, like getting to know a new creature, not maintaining an old machine. If your config has been accumulating since Sonnet 35, that's not memory. That's scar tissue from models that no longer exist.
Moment three, how did Claude Code even happen? Boris tells the origin story as a repeatable formula he calls product overhang. The gap between what a model can already do and what any product lets it do. Here's what that gap looked like two years ago.
>> They were they were doing chat. So you can talk to the agent, but it wasn't, uh, write access. You could only read. You could ask about the codebase. And so the the feeling was that there wasn't really a product that was fully eliciting the model's capability to write entire functions at a time, entire files at a time. At the time, it wasn't entire features. We weren't there yet, but probably entire files. That's that was the level of capability at the time. And so the idea with Claude Code was, all right, we think the model can probably do this. What if we get rid of all the scaffolding and just give the model the simplest possible harness so it can write an entire file at a time and build an entire feature? Um, I I think that nowadays with modern models, there is so much product overhang that I I'm not saying startups capture, and I think there's people thinking about these problems, but there's just a huge amount of opportunity to elicit these behaviors from the model that are just like amazing and interesting and and commercially valuable.
That's the formula. The model could already write whole files. Every product was still doing autocomplete, and Claude Code was just the thinnest possible harness dropped into that gap. Now run the same logic today. Boris, the person best positioned on Earth to know, says the overhang with today's models is bigger than it was then, unclaimed and commercially valuable. The next Claude Code is sitting in that gap right now, waiting for someone in that room or this one.
Moment four is the story that broke my brain. Claude Code runs on Bun, the fast JavaScript runtime Anthropic acquired last December. Bun was over 500,000 lines of low-level Zig where you manage memory by hand. The team had Claude hunting its memory leaks one case at a time. Then an engineer named Jared decided to stop hunting.
>> And then at some point, Jared on the team was like, "Okay, let's just like rewrite it. Maybe the model can do this." And I I think this is like one of these test problems that he kind of threw at the model with every new model generation. And starting with Fable, the model started to be able to do it. And so I think Opus 5 could do it as well. And so what he did was essentially he defined a test suite. The nice thing about Bun is it's very, very well tested. There's a big test suite in Bun. There's a big test suite in Node.js. So it's easy to know if you did the right thing. And he had the model rewrite it from Zig to Rust. It was one prompt. It was a dynamic workflow. And dynamic workflows are a feature in Claude Code that essentially let you orchestrate, you know, dozens, hundred, thousands of agents to do work productively. And it ran for 11 days and it rewrote the entire codebase.
>> And this was one shot?
>> It was one shot with no, it wasn't one shot, but there was steering. There was steering.
>> Um, but previous models just couldn't do this. Even even with the steering, it just wouldn't have been possible.
>> Just 11 days. Oh my god. This would have taken in the past, even with the best engineers, multiple months, years.
>> Over definitely over a year.
>> Yeah.
>> Yeah. Over a year. This is like over 100,000, like, JavaScript runtimes are really complicated. There's there's a lot of stuff in there. Um, and yeah, like it works. This is in production out. This is what Claude Code uses now when when you're running it.
So, we fact-checked this one hard, and it's all public. The official Bun engineering blog documents it: 535,000 lines of Zig converted to Rust in 11 days this May. 64 Claude instances running in parallel, about $165,000 of tokens at API prices. Claude Code has shipped the Rust port since June. Bun's own repository now lists Rust as its primary language. If you ran Claude Code today, you ran the result. Full disclosure: from the same sources, there was human steering, adversarial. Claude reviewers caught three critical bugs before merge, and Zig's creator publicly hated it. But the referee that made it possible was boring: a brutal test suite on both sides, telling the model at every step whether it was right. Hold that thought. It's the whole next moment.
Quick pause. If this is useful, follow us on Instagram and Facebook. Want to back what we build? Become a member on YouTube or a subscriber on Facebook. That's the ask.
Three moments left. The next one is a prompt you can steal.
Moment five. Forget prompt engineering. Boris says the real skill now has two parts: give the model a task slightly too hard, and give it a way to check its own work. Then he shows the receipt: a prompt he typed into Slack that is still running as he speaks.
I I think the skill nowadays is less about prompt engineering and more about figuring out how do you give Claude a hard task that seems a little bit too hard, and then how do you make it possible for Claude to verify its work along the way? And the verification, I think, is probably the single most important thing that people do not get right, virtually. And so what I did is, I I started a Claude tag session, and Claude tag is just, you know, it's a it's a new product we have, it's just Claude running in Slack. My first question was, "Hey, Tag, do you have access to a macOS runner on GitHub?" And it said no. And then I I hooked up a runner. So it was able to start a Mac virtual machine, uh, using using GitHub. And then, um, my second question is, uh, I created this like empty codebase that was, uh, Claude desktop app rewritten in Swift. And I asked, "Can you access this codebase?" It said no. And then I gave it access, and I was like, "Okay, great. Now I have access." And then I was like, "Okay, now I want, what I want you to do is, I want you to rewrite the Electron app in Swift. I want you to run the Electron app in the Mac virtual machine, screenshot it, and then look pixel by pixel, compare it to the Swift version. Don't stop until you're done."
>> And that was your prompt, basically?
>> That was my prompt.
>> And how long did this take to run?
>> It's still running.
>> When did you start it?
>> It's been, uh, it's been a little over two weeks. So, it's like 14 days, 15 days.
>> Yeah. So, I don't know if anyone in the audience has gotten Claude to run a a a task for more than two weeks. I don't know. Raise your hand. Anyone in the audience?
Look at the anatomy: it's three sentences. A task beyond what he knew the model could do. A verification loop: run the real app, screenshot it, compare pixel by pixel. And an exit condition: don't stop until you're done. That's it. No framework, no scaffolding. And Claude even decided on its own to open a Slack channel and live blog its progress with screenshots. When people ask what separates the top 1% of Claude users, it is not a secret prompt. It's that they build the checker before they hand over the task. The model does the work. The verifier is your job.
Moment six. Take that same pattern, make it recurring, and you get the part of the talk that should genuinely change your Monday. Anthropic has Claude maintaining Claude's own codebase on a schedule. Listen to the routines.
>> And so a thing that we've started doing is, um, we actually have Claude maintaining itself now. And the way we do this is we have a Slack channel where we just had Claude start a bunch of different routines to maintain its own codebase. And we actually do this for the CLI, for the iOS app, for the Android app, uh, for the desktop app. And for example, one routine is "clean up dead code." This is a single prompt. It's like one sentence. Claude runs this every day. It'll look for dead code across all the codebases using static and dynamic analysis. We didn't prompt that. It just kind of figured it out. And it'll put up pull requests every day to delete the dead code. One that I really love is this, um, I forgot what we called it. I think we called it "abstraction police." And the idea is there are often in a big codebase, there's kind of the same abstraction, and it appears multiple times. And if you kind of squint, it actually maybe should just be the same abstraction, but kind of over time, for whatever reason, you rebuilt it multiple ways in different parts of the codebase. So Claude kind of goes out every day across all our codebases. It finds these nearly duplicated abstractions and it unifies them. And so now we have every day maybe 20 or 30 of these routines. It's running across all of our codebases. And it's not totally there yet, but we're on the path to fully automating the maintenance of our apps by doing this. And this is again, hundreds of agents running every day, sometimes thousands of agents every day. It's doing the work of, you know, dozens or hundreds of
>> Every one of those is a one-sentence prompt on a timer. Clean up dead code. Ship experiments that hit 100%. Write tests where coverage is thin. Delete tests that earn nothing. Unify duplicated abstractions. The abstraction police. 20 to 30 routines a day doing what used to take teams of engineers. So the humans ship products instead of doing chores. None of this needs big company infrastructure. A cron job and a one-line prompt is something you can set up tonight on your own codebase. The moat isn't the routine. It's deciding what's worth repeating.
Last moment. So how do you get as good at this as the guy who built it? Boris's answer starts with who to stop listening to. Maybe like, don't listen to the LinkedIn influencers.
>> Don't listen to, don't read Twitter.
>> This is the thing about the model is, uh, I think everyone's looking for like the one weird trick to do it. There's just like, and that's kind of cool. When I think about the people that are the best at using Claude, I think there's a certain mindset that you can bring that's really effective. And it's really about being empirical. So forget all the things that you learned about past models. Forget everything that you learned about computer science theory in class. Look at the model, try to do a task, see where it struggles, and then based on that, adjust. So it's just like very much become, it's not a theoretical science, it's become an empirical science. So I think people that are really good at this, that are really good at kind of forgetting their priors, letting go of, you know, this like maybe idea that didn't work before, and just being open to trying it again. This is the kind of skill that's just very, very successful now.
Now, there is no one weird trick from the person who would know if there were one. The skill is empirical. Give it a task that's too hard. Watch where it struggles. Adjust. Repeat. 20-year veterans struggle with this most because over-specifying used to be the job.
One more thing. Boris mentioned he learned to code on a TI-83 calculator to pass his math tests, and that his guide is quote, "still up on the internet somewhere." We went looking. It is talc.org 2004. A Beginner's Guide to Calculator BASIC Version 2.5 by Boris Churnney. Practical problem first, theory second. That loop built Claude Code.
Seven moments: Anthropic deleted 80% of Claude Code's system prompt and got a smarter model. Delete your `claude.md` every six months and rebuild it line by earned line. Product overhang built Claude Code, and the gap is bigger today. A half-million-line runtime was rewritten in 11 days with a test suite as the referee. The elite skill is building the verifier, like the three-sentence prompt still running after two weeks. Put one-sentence routines on a timer and let Claude maintain your codebase, and ignore the influencers. The only method is empirical.
We condensed this into the Delete Protocol, a free PDF with every quote timestamped to the full talk, the delete and rebuild method as a checklist, the two-prompt template you can adapt, and the full routine list to copy. Comment the word "delete" on this video, and our assistant sends it over, or grab it at hyperautomationlabs.co/free/delete.
Real talk, 90% of you watching haven't subscribed. On Facebook, "subscribe" is the supporter button. That is what keeps the lights on here. On YouTube, it's free, and it tells the algorithm to send you more. Subscribe to support us.
If you are starting out with AI coding tools, the beginner guides are linked below: The Complete Claude Code Guide, the CodeX Guide, the Cowork Sales Guide, and the Architect Prep Kit. Step by step from zero. We're on YouTube, Facebook, and Instagram as Hyper Automation Labs. Same name everywhere.
And tonight, before you add one more line to your `claude.md`, try deleting one instead. See you in the next one.