Modern Creator
Nate Herk | AI Automation · YouTube

Anthropic Just Released the New Rules of Claude Code

Five jobs you used to do by hand in every Claude Code session, and what now handles each one.

Posted
5 days ago
Duration
Format
Tutorial
educational
Views
217.4K
2.1K likes
Big Idea

The argument in one line.

With models as strong as Opus 5.5, the manual jobs of steering, approving, and starting sessions move to the model, the harness, and the environment, so your effort belongs in deny rules, checks, and sandboxes.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…
  • You use Claude Code daily and your CLAUDE.md has grown into a pile of IMPORTANT and NEVER rules you no longer trust.
  • You run several Claude Code sessions at once and keep getting pulled in to click approve on commands or babysit long runs.
  • You use Claude Code for knowledge work like reports, research, and content, and want the same safety and quality checks that developers use.
  • You are not from a coding background and want to know which safeguards to set up once so you stop worrying about keys and deleted files.
SKIP IF…
  • You only use Claude Code for short, one-off prompts and never leave a session running unattended.
  • You want a step-by-step install tutorial. This covers the working habits and settings, not first-time setup.
TL;DR

The full version, fast.

Anthropic's Claude Code team went from about 2,500 code changes a day in May to over 30,000 in September, and the work now looks like managing dozens of sessions. The talk reduces your hands-on jobs to five: steering, approving, saying no, verifying, and starting sessions. Strong models need a leaner CLAUDE.md, auto mode replaces click-to-allow, deny rules and sandboxes cover what can't be undone, pass/fail checks and exit-code-2 hooks catch bad runs early, and Claude Code Projects lets one coordinator session start the rest.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →
Chapters

Where the time goes.

00:00 – 00:26

01 · Cold open

The jump from 2,500 to 30,000 code changes a day and the promise to cover five jobs you still do in every session.

00:27 – 01:40

02 · Steering: trim your CLAUDE.md

On Opus 5.5, all-caps rules hurt. Keep only what Claude can't see from code, and use the doctor prompt audit to find dead weight.

01:41 – 03:26

03 · Approving: auto mode

A classifier replaces click-to-allow, trusts only the current repo by default, and is set up in plain English with auto mode setup.

03:27 – 04:30

04 · Saying no: deny rules

Auto mode blocked 89% of dangerous commands versus 14% for people, but one in ten still slips through, so irreversible actions get hard deny rules.

04:31 – 05:20

05 · Sandboxes and cloud sessions

Deny rules only see the command. A sandbox limits files and network, and cloud sessions run on a disposable machine without your keys.

05:21 – 06:35

06 · Verifying: checks along the way

The same prompt can land in different places, so give each task a pass/fail check such as a test, screenshot, or source-link rule.

06:36 – 07:46

07 · Hooks and automated PR review

Hooks should exit with code 2 to force fixes, and every pull request gets a fresh-context Claude review before a human sees it.

07:47 – 09:09

08 · Starting: Claude Code Projects

One coordinator session starts and checks a session per task, with separate models for coordinator and threads.

09:10 – 09:40

09 · Wrap-up and what to try

Try one oversized task with a check that catches failure, start in the cloud, and hand over wherever you are still in the loop.

Atomic Insights

Lines worth screenshotting.

  • On a model as strong as Opus 5.5, all-caps IMPORTANT and NEVER lines in CLAUDE.md work against you, causing extra tool calls and worse results.
  • The test for every CLAUDE.md line is whether Claude could figure it out by reading the code. If it could, delete the line.
  • Auto mode runs a separate classifier over your commands and by default only trusts your current folder and current repo.
  • In Anthropic's August study, only about 14% of people caught a clearly dangerous command. Auto mode blocked 89% of them.
  • Auto mode still lets roughly one in ten bad commands through, so anything that matters needs a hard deny rule.
  • The deny-list test is simple: if Claude gets this wrong once, can I take it back? Bad code can be undone. A leaked API key or deleted unsaved work cannot.
  • A deny rule in settings is a hard block. A rule written in a prompt is only a suggestion.
  • A deny rule sees the command, not what the command does, so a compromised test script can still read your .env file or SSH keys.
  • A sandbox limits which files a command can open and which sites it can reach, so even a bad package can't grab your keys.
  • Cloud sessions run on a disposable machine with a copy of your code, so your keys aren't in there and the job continues with your laptop closed.
  • The same prompt can land in very different places: one run migrates the API, another keeps the old one, another logs every user out, and all three look fine at a glance.
  • Give every task a pass/fail check like a test or screenshot so the bad run fails at the first check instead of after hours of wasted tokens.
  • A hook script that exits with 1 still lets Claude mark the task completed. Exit with 2 to send Claude back to fix it.
  • On the Claude Code team, every pull request is reviewed first by a fresh session with its own agents, not the one that wrote the code.
  • Claude Code Projects lets one main session take your weekly task list and start a separate session for each item.
  • Pair a strong judging model as coordinator with a cheaper worker model per thread, such as Fable 5.2 coordinating Opus 5.5 threads.
Takeaway

Move your effort from prompts to guardrails.

WHAT TO LEARN

Strong models handle steering, approving, and starting work on their own, so your time is better spent on hard deny rules, sandboxes, and checks that catch a bad run early.

02Steering: trim your CLAUDE.md
  • Cut CLAUDE.md down to what Claude can't see from the code, since all-caps IMPORTANT and NEVER lines now cause extra tool calls and worse results.
  • Run the prompt audit to find lines the current model no longer needs or that may be confusing it.
03Approving: auto mode
  • Use auto mode instead of clicking allow or skipping permissions, and set its trusted repos and domains in plain English with the setup command.
  • Auto mode caught 89% of dangerous commands versus 14% for people, but one in ten still gets through, so don't treat it as the only safeguard.
04Saying no: deny rules
  • Put irreversible actions on a deny list in settings, using the test of whether you could take back a wrong move, for coding and knowledge work alike.
05Sandboxes and cloud sessions
  • Add a sandbox or run long jobs in a cloud session, because a deny rule can't see what a compromised script does once it runs.
  • Commit your deny rules into the project so every future session, including cloud ones, picks them up automatically.
06Verifying: checks along the way
  • Give every long task a pass/fail check, like a test, a screenshot, or a rule that every claim has a source link, so a bad run fails at the first check.
07Hooks and automated PR review
  • Make hook scripts exit with code 2 on failure, because an exit code of 1 still lets Claude mark the task as completed.
  • Have a fresh session review every pull request before a human does, so people only look at what is actually risky.
08Starting: Claude Code Projects
  • Try Claude Code Projects with a strong coordinator model and a separate worker model per thread, so one chat replaces juggling a dozen.
Glossary

Terms worth knowing.

Auto mode
A Claude Code permission mode where a separate classifier checks each command. Routine actions like tests and installs run on their own, and anything uncertain gets blocked for your approval.
Deny rule
A hard block written in your settings file that Claude Code checks before auto mode gets a say. It is enforced by the tool, unlike an instruction in a prompt.
Sandbox
An environment enabled with the slash sandbox command that limits which files a command can open and which websites it can reach, even if the code running is malicious.
Hook
A small script Claude Code runs automatically at set moments, such as after every edit or before a task is allowed to finish.
Exit code 2
The exit status a hook script returns to tell Claude Code the check failed and it must go fix the problem. An exit code of 1 still lets the task be marked done.
Claude Code Projects
A beta feature where one main session takes a list of tasks, starts a separate session for each, and checks what comes back.
Coordinator model
The model that decides what to do and judges the results in a Projects setup, as opposed to the thread models that do the actual work.
Resources

Things they pointed at.

01:25toolslash doctor prompt audit
02:24toolslash automode setup
04:31toolslash sandbox
07:52productClaude Code Projects
08:35productFable 5.2
08:40productOpus 5.5
Quotables

Lines you could clip.

03:27
“If Claude gets this wrong once, can I take it back?”
One question that decides the whole deny list, no setup needed→ IG reel cold open↗ Tweet quote
05:46
“There's a big difference between saying something in the prompt and having something actually hard-coded in permissions.”
Clean distinction most users get wrong→ TikTok hook↗ Tweet quote
06:59
“Make your hooks exit with a two, and then Claude can't call something done until it actually is.”
Specific, actionable, surprising detail→ newsletter pull-quote↗ Tweet quote
The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

So Anthropic went from about 2 ,500 code changes a day in May to more than 30 ,000 a day in September. And Lydia Halley from the Cloud Code team just gave a talk on how they're working now. And it looks really different from how most people are still using Cloud Code today.
We've now essentially become managers for dozens of sessions. So I broke down her talk into the five things that you need to do yourself in every single session, what handles each one now, and the setup that you can copy today. So let's not waste any time and just get straight into this one.
All right, so the first thing that we used to do was steer. Earlier this year, a session on Opus 4 .5 meant you would watch it after you prompted it, and then you correct it and remind it what to do. So people started filling up their Cloud .mds with lines like IMPORTANT and NEVER in all caps.
Lydia's daily driver now is Opus 5 .5, and she says on models that are that strong, those lines actually work against you. But with today's models, you really don't need that, and it can actually make the model go off track. So you end up with more tool calls and overall worse results.
So nowadays, your CloudMD file should only include the things that Cloud cannot see from your code. So the test for every line in your Cloud .MD is, could Cloud figure this out by reading the code? I basically run my whole business out of one folder, and inside of Cloud Code, it uses cloud .md as my routing map, or it can also use agents .md, where my business wiki lives, where my brand assets are, and where my finances are, things like that.
Cloud would have a really hard time just guessing that from the files, so that's what stays. And the cool thing is you don't have to clean all of this up by hand. You can just start to brainstorm with it a little bit and you can even run slash doctor prompt audit and it will check your cloud .md and your skills against the model that you're on and it will tell you what the model no longer needs and what's just taking up space and maybe even confusing the model.
Now, the second thing was about approving. You either clicked allow on every single command or you skipped permissions dangerously and you just kind of crossed your fingers and hoped for the best. But now we have auto mode, which is the default inside of like the terminal and cloud code desktop app.
And so with auto mode, they have a separate classifier that checks your commands. So tests and installs can just run and it will only stop on things that it isn't sure about. But by default, it will only trust your current folder and your current repo.
So if you ask cloud to ship something to staging, it will just block the push to your deploy repo. And you're back to once again, approving things in a very safe manner. You can configure auto mode in your own settings, just in plain English.
And this is what gets sent to the classifier, which then decides whether to reject or allow certain commands. which repos or buckets and domains that you trust, plus what it should always allow or never do. And if you don't want to write that yourself, then you can just run slash automode setup, and it will draft those entries from your project and your recent sessions.
And automode is also already really good at catching these bad commands, and much better than you are, especially if you don't come from a coding or technical background like I don't. So I use automode all the time. So in a study we published back in August, we tested auto mode versus real people in the loop, and only about 14 % of people caught a clearly dangerous command.
Auto mode blocked 89 % of them. So it is a lot better at it than we were. But about one in 10 of those commands still went through.
Now, the third thing is interesting. It's about saying no. Auto mode will still let about one in 10 bad commands through.
So for the stuff that really matters, you want to have a deny rule or like a deny list. And that's a hard block that you put in your settings file and Cloud Code can check it before even auto mode gets a say. So Lydia has a simple test for what needs to go on this deny list.
I think it kind of just comes down to if Claude gets his wrong once, can I take it back? If Claude writes bad code, you can undo that. So then you just let the model handle it.
But if it wipes work that you hadn't saved, or if it reads one of your API keys, you can't undo that. So saying never read my .env file, which is where your keys live, that would actually become a hard rule rather than just a prompt rule. There's a big difference between saying something in the prompt and having something actually hard -coded in permissions.
And that's important if you're working with clients too. And also if you're using cloud code way more for knowledge work like I am, rather than like building software or coding all the time, the test is still the exact same thing. Claude rewriting a draft is fine, but sending an email or deleting files is something that you cannot take back.
But once again, a deny rule only sees the command, not what the command does. So say Claude runs your tests. Those tests also run a bunch of code that you didn't write.
So if one of those scripts is compromised, it could just open that same end file or your SSH keys and send those to a server you've never heard of, right? And...
And that's what a sandbox sort of environment is for. And you can actually type slash sandbox, and your computer itself will limit which files a command can open and which websites it can reach. So even a bad package can't go grab your keys.
And Lydia also says that for the really long jobs, she will run Cloud in a cloud session, where it gets its own fresh computer with a copy of your code, so your keys aren't even in there. And it keeps going even if you, you know, close your laptop.
This machine is disposable, but the things that leave it aren't. So a commit is pushed or a message is sent through a connector. And you can keep those deny rules in the cloud sessions as well.
All you have to do is commit them into your project and then every session in the future will pick them up. So by the way, I put all of these deny rules and the auto mode settings and all these, you know, these hook setup things that I'll be talking about from this video into a free guide inside of my free school community, which you can grab using the link in the description.
If cloud runs for hours on its own, you're not reading every single file at the end and if you are you might be wasting some time but the same prompt can land in really different places so lydia's example is moving your login system to a new api so with the exact same prompt you know one run might move it over but leave the old api in there or one might move it but only for new logins and another one might move it but log everyone out all three of these look fine at a glance So what you do is you give Claude checks along the way that either pass or fail, like a test or a screenshot.
That way, the run that logs everyone out actually gets caught right away at that first check rather than at the very end and you've wasted all your time and tokens. And this, of course, works outside of code too. If Claude is writing a research report, for example, the check can be, you know, making sure that every claim has a source link or that every number matches the spreadsheet.
And once again, when you're doing these checks, yes, they can be programmatic or sort of hard coded in, but they can also be a bit more subjective. They can be simply you saying, what does done look like or what does good look like? And you can give every single task its own test and you can have it take screenshots and, you know, double check things and triple check things.
The key is that Claude is looking at its actual output and it's iterating it on it and it's giving itself feedback and it's checking things before it hands you that V1. Also like to ask it to show the actual output because you weren't there to see it. And I am always doing some sort of version with this in my skills and also whenever I do a slash goal prompt, which is, you know, the prompt that keeps Cloud working until a finish line is actually true.
But then if you do have certain checks that have to run every single time, that's when you use hooks, which are these little scripts that Cloud Code runs on its own. You know, a quick format check after every edit or the test after every task and the full test suite before it's allowed to finish. So these are a lot more programmatic and code based.
And when a check fails, the number your script exits with decides what Claude does next. When a test fails, by default, most tools that exit with a one exit code. But with a one, that task by cloud code just gets marked as completed anyway.
So make sure that your scripts exit with a two exit code because that's what actually sends Claude back to fix it. So maybe you could make your hooks exit with a two and then Claude can't call something done until it actually is. And then once a session opens up a pull request, your CI can run.
And on Lydia's team, Cloud reviews the code before any human person does. On our team, every PR gets reviewed by Cloud first. So not by the session that wrote it.
So it comes with a fresh context and also a separate group of agents to just double check every bug it finds. And after that, the people only review what's actually risky. And the small stuff like the docs can merge on its own once those checks have passed.
Now, the very last thing that you still do yourself is start every session. And that's the next thing that Anthropic is handing off. So with Cloud Code Projects, which is in beta right now on Pro, Max, and Ultra plans, you basically give one main session your whole list for the week.
And it just starts a separate session for each task, and it checks what comes back. So it's kind of like the same way you would have, you know, a main orchestrator agent delegate to subagents. but it's doing it in more of a project -oriented way.
It's like subagents on steroids. And that list, of course, doesn't have to be code. It could be a client report or a research brief or, you know, making up a bunch of content ideas and then scripting out the videos or whatever it needs to be for that specific project.
So instead of juggling all, you know, 12 different chats, you're just talking to one main chat. And the main session doesn't write the code itself. So there you want a model that's really good at deciding what to do and judging what comes back.
A model like Fable. And you can even in your project settings, set what the coordinator or the orchestrator model is. So you could use something like Fable 5 .2, which is Anthropic's newest model at the moment.
And then you could have each thread model, which are like the little sub chats, be something like Opus 5 .5 for the actual work. So basically, moral of the story here is that the old best practices are all still there, but they've just kind of moved a lot off your plate and things are happening more automatically now. And you want to make sure that you're not giving these really powerful models too many instructions and really just getting in their way.
You want to let them do what they're... built and trained to do. So almost everything we used to do ourselves is now either the model, the harness, or the environment.
So if you want to try this, just take one task that's way bigger than what you'd normally give to Claude and make sure you have a check that would catch if something is going wrong. And then start in the cloud and see where your sessions get stuck and where you're still in the loop because that's the next thing to hand over to Claude.
So if you guys enjoyed this one or you learned something new, then please give it a like. It helps me out a ton. And as always, I appreciate you guys making it to the end of the video and I'll see you on the next one.
Thanks everyone.
The Hook

The bait, then the rug-pull.

Anthropic's own Claude Code team now ships over 30,000 code changes a day, up from about 2,500 in May. This breakdown walks through the five things they say you still do yourself in every session, and what now handles each one.

Frameworks

Named ideas worth stealing.

00:27list

The five session jobs

  1. Steer
  2. Approve
  3. Say no
  4. Verify
  5. Start

The five things a person used to do by hand in each Claude Code session, each now handled by the model, the harness, or the environment.

Steal forauditing which parts of your own Claude workflow you can hand over
03:27concept

The can-I-take-it-back test

If Claude gets this wrong once, can you undo it? If yes, let the model handle it. If no, such as reading a key, deleting unsaved work, or sending an email, make it a hard deny rule.

Steal fordeciding what belongs on a deny list
00:42concept

The CLAUDE.md line test

For every line, ask whether Claude could figure it out by reading the code. Only keep what it can't see, such as where your business wiki or brand assets live.

Steal forpruning a bloated CLAUDE.md or agents.md
CTA Breakdown

How they asked for the click.

VERBAL ASK
04:50link
“I put all of these deny rules and the auto mode settings and these hook setup things into a free guide inside of my free school community.”

Mid-video pitch placed right after the deny rule and cloud session material, when the viewer wants the exact settings.

Storyboard

Visual structure at a glance.

open
hookopen00:01
auto mode
valueauto mode01:42
deny rules
valuedeny rules03:07
cloud session
valuecloud session04:42
projects
valueprojects07:51
wrap-up
ctawrap-up09:16
Frame Gallery

Visual moments.

One-click upgrade to your Google

Get more breakdowns in your search results

Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.

Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
Watch next

More from this channel + related breakdowns.