16:15Austin Marchese · Tutorial
How Anthropic Employees ACTUALLY Use Claude Skills
A 16-minute extraction of Anthropic's internal playbook, collapsed into five lessons any Claude Code user can implement today.
June 23rdThe argument in one line.
The creator of Claude Code built a high-output automation system not by building more skills, but by passing every skill through a frequency test, equipping six focused agents to run them, and treating skill debt as seriously as technical debt.
Read if. Skip if.
READ IF YOU ARE…
- You already use Claude Code and want to see what a disciplined practitioner's setup looks like from the inside.
- You've built several skills but are not sure which ones are worth keeping — and which are just adding noise.
- You want a practical walkthrough of agents, hooks, loops, and scheduled tasks beyond the docs.
- You've noticed your prompting patterns repeat and wonder whether they should be formalized.
SKIP IF…
- You have never used Claude Code before — this assumes basic familiarity with the tool.
- You are looking for a beginner intro rather than a workflow optimization playbook.
The full version, fast.
Boris Cherny runs his entire development workflow through three filters: a frequency test that decides what becomes a skill (do it 2-3x a week, follows a pattern, benefits from preloaded context), four multiplier strategies that extract more from each skill without adding new ones (agents for when, hooks for automatic triggers, loops for in-session timers, schedules for cloud cron runs), and a quality-over-quantity discipline that caps active skills at 5-10 and audits for drift. The deeper lesson is the dual-use principle: every skill Boris builds can be invoked both by him and by Claude autonomously, which is what turns a collection of shortcuts into a self-running toolkit.
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 →Where the time goes.
00:00 – 00:25
01 · Cold open
Sets up the premise: Boris automated his work with a few simple skills, and this video reverse-engineers exactly how.
00:25 – 02:36
02 · Section 1: The Inner Loop
The three-question frequency test for deciding what becomes a skill. Boris's seven documented skills and what makes them earn their place.
02:36 – 05:47
03 · Section 2: The Most Powerful Features
Four multiplier strategies: agents (decide when), hooks (auto-fire on events), loops (in-session timer), schedule (cloud cron). Three real hook examples from Boris's config.
05:47 – 07:12
04 · Section 3: Quality Over Quantity
Skill debt, the 5-10 active skill ceiling, the dual-use principle, and an audit prompt for cleaning house.
07:12 – 10:07
05 · Outro / sponsor
Free email course CTA, subscribe request, BuildPartner.ai mention.
Lines worth screenshotting.
- Boris Cherny has exactly seven documented skills — every single one passes a three-question frequency test before being built.
- Skills are instructions; agents are employees who decide when those instructions should run.
- A Claude hook fires automatically on a system event with no prompt required, making it the closest thing to true background automation inside a session.
- The stop hook is deceptively simple: it just keeps answering yes to Claude's own 'should I keep going?' until the work is finished.
- Skill debt is the accumulated maintenance cost of automations that drift as workflows change and models improve.
- Every skill Boris builds is dual-use: both he and Claude can invoke it, which is what separates a toolkit from a to-do list.
- Boris deletes and rewrites his entire setup constantly — there is no part of Claude Code that survived from six months ago.
- The question is not how many skills to build but how many you can actively maintain; for most people that ceiling is 5-10.
- /loop runs a skill on a repeating timer inside your current session; /schedule runs the same skill on a cron outside the session entirely, in the cloud.
- The best skill audit asks three things: unused in a month, conflicts with another skill, or replaceable by a single prompt — delete all three categories.
Build fewer automations. Maintain them better.
WHAT TO LEARN
The most productive Claude Code setups are not the largest ones — they are the most honest ones, built around a frequency test and maintained with the same discipline used to write the skills themselves.
- Before building any automation, ask three questions: do you do this 2-3 times a week, does it follow the same pattern, and would preloaded context help. All three must be yes or it stays a one-off prompt.
- Agents and skills are different layers: skills encode how to do something, agents encode when to do it — separating these two concerns keeps each file small and focused.
- Hooks let you attach automated behavior to system events (file writes, task stops, session starts) without any manual trigger, which means your environment can improve itself as you work.
- /loop and /schedule are not the same: loop runs within your active session on a timer, schedule runs in the cloud on a cron independent of any open session.
- Skill debt accumulates silently — every skill you build is a maintenance contract that grows stale as models improve and your workflow shifts, so deletion is as important as creation.
- The dual-use principle is the design constraint that makes skills scale: build every skill so Claude can invoke it on its own, not just so you can trigger it manually.
- Cap your active skill count at what you can honestly maintain — 5-10 is the realistic ceiling for most people, not 50 — and run a regular audit against three criteria: unused in a month, conflicts with another skill, or replaceable by a single prompt.
Terms worth knowing.
- Inner loop
- The recurring daily or weekly tasks that define a practitioner's core workflow — used here as the filter for deciding what deserves to become a permanent skill.
- Skill (Claude Code)
- A reusable slash command stored in .claude/commands/ that encodes a repeatable workflow so Claude can execute it without re-prompting.
- Hook
- A Claude Code configuration that fires automatically when a specific event occurs (file write, task stop, session start) without requiring a manual prompt.
- Agent (Claude Code)
- A specialized subagent file stored in .claude/agents/ that scopes Claude to a single role or review function, invoked by name or automatically.
- /loop
- A built-in Claude Code command that runs a skill on a repeating timer within the active session.
- /schedule
- A built-in Claude Code command that schedules a skill to run at a specific time or on a cron interval in the cloud, outside any local session.
- Skill debt
- The maintenance burden that accumulates when you build more skills than you actively use — each one requires upkeep as workflows evolve and models improve.
- Dual-use skill
- A skill designed so that both the human operator and Claude itself can invoke it autonomously, rather than one that only responds to a manual prompt.
- Post-tool-use hook
- A hook that triggers after Claude uses a specific tool (e.g., the write tool), used here to auto-format code every time Claude writes a file.
- Session start hook
- A hook that fires when a new Claude Code session opens, typically used to preload project context automatically.
Things they pointed at.
Lines you could clip.
07:49
“The more you build, the more you owe in maintenance.”
09:00
“The question shouldn't be how many skills should I build, it's actually how many can I actively maintain?”
09:40
“The best system isn't the one with the most skills, it's the one where nothing is wasted.”
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.
Boris Churney, the creator of Claude code claims that he's automated his workflow with just a few simple skills. So I dug into his interviews, his threads, his files, and it turns out that Boris has a simple system that anyone can follow. I'm So gonna walk you through exactly how he uses Claude skills, show you how to apply it in your own workflow whether you're technical or not, and then cover two features you probably aren't using that Boris calls the most powerful features in Claude code.
Okay. Section one is the inner loop. Let's start with the foundation.
Boris has a philosophy when it comes to skills. I believe one of them is what's better than doing something? Having Claude do it.
Simply put, why should you do it when you could automate it? But he doesn't automate everything. He has a test for when something should become a skill.
He calls it his inner loop. He tweeted, I use slash commands for every inner loop workflow I do many times a day. This saves me from repeated prompting.
Now, says slash commands here, but think of slash commands as simple clawed skills. So in this video, I'm just gonna call them skills. Now, if he's doing something multiple times a day, that's when he decides to make it a skill.
He's very selective. And this may seem obvious, but in practice, most people don't actually do it. They usually fall into two buckets.
The first is that there's people who never use skills, so they re prompt every single day and are creating compounding systems. Then on the other hand, there's people that make skills for everything which creates an entirely different problem that I'll cover later in this video. And unfortunately, I actually fall in the second bucket.
I try and make too many skills. But Boris, he sits in the middle of these two buckets. Selective, but not overly selective.
Based on public info, he has seven skills that he's documented, and all of them have earned their place. So a simple test before you actually create a skill, run it through your inner loop test. Do you do it two to three times a week?
Does it follow the same pattern each time? And would preloaded context help? If it's yes to all three, make it a skill.
Okay. But what skills does Boris actually use? His most used is slash commit dash push dash p r.
This skill commits his code, pushes it to GitHub, and then creates a p r. It is a simple, well defined skill that's clearly named for what it actually does. And clearly defined workflows like this help him have an extremely high output.
Every day I ship, like, ten, twenty, 34 requests, something like that. 100% written by quad code. I have not edited a single line by hand.
For those nontechnical folks watching, that's a lot of p r's and I highly doubt these are just small changes. Now his other skills handle things like running tests, reviewing code for bugs, and cleaning up at the end of sessions. These are all technical things because that's his focus, but every single one passes the same filter, well defined things you do repeatedly.
So if you don't know where to start, paste this prompt into Claude code. Based on my Claude code session history, what are the tasks I do repeatedly that should become Claude's skills? Like, Claude did the heavy lifting and it'll identify things that you should work on.
Section two is the most powerful Claude code features. The reality is once you create these skills, you're gonna forget to run them or not remember when you should run them. So Boris, he doesn't just run these skills manually.
He uses four different strategies. Agents, hooks, loops, and schedules. Strategy one is agents.
Think of an agent like an employee that's trained to use Claude skills. Skills are how to do something and the agent determines when to do it. So Boris has six agents and it's the same restraint as his skills.
Each one does one thing. Here's a look at six of them, but my favorite is his staff reviewer and I'm actually implementing these for some of the clients I work with. Essentially, it's a skeptical senior engineer that looks at your plan and gives a verdict.
Approve, request changes, or needs to rethink. It doesn't actually build anything. It just reviews.
That's the only job. And on my personal projects, I do the same thing. Here's a folder with my agents and I have specific agents that service consultants with specific expertise.
They each review my work from a different angle, whether that's packaging, positioning, content strategy, curiosity gaps. I rarely actually call these agents. I just say review this content or review this video, and Claude is smart enough to grab the right expert.
To create your own agent, here's a prompt that can be helpful. I wanna create an agent that acts as a role. It should be an expert in context and review my work from this angle with direct feedback.
Create the agent file. Strategy two is hooks. These are things that Claude automatically triggers based on things that happen within Claude code.
Here's Boris explaining it. So stop hook runs whenever the turn is complete. And so you can define a stop hook that's like, if the tests don't pass, return
the text keep going. And essentially, it's like you can just like make the model like keep going until the thing is done. So a hook fires automatically when a specific event happens.
Let's say Claude finishes a task, a hook fires. Claude edits a file, a hook fires. You don't prompt it, it just runs in the background.
Here are three examples of hooks that Boris uses. Post tool use, stop, and session start. His post tool use triggers after a tool is used.
So for him, if Claude uses the write tool, which is like when it writes to files, it then runs an auto formatter to make sure that the code is formatted properly. He tweeted about this one and he said that the hook handles the last 10. So it's a cleanup mechanism.
The second hook stop triggers when Claude stops working after a back and forth. He has it set up to keep going when there's work remaining. So basically, when Claude's like, should I keep going?
He basically says on repeat, yes, you piece of keep working. That's what I pay you for. Hook three is session start, which starts every time you create a new clawed session.
And he has it load in context the moment the session opens. Now, the hooks that Boris uses are focused on productivity, which is great. But another way to use it is for compounding or improving your clawed code workspace.
In my projects, I have a slash knowledge folder that has a ton of training data. And whenever I add anything to this folder, I have a post tool hook where it triggers on right where it looks to see if the file added is in the knowledge folder. And if it is, it runs a skill I made called ingest source, which makes sure that it's ingested properly.
Here's a prompt that you can use to set up a skill that does exactly this. When you set this up properly, your system automatically improves over time as you're adding more training data. So that was agents and hooks.
And now for the last strategies, which are loops and schedule. Boris made this statement.
Two of the most powerful features in Claude code are loop and schedule. Slash loop runs a skill on a timer. So Boris runs slash loop five minute slash babysit, which means every five minutes Claude checks if there's anything that needs attention.
These loops run-in the specific session that you trigger it. Then slash schedule does something similar, but at a specific time or on a specific schedule and that runs in the cloud outside of your local project. This is where you can set up an entire Claude system to automate these processes, these workflows, these skills.
I have a slash build partner colon improve system skill that runs automatically on a schedule where it will review my project and suggest improvements that I can then merge into the project itself. As you layer in these schedules and these loops, now your clawed code sessions just get that much more powerful. So that's agents, hooks, loops, schedules.
Four ways to get more out of the skills that you already have without building more of them. Now, before I get into what I think is the most counterintuitive thing, I know I'm covering a lot here pretty quickly. So if you want a more in-depth walkthrough, I put together a free five day email course that dives deeper into some of these concepts.
Now, I'm highly confident that based on thousands of people that have gone through this, you will love this. But, if you don't, you can unsubscribe at any time. Here's actually a message that somebody sent me on Instagram the other day which fired me up about how helpful it was.
So, go check that out. It is the first link in the description. Also, while you're at it, subscribe to the channel.
Alright. Section three is about quality over quantity. So, mentioned earlier that I fall into the bucket of automating too much or trying to make too many skills.
I have probably like 40 skills, but I really only use like five or six of Now, when I type slash, I have a million different skills that I see and I forget which ones I actually use. The reality is that every skill you build is a tool that you have to maintain over time. And as your workflow changes, these skills drift and they may not actually work anymore.
This is a concept that I call skilled debt. The more you build, the more you owe in maintenance. Boris gets this.
He deletes and rewrites constantly. All of quad code has just been written and rewritten and rewritten and rewritten over and over and over. There is no part of quad code that was around six months ago.
They rewrite everything. The reality is skills are not permanent. They're living tools.
And because they're so easy to create, they're also easy to just delete and get rid of. I mentioned it earlier, but I have a skill slash build partner colon improve system that will review skills, check for outdated info, contradictions, and bloat. And you need to constantly be doing this because as models get better, what you need in the skill actually changes.
So the question shouldn't be how many skills should I build, it's actually how many can I actively maintain? For most people, that's probably five to 10, not 50. Now for the skills that do survive,
here's a key mindset shift. Stop thinking of skills as instructions you give Claude. Think of them as tools you equip Claude with.
That's exactly what Boris is doing. Here's him explaining it. And this is part of the philosophy also, like, everything is dual use.
Um, so for example, the model can also call slash commands. So, like, you know, I have a slash command for a slash commit,
where I run through kind of a few different steps, like diffing and generating a reasonable commit message and and this kind of stuff. I run it manually, but also Claude can run this for me. Uh, and this is pretty useful because we get to share this logic.
His slash commit skill isn't, hey, Claude, commit my code. It's a tool Claude has in its toolkit that it knows how to use on its own. Boris runs it manually and Claude can run it without him.
So when you're building skills, the question isn't what do I want to tell Claude to do. It's what tools could I create to help Claude help me. So here's a prompt that can do two things.
Cleans up the skills that you're not using and upgrades the ones that you are. Review all my skills, flag any that I haven't updated in a month that conflict with another skill, or that a simple prompt could replace. For the ones worth keeping, rewrite them so Claude could run them on its own without me triggering them.
That's how you go from a pile of instructions to a toolkit that scales. So zooming out, Boris created Claude code. He could have automated anything, but he chose to be precise instead of building millions of automations.
The lesson isn't what he built, it's what he didn't build. Every skill passed the frequency test, every agent has one job, hooks and loops get more out of each skill without adding any debt, and when he builds a skill, he builds it as a tool both he and Claude can use. The best system isn't the one with the most skills, it's the one where nothing is wasted.
Now, if you wanna see exactly how I set up my projects, my skills, and apply these principles in my exact setup, check out this video. If you got this far, welcome to the channel and I'll see you over there. Peace.
The Hook
The bait, then the rug-pull.
The creator of Claude Code has seven skills. Not seventy — seven. And every single one of them passed a test most builders skip entirely.
Named ideas worth stealing.
01:25list
The Inner Loop Test
- Do you do it 2-3+ times a week?
- Does it follow the same pattern each time?
- Would preloaded context help?
All three must be yes before building a skill. Filters out one-offs and keeps the skill library lean.
Steal fordeciding what deserves a Claude skill vs. a one-time prompt
02:36list
Four Multiplier Strategies
- Agents — decide when to run a skill
- Hooks — fire automatically on system events
- Loops — repeat a skill on a timer in-session
- Schedule — cron-based runs in the cloud outside any session
Get more output from fewer skills by adding automated triggers rather than building new automations.
Steal forscaling a small well-maintained skill library without adding maintenance debt
07:49concept
Skill Debt
Every skill is a maintenance contract. As models improve and workflows change, unused or outdated skills become a liability — requiring audit and deletion, not just addition.
Steal forjustifying a regular skill audit and capping total skill count
08:21concept
Dual-Use Skill Design
Build every skill so both the human operator AND Claude itself can invoke it autonomously. Transforms individual shortcuts into a self-running toolkit.
Steal forwriting skills that compound without extra prompting
How they asked for the click.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
