4 Rules Anthropic Engineers Use to Prompt Claude Code

Before we get to the rules that will transform how you work, we need to understand the foundation of how Anthropic engineers use Claude.

The Mental Shift

Generally, when people first start using AI, they start writing new prompts for everything they do. But the reality is most of what people do is repetitive tasks.

Anthropic engineers created Claude Skills to help tackle these repetitive tasks. As Barry from Anthropic describes it:

In other words, they're folders. "Procedural knowledge for agents" is a fancy way to say a way to get a task done.

Practical Example

Here's what it could look like if you wanted to draft a response to an email:

• Old way: Write a crazy prompt to help you respond to an email with your voice, your tone, and your writing style
• New way: Just type /draft-email and then bring in the email you want to respond to

The Three-Layer Model

If you were to compare this to your cell phone, Anthropic is building the phone itself. You have to create the apps. That's the layer to control.

So you're convinced you need to change how you prompt to prompt skills. The next question is: How do you actually create skills that work?

The Three Layers Inside a Skill

A skill is more than a prompt that lives in a folder. Inside a skill, there are three layers:

1. Layer 1: The Description
   This is what Claude checks every time you ask a specific question, and it determines if it should use the skill or not. Think of it like a title on a folder. If the label's vague, Claude's going to have a tough time identifying when to use it. If it's specific, it'll know exactly when it needs to use it.
   
   Yes, when you're prompting Claude, you don't need to explicitly call a skill if it's properly described. Claude will automatically know when to use it.
2. Layer 2: The Instructions
   Once Claude grabs the skill, this is the playbook it follows. This is a step-by-step process on how to actually complete the task.
3. Layer 3: The Tools
   This is code scripts, API calls, reference files. This is where a skill becomes a lot more than prompts, and this layer three is where most of the leverage lives, but most people stop at layer two.

Real Example: Domain Checking

Instead of going back and forth manually thinking about domains, the author created a custom skill that could check domains programmatically. Whatever domains Claude suggested, it already verified that they could be purchased.

By giving this skill access to the right tool, it leveled up the entire process. Now 10 different sub-agents could use this skill to look through 10,000+ domains to find the right one—something literally impossible to do manually.

Pulling directly from Anthropic's engineering blog about what skills are and how to position them, they are: composable, portable, efficient, and powerful.

What Does Composable Mean?

Composability means multiple skills can work together with Claude automatically coordinating which to use. What this means is you should have small, focused, and reusable skills that can work together, versus having a single massive skill that does everything.

Real Example: Content Creation

When the author first started building skills for their content engine, they built a single /content-creation skill that did everything: generated ideas, wrote scripts, drafted social posts. All of it. One skill, a million possibilities—and it just became unmanageable.

Every time they wanted to change how scripts were written, they had to rewrite the whole skill and didn't know what it actually impacted.

The solution? Split it up into more specific skills:

• /youtube-idea-research
• /youtube-script-writer
• /linkedin-post

Each skill had a specific goal in mind, and the benefit is that each can call the other skills, so they start chaining them together.

Three Benefits of Composable Skills

1. Issues are easy to spot
   When a focused skill breaks, you know exactly where to look. Whereas if it's a giant skill, you don't know what exactly the issue was.
2. Improvements compound
   If you update, let's call it /youtube-idea-research, every workflow that uses the same skill automatically gets upgraded. Whereas if you're using a giant skill, you're going to have overlapping functionality, which means you'll fix it in one skill and it will still be broken in the other.
3. You can reuse instead of rebuilding
   If you build something like the check domain skill mentioned earlier, you can plug that into any workflow you want. You're not rebuilding the wheel every time with a new workflow.

Technical Patterns from Anthropic Engineers

Pattern 1: Save Scripts Inside of Skills

This is part of the tools layer of a skill and it's how you actually make them sharper. Barry at the AI Engineering Code Summit explained:

Claude kept rewriting the same Python script every session. Instead of letting it rewrite it, they saved the script inside of a skill folder. Now the next session Claude doesn't have to rewrite the script—it just reruns it.

General rule of thumb: If you can use code instead of AI, you should. And you don't have to write the code—you can just have AI write it for you once and then you can reuse it as much as you want.

Pattern 2: Control Who Invokes What

Most people don't know this exists, but Anthropic built two flags into Claude's skills that are important to understand:

• User Invocable (set to false)
  This hides the skill from your slash menu. It means that the user (you or me or whoever) can't directly invoke this skill. It's only a skill for agents. This is perfect for any AI agent-specific tools that you don't even want to think about.
• Disable Model Invocation
  This does the opposite. Only you can run it and the model can't. This is great for higher-risk things like a skill that sends a message or deploys a new version of your code to production.

Here's where Anthropic engineers really pull ahead. Their skills—and in turn their prompting—doesn't just work. They get better every session.

The Compounding Loop

When you prompt Claude with a sentence, that prompt disappears the moment you close the chat. When you prompt with a skill, the skill stays. And every time you use it, you have a chance to sharpen it.

How to Actually Do This

Every time Claude learns something about how you work—your voice, your process, your edge cases—you write it down in the skill. Next session starts smarter than the last.

Every time you run a skill and the output isn't exactly what you want, ask yourself one question:

If it's forever, update the skill. Add the rule, the example, the edge case.

The Common Mistake

A lot of people skip this entirely. They're just like, "Okay, run the skill, get an output," and continue with their day. But Anthropic engineers use a skill, get the output, then update the skill so that there's a compounding loop that improves over time.

It's really quite simple. You can literally use your chat history as a reference point to improve the skill itself. Just say: