Big Idea

The argument in one line.

Boris Cherny's four-step Claude Code adoption ladder works by shifting your job from doing the task to verifying, permissioning, and scheduling it, and the real ceiling on 10x output is trust and token discipline, not model capability.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You already use Claude Code or a chat AI for real tasks and want to move past one-at-a-time chat sessions.
You run a small team or solo operation and want to turn your own repeatable processes into reusable AI skills.
You're nervous about runaway agent costs and want concrete guardrails before you scale up automation.

SKIP IF…

You've never used an AI coding or chat tool at all, this assumes you're at least past the chat-window stage.
You want a hands-on code walkthrough, this is a conceptual framework explainer, not a build-along tutorial.

TL;DR

The full version, fast.

Claude Code creator Boris Cherny mapped four stages of AI adoption, AI-assisted, AI builds in parallel, supervised autonomy, and AI-native, and this video translates his engineer-facing version into plain steps. Moving up the ladder isn't about smarter prompts, it's about building trust: rule-based and taste-based verification so you stop reviewing every output, scoped agent permissions so mistakes can't do real damage, reusable skills and routines so processes run without you, and hard caps on token spend and iteration counts so an unattended loop can't quietly burn thousands of dollars. The practical filter for what to automate is simple: if AI can do a task about 80% as well as a person you'd hire for it, hand it off; if it needs to be near-perfect, keep a human in the loop.

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:32

01 · Cold open

Boris Cherny's four-step framework is teased as the throughline for the video.

00:32 – 01:23

02 · Step 0: Living in the Chat Window

Most people, even regular AI users, are stuck copy-pasting in a chat window; Gallup data shows half of US workers don't use AI at all.

01:23 – 03:40

03 · Step 1: AI-Assisted

Getting AI to edit files and pull from connected tools directly, removing the copy-paste dance, using Claude Code, Obsidian, and connected apps like Notion.

03:40 – 09:37

04 · Step 2: AI Builds in Parallel

Becoming an AI orchestrator: rule-based and taste-based verification, agent permissioning (the 'drunk intern' rule), and splitting cross-project vs. inter-project tasks, with a mid-video Accio Work sponsor read.

09:37 – 15:22

05 · Step 3: Supervised Autonomy

Becoming an AI agent CEO: building Claude skills as standard operating procedures, setting delivery timelines and a reporting channel (Slack), and using sub-agents to break bottlenecks.

15:22 – 17:43

06 · Step 4: AI-Native

Agents kick off other agents and you monitor by exception; a $3,000 overnight token-burn horror story motivates setting a minimum viable model and a max iteration cap.

17:43 – 18:18

07 · What to Automate and What Not To

The 80% rule for deciding what's safe to automate end-to-end versus what still needs a human in the loop.

18:18 – 19:04

08 · All Four Steps

Recap card summarizing AI-Assisted, AI Builds in Parallel, Supervised Autonomy, and AI-Native.

Atomic Insights

Lines worth screenshotting.

Gallup found roughly half of US workers aren't using AI at all, and only 28% use it weekly or daily, so a regular chat-window habit already puts you ahead of most people.
Even daily AI users are often stuck at 'step zero': manually copying answers out of a chat window and pasting outside data back in.
The test for whether you're past copy-paste AI use is simple: do you still paste output from the AI elsewhere, or paste outside data into the AI by hand?
The first real unlock is getting AI to edit your files and pull from connected tools directly, removing the copy-paste loop entirely.
Without a non-human way to verify output, your own attention becomes the bottleneck no matter how many AI agents you run in parallel.
Split verification into rule-based checks (objective pass/fail like lint, tests, type checks) and taste-based checks (subjective quality like tone or design).
Treat agent permissions like handing keys to a drunk intern: give access only to what it can't seriously damage, and auto-approve only low-risk actions.
Separate work into cross-project tasks (unrelated, should live in separate folders/contexts) and inter-project tasks (related, non-overlapping, safe to run in parallel).
Building a reusable AI skill from a task you already did well, rather than from scratch, is the fastest way to make a process reproducible.
An unmonitored autonomous AI loop reportedly burned over $3,000 in tokens overnight for one operator by looping on a single task without a cap.
Setting a minimum viable model per task, and a maximum iteration count per routine, are the two simplest guardrails against runaway token spend.
The automation decision rule is an 80% bar: if AI can do a task about as well as someone you'd hire for it, automate it; if quality must be near-perfect, don't.

Takeaway

Verification and permissioning matter more than more AI

WHAT TO LEARN

Boris Cherny's four-step ladder isn't about smarter prompts, it's about building trust systems, rule-based and taste-based verification, scoped permissions, and token caps, that let you hand off more work at each stage.

02Step 0: Living in the Chat Window

Gallup found roughly half of US workers aren't using AI at all, and only 28% use it weekly or daily, so simply using a chat window regularly already puts you ahead of most people.
Even people who use AI daily are often stuck at 'step zero': copying answers out of a chat window and pasting data back in by hand.

03Step 1: AI-Assisted

The test for whether you're past step zero is whether you still copy-paste between AI and other tools; if you do, set up an agent that can read and edit your files directly instead.
Connecting AI to your existing tools removes the manual copy-paste loop and is the single biggest unlock at the AI-assisted stage.
The bottleneck at this stage is your own attention: low trust in the model's output forces you to review every response, capping how much you can offload.

04Step 2: AI Builds in Parallel

Verification is the highest-leverage change for running multiple agents at once: without a non-human way to check outputs, your own review becomes the bottleneck no matter how many agents you spin up.
Split verification into rule-based checks (objective pass/fail: lint, tests, type checks) and taste-based checks (subjective: does this look good, is this concise) and build both into your workflow.
Treat agent permissions like handing keys to a drunk intern: give access only to what it can't seriously damage, using a preset auto-approval mode for low-risk actions while gating anything risky.
Separate tasks into cross-project (unrelated work in entirely separate folders/contexts) and inter-project (related, non-overlapping units you can run in parallel) so agents never collide.

05Step 3: Supervised Autonomy

Turning a repeatable process into a reusable AI skill is what lets it run without you: build the skill from a real session you already completed well, then generalize it.
Set explicit delivery timelines and a reporting channel (a Slack channel, a scheduled routine) so AI 'employees' report status the way a human hire would.
When a task is taking too long, break it into sub-agents that each own one narrower slice of the work to run it in parallel and finish faster.
Setting up a system to hand off a task will feel slower than doing it yourself the first few times; the payoff shows up once the system runs unattended.

06Step 4: AI-Native

At the AI-native stage, agents kick off other agents and you stop checking in on individual tasks, only stepping in when something breaks.
Without guardrails, an autonomous loop can burn real money fast: one unmonitored task reportedly cost over $3,000 in tokens overnight by looping without a cap.
Set a minimum viable model for every task, a cheap model for simple work rather than defaulting to the best one, and cap the maximum iterations any routine can run.

07What to Automate and What Not To

Use an 80% bar to decide what's worth automating: if AI can do a task about as well as a person you'd hire for it, hand it off; if quality has to be near-perfect, don't.
Depth of automation should track how forgiving the task is: routine, well-defined work is prime automation material, novel or high-stakes work still needs a human in the loop.

Glossary

Terms worth knowing.

Rule-based verification: Checking AI output against objective, pass/fail rules like lint, automated tests, or type checks, where there's no debate about right or wrong.
Taste-based verification: Configuring AI to judge subjective quality, like whether writing is concise or a design looks good, where the answer isn't a strict yes or no.
Auto mode (Claude Code): A preset permission setting in Claude Code that auto-approves lower-risk actions and asks for explicit approval only on riskier ones.
Claude Routines: Claude's built-in scheduling feature for running a skill automatically on a set cadence, like a report generated every Monday morning.
Sub-agents: Multiple narrower AI agents each assigned one slice of a larger task (for example, one agent per research platform) so the work runs in parallel instead of sequentially.
Cross-project vs. inter-project tasks: Cross-project tasks are unrelated work kept in separate folders and contexts; inter-project tasks are related but non-overlapping units of work safe to run alongside each other.
Minimum viable model (MVM): Selecting the cheapest AI model capable of handling a given task, rather than defaulting to the most powerful model for everything, to control token cost.

Resources

Things they pointed at.

01:35linkBoris Cherny's "Steps of AI Adoption" doc ↗

02:35toolObsidian

06:36productAccio Work ↗

06:59toolAnti-slop Skill (BuildPartner.ai) ↗

12:53toolSlack

07:10toolClaude Code auto mode

Quotables

Lines you could clip.

01:30

“There are levels to this shit, and we're going to level up in this video.”

punchy, quotable hook-style line mid-intro→ TikTok hook↗ Tweet quote

06:16

“The mental framework I always use is thinking of agents like a drunk intern.”

vivid, memorable metaphor for agent permissioning→ IG reel cold open↗ Tweet quote

16:26

“An AI burned through over $3,000 worth of tokens on a single task... it literally got stuck in a loop and was lighting money on fire.”

cautionary horror story with a concrete dollar figure→ TikTok hook↗ Tweet quote

10:00

“Lose the battle to win the war.”

short, standalone mindset line→ 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.

metaphorstory

Boris Churney, the creator of ClawedCode, said something that shocked me. Inside every company, there is one person who uses AI to 10 x their output while everyone else around them struggles to keep up. So to help with this, Boris shared four steps that separates these AI powered users from everyone else.

But the problem is his advice is extremely technical, so it can be very intimidating. So in this video, I'll break down and simplify his exact four step process to 10 x ing your AI productivity and how you can apply it today.

And by the end, I guarantee whether you're technical or not, you'll know exactly what to do, how to do it, and why these four steps matter. Now before we get to step one, it's important to understand what step zero is. This is people who are using Callout or ChatGPT in the chat window.

That's it. And this is identical to how everyone started using ChatGPT when it first came out. Now 99% of the people watching this channel are past this level, but there are two important things to cover here.

The first is in a study by Gallup. They estimate 50% of US workers aren't using AI at all, and only 28% of them are using it weekly or daily. So most people are barely at step zero, which sounds crazy, but here's what's more important.

The second thing, if Boris saw how you use AI today, he'd put you in a similar category as the people who barely use AI at all. So as a wise person once said, there are levels to this shit, and we're going to level up in this video. So the first step is about get becoming a better AI powered worker.

Step two, that's about becoming an AI manager. Step three and step four is about becoming a manager of AI managers. And Boris specifically designed these steps so that they build on top of each other.

So step one is AI assisted. Here's how Boris describes a step. And throughout this video, I'm gonna be referencing a blog that he wrote that's specifically going through each of these four steps.

This is one engineer, one agent, mostly supervised, a fast pair programmer. You run one session at a time and review almost every change before it merges. Now that sounds technical, but it really isn't.

Think of a pair programmer as no different than having an assistant in the room who can do a task for you. And in practice, this looks like using Claude code and co work, which a lot of you already do. Now this is the first of two paradigm shifts we'll cover in this video.

This is getting AI to do things for you, not just answer your questions. Now most people think they're here, but they actually aren't. So to identify this, ask yourself two questions.

Do you find yourself copy and pasting output from Claude into other locations? And do you find yourself copy and pasting data that's outside of Claude and bringing that manually into Claude? If the answer is yes to either of these, you can improve your system so that you're more in step one.

AI should be able to pull information for you and then edit documents directly on your behalf, so you don't have to do this copy and paste dance. So what's the easiest way to do this? Now I use ClawdCode because it seamlessly can edit files on my computer.

And this is not just for coding tasks. I know a lot of nontechnical people watch this. You should not feel intimidated to use ClawdCode.

Code. So to set this up, go to Claude desktop, click code, and then select the folder and hit add another folder, then select new folder and call it your personal AI system, and then hit create. Once you're in there, run slash in it and it'll optimize this project for you.

Now you could ask Claude to say, write a file that says I'm a boss, and it'll go ahead and do it for you. Now to make navigating these files easier on your computer, I use Obsidian, which is free. You just download that, then select the folder you created, and now you can easily view the file that it just wrote to.

Now this small change makes it super easy for you and your AI to collaborate together, removing the need to copy and paste, which just takes way too much time. Now to connect it to the external world, click the plus and then connect any system you need the agent to have access to. So for example, I use Notion a lot, so I just connect Notion, and now it has access to the data, and I don't have to copy and paste it from there.

Now just setting this up is a massive change for a lot of people, but there is still some key bottlenecks, and Boris outlines them exactly like this. Your attention and the need to inspect each response and code edit. Due to low trust for the model's output and lack of self verification, you feel you must read everything so you never look away.

So how can we change from this back and forth manual process that feels like a one lane road to something that more resembles a multilane highway that allows you to build faster? Step two is AI builds in parallel. In Boris' words, this step is about having one engineer that orchestrates five to 10 agents at once, each on its own Work Tree or Git Checkout jumping between them.

Now ignore the technical terms like Work Tree and Git Checkout. That doesn't really concern us right now. The key here is that he calls your role orchestrator, which isn't about just opening a bunch of tabs and having AI work on things simultaneously.

There's more to the story here. The key unlock is having AI agents that do work end to end and then check the output themselves. So you're looking at a final product, not the intermediary steps.

And once you do this, this is how Boris describes the impact. A backlog that used to take the team weeks becomes one engineer's afternoon of orchestration. So how do you actually get there?

There are a bunch of ways to do this, but these are the highest leverage changes. The most important step is verification. To go from a single lane highway to a multi lane highway, you need a nonhuman to verify the outputs.

If you don't do this, your verification process ends up becoming the bottleneck and will drastically slow you down. So there are two types of verification you need to be focused on. These are rule based verification and taste based verification.

Rule based verification is the process of using rules to objectively verify an output. This is where there's really no debate.

Right? Is something right or wrong? Yes or no?

Now in the coding world, Boris calls this automatic code quality enforcement like Lint, automated test type check. Now don't worry about what these terms are, but the key here is that they are all objective metrics, pass or fail. And this exists for nontechnical work as well.

Does a report use the correct colors? Does it use the right fonts? Does the text use em dashes?

These are all yes or no questions. And depending on your domain, the list may expand greatly. For example, if you're a mechanical engineer, there may be concrete rules and regulations that are quantifiable to validate.

This is something firsthand I've seen with engineering businesses that I'm working with. The second is taste based verification, and this one is tricky, but it's personally my favorite.

The key here is that you're configuring AI to validate work that isn't objective. Does the design look good? Does that content idea pass a quality bar?

Is the writing concise? Here's a prompt that will help you create two skills, one for rule based verification and one for taste based verification. The key here is that you need to go through and provide context about what you're working on and then optimize it over time.

Now, you'd rather get the exact verification skill I use, I call it the anti slob skill, and that's linked in the description below. This uses my build partner dot a I Claude plugin, which walks you through the exact steps to set it up in your system. So that's the first high leverage change to go to step two, which is creating a verification process for your system.

But the second high leverage change is agent permissioning. This is the process of giving agents room to work without the fear of it causing permanent damage. The mental framework I always use is thinking of agents like a drunk intern.

If it has access to something that it can mess it will mess it up. So protect yourself by removing that possibility. And now the simplest way to do this, and this is suggested by Boris, is to use Claude code's auto mode.

And I'm honestly surprised how many people have never heard or used of this. But to do this, just click next to the plus on Claude and then select auto. This will use Claude's preset configuration to auto approve things that aren't as risky and then ask for your permission for things that are risky.

It's the Goldilocks zones for permissioning, and you don't really have to worry about changing it from there. Once you've set up Claude to validate the results and give it the permission to run and work through tasks without monitoring it and approving every single step, you've empowered Claude to complete tasks end to end.

And that's the key to step two. So it now has the ability to build in parallel, but we now need to identify what to work on in parallel without the agents crossing swords. But before we get to that, one of the things we're talking about here is agent autonomy.

And that's exactly where today's video sponsor, Assia Work, comes in. Instead of one AI assistant, you get an agent team that actually executes on your behalf. Here you can see me the Assia Work dashboard where you can add agents to your virtual team like you're adding people to a real team.

Each one has specific skills you can see, and you can add new ones for whatever you want that specific agent to focus on. And Assia Work has access to Alibaba's massive network training data, which gives these skills and agents a massive competitive advantage. One feature that I love is their ability to communicate with people directly.

So let's say you're looking for a supplier for your business, you can vet suppliers and then negotiate on your behalf. At my last startup, I used to speak to 10 to 20 different suppliers to land on the one that I needed to produce hundreds of thousands of product that would get shipped around the globe. And if I had this at the time, it would have been a massive lifesaver.

And because AscioWork has data about what people are selling across platforms like Alibaba, it has unique contextual information to draft better responses. And the thing with this is it's not something that you can just replace yourself.

So if it's ecommerce, marketing, outreach, or operations, using Assia Work to create an agent team that runs twenty four seven just makes sense, and you can manage it directly through your phone through Telegram. If you wanna start building with your own AI agent team, click the first link in the description where all new Ascio Work users will get free access for seven days.

You're gonna be happy you tried it. But we need to get back to step two where we're identifying how AI agents can work together within Claude code. And to think about this, I try and think about tasks in cross project and inner project.

Cross project tasks is when two tasks are an entirely different things that don't have to do with each other. So think of this as a task that would live in your main business or your job, and then a task that sits in your side project. You wanna optimize your setup so that if they have nothing to do with each other, let's have them entirely different projects.

So to optimize a setup, I have a folder called slash projects. Then under that, I have each unique thing I work on. So I have slash build partners slash internal OS slash incubator website slash clients.

This lets me separate context and easily allow AI to work within that specific domain, and I'm confident that there will be no overlap. So I have these clear folders, and then in clawed code directly, I can select the project that I'm working on. By doing this, it separates the context entirely, and it easily allows AI to know what it should be working on, so I don't have to be worried about it working on a different project.

For inter project tasks, this is where it gets a little bit more tricky. You wanna think about tasks that are isolated. So if you're a software engineer, it's different parts of the app.

If you're a sales rep, it's different customer proposals. If you're a content creator, it's different scripts. You wanna think about different units of work that don't necessarily overlap.

If you're not sure where to work, here's a prompt that will work with you to identify the best task for you to work on simultaneously with AI. At this point, you've set up agents so that they can work simultaneously and complete tasks end to end.

But there's a bottleneck here too. From Boris, here is a limitation. Prompting and steering the model as you juggle sessions.

Step three is supervised autonomy, and this is the second of two operational paradigm shifts that we'll cover in this video. The unlock here is described by Boris. At this point, Claude proactively does work that you would have had to kick off manually before.

Maintenance and cleanup that used to wait for someone to find the time now runs continuously in the background. The key here is that Claude is proactively doing work for you. In step one, you became a better AI powered worker.

That was the first paradigm shift. In step two, you became an AI manager. And now in step three and step four, this is about becoming a manager of AI managers.

You become an AI agent CEO. And I like this visual of thinking of it like an org chart where you're at top and you're guiding everyone else below you. We'll cover the tactical ways to actually do this, but first, there's one limiting belief I hear more than any other that keeps people in step two instead of going to step three.

They'll say, it's faster if I just use AI and do it myself than set up a full system. And a lot of the times, the reality is that you're actually right. It is faster for you to do that specific task yourself.

But that isn't the point of all this, and here's the story that changed how I think about this. Back in 2021, I interviewed someone called Evan Vener on TikTok live. Shout out Evan.

And he told me, if you can hire someone to do a task 80% is good, do it. Later that week, I decided to hire my first two contractors, Liam, a social media manager, and Sarah, a video editor. For the first two weeks, each video and social post technically took me longer because I was teaching and training them.

But then it got faster, and then I wasn't involved at all. I had built a team that was able to scale my output without me being in the middle of it. That's the lesson I need you to take out of this.

Lose the battle to win the war. If it takes you more time today but will save you time in the long term, do it. So that's the mindset.

You're a CEO building a team. It may take longer to set up, and you're fine with that because you're building something that compounds. Now as the CEO managing AI agents, there are three things that you need to do, each pulled from Boris' blog.

The first is you have to create your company's standard operating procedures. Every business needs a concrete way to do things and complete tasks, and the best way to do this within Claude is creating Claude skills. These are reusable skills that do the same thing every time you run them, and you've probably heard of skills before, but the value of this clicks when you think about managing a team.

Skill think of these skills as a way to scale your output, codifying your processes without having to worry about AI hallucinating when you're not involved with a task. And my favorite way to create skills is what I call output driven skill creation.

Create a skill that is based on work you've already done. So for example, if you wanna create a topic research skill that exports a PDF, you would go back and forth with Claude, create a high quality output, and then write, based on this conversation, create a Claude skill that allows for this process to be reproducible.

This will create a skill called topic research report and make it so that if AI were to complete this without you, it would follow this exact process. And, yes, creating this skill when you're doing the task does take more time today, but it'll save you a headache in the future when you try and offload this task. Once you do that across your entire day or across your entire team, you're starting to build these standard operating procedures like you're scaling a team.

The second step is you want to establish delivery timelines and communication expectations. For this specific delivery, I use routines.

So this is Claude's way of scheduling tasks. I think of this a lot like saying to a coworker, hey. Every Monday at 8AM, I want this report sent to me.

And to do this, I would then use the skill that we already created, the topic research report generation skill, and then set up a routine to run that skill on Mondays. Then the key here is the communication expectations. Think about growing a team.

You need to hear from them about what they're doing and any problems they're having. So just setting up this routine is not enough. You need to communicate the results.

And so what I like to do is I use Slack for my entire team, and I have a channel called company updates where each of my AI employees will directly report their updates when they complete a task. And you might not have a team. That's totally fine.

But for you, just think about a location, whether it's WhatsApp, Telegram, Slack, where you can get these updates in a place that you'll actually check. So in the Slack example, you might just name it automation updates, and then that's where you get messages. To do this, I create a specific skill called send Slack update, and then I'll add that to whatever routines I want to see the output from.

After you've done that, it's time to find the bottleneck. Sometimes tasks take too long across your team and you need to find a better solution. The best way to do this is using sub agents.

Think of this like having an AI agent team swarm on a specific task. So let's say that task is research. So going back to that research example, let's say you wanna check YouTube, Google, Twitter, Instagram, and emails.

You can have a sub agent for each unique task, which will speed up the entire process. So you can say, enhance my topic research report generation skill to use sub agents for each unique platform. And this will cause it to fan out these agents to complete the task quicker.

And as the CEO of your team, you need to understand where your bottlenecks are and figure out these creative solutions. Depending on when you watch this, I'll have a video diving into exactly how to fix these bottlenecks using graph engineering. That'll be on my channel in about a week, so go check that out.

Now at this point, we're approaching AI native tier, and if you got this far, you're already crushing it. But there are limitations that Boris calls out. The trust at this point is in the loop and your team's decision throughput, and you have to ensure tokens are used efficiently as usage increases.

At this step, Boris describes the bottlenecks as your ability to trust in the loop and your team's decision throughput. And part of this is ensuring tokens are used efficiently as usage increases. Now both these bottlenecks will solve in step four.

Before we get to that, if this is your first video of mine, welcome to the channel. But if this is your second or more, you know the drill. This is our anti SLAP agreement.

The visuals, the testing, the hours of research, me misspelling things on this piece of paper, this is entirely built for humans, not for AI robots. So as part of this agreement, all I ask is you hit the subscribe button to help this content reach more people.

We're about 80 k subs, so shout out everybody who's already subscribed. Also, as a thank you, every video I give away a clawed max subscription. So this video's winner is hugo fam seven two one zero, who is using clawed to optimize a new drug against cancer.

That's obviously epic, so shout out Hugo for making the world a better place. Now for this video, comment below with a topic you'd like me to make the next video about, and I do accept sarcastic answers. Let's just have some fun in the comments.

Now step four of this whole process is becoming AI native. Once you get to this stage, here's how Boris describes it. The loop is fully closed and most agents are kicked off by Claude.

Hundreds to thousands of agents run. You steer by intent and monitor by exception. At this point, you stop starting things, you stop checking things, and you only look when something's wrong.

And then Boris says that the actual impact of this is that quarter long migrations become a workflow you kick off and check on. And honestly, this step is also why AI is really scary. When you properly set it up, it creates a recursive feedback loop that just builds things and fixes it without you ever being involved.

And that's the exact reason why AI gets better exponentially instead of just linearly. It no longer requires humans to improve and complete tasks. Now that's why it's scary, but that's also why it's exciting, and that's why we wanna capitalize And so now to get here, you have to become really good at two things.

You have to identify the right work to automate, and you have to keep token consumption economical while you scale. Now a quick horror story from this. One of my clients who firmly was in step three didn't have some of the proper guardrails set up.

And he told me that one morning he woke up, an AI burned through over $3,000 worth of tokens on a single task. It literally got stuck in a loop and was lighting money on fire.

So let's just make sure that that doesn't happen. So first, we're gonna optimize automated routines for less token consumption, and then we'll cover how to become an expert at identifying automation candidates.

To optimize these routines for token consumption, we're going to do two things. First is set the minimum viable model for each task. We'll go with MVM for short because we are running out of room.

So within any skill that you run, you can optimize them to select the specific model for the task. So simply put, you don't need the best model for a simple task. That's just wasting tokens.

So in a second, I'll share the prompt that will actually optimize your skills so that they only use the model that's actually required for that specific task. Then after that, we wanna establish the maximum amount of iterations a specific routine or loop can have.

In my client's case, this wasn't implemented, so AI just continuously looped until he manually stopped it. So what we do is establish a maximum number of iterations so that this never actually happens. Honestly, it's the simplest way to avoid these big issues, which becomes the actual problem.

Here's a prompt that will help you set the minimum viable product and also set the maximum amount of iterations. Now token optimization is a deep rabbit hole, and it depends on what you're using. So I do have a step by step walkthrough that uses my build partner dot a I plugin that will go step by step for free to optimize your setup.

Now the next thing to become an AI native expert is you have to identify automation candidates. The most important thing here is going back to a quote I mentioned earlier that frankly changed my life. If you can get someone to do something 80% as good, hire them.

It's the same thing here, but with one caveat. A task is fine being done at 80%, then use AI. A lot of the time, depending on the task, good is good enough, and those are perfect automation candidates.

Now for tasks where quality is critical, you don't wanna automate those end to end, And that one key distinction is the whole strategy for deciding what to hand off. Where is good good enough? Automate that.

Where is good not good enough? And don't automate that. Now at this point, you've gone through the four steps to become AI native.

Step one is AI assisted. You have AI doing tasks for you. This is the first of the two paradigm shifts.

Step two is AI builds in parallel. You have AI helping you work on multiple things at once, and you become an AI manager. Step three is supervised autonomy.

This is where AI is proactively working on things, you become an AI agent CEO. This is the second paradigm shift. And step four is where you become AI native.

AI is running automatically and you start optimizing the system. Now these are the exact four steps that Boris, the guy who created this tool, says there are to become AI native. And no matter what step you're on, you can get to the next step.

Now if you like this video, you will love this video where I walk through building a self improving system. It goes deep on steps two and three, and it makes it so that the system automatically gets better over time. So click here, and I'll see you over there.

The Hook

The bait, then the rug-pull.

Inside every company, Boris Cherny says, there's one person getting 10x the output while everyone else struggles to keep up, and he wrote down exactly what separates them. The catch: he wrote it for engineers, so this video translates his four-step adoption ladder into plain language anyone can apply today.

Frameworks

Named ideas worth stealing.

01:23list

Boris Cherny's 4 Steps of AI Adoption

Step 1: AI-Assisted
Step 2: AI Builds in Parallel
Step 3: Supervised Autonomy
Step 4: AI-Native

A ladder describing how a worker's relationship to AI changes: from AI doing things for you, to you orchestrating parallel agents, to AI proactively working while you supervise, to AI running itself while you monitor by exception.

Steal forFraming an internal AI-adoption rollout or coaching curriculum for a team

04:24concept

Two types of verification

Rule-based verification (objective pass/fail)
Taste-based verification (subjective quality judgment)

Splits AI output-checking into automatable objective rules and configurable subjective taste checks, both needed to remove yourself as the bottleneck.

Steal forAny QA layer for AI-generated content or code before it ships

08:20concept

Cross-project vs. inter-project task split

Cross-project: unrelated work, separate folders/contexts
Inter-project: related, non-overlapping units, safe to parallelize

A way to structure folders and Claude Code projects so parallel agents never collide on context or files.

Steal forOrganizing a multi-client or multi-product workspace for parallel AI work

CTA Breakdown

How they asked for the click.

VERBAL ASK

06:36product

“Try Accio Work free for 7 days”

Mid-video sponsor read for Accio Work (AI agent team platform), woven in right after the agent-autonomy discussion so the pitch follows the content logically rather than interrupting cold.

MENTIONED ON CAMERA

01:35linkBoris Cherny's "Steps of AI Adoption" doc ↗

06:36productAccio Work ↗

06:59toolAnti-slop Skill (BuildPartner.ai) ↗

FROM THE DESCRIPTION

PRIMARY CTAWhere the creator wants you to go next.

OTHER LINKSAlso linked in the description.