Anthropic Just Broke Prompt Engineering (And Replaced It With This)

Lessons from Building Claude Code: How “Skills” Are Changing AI Engineering from Thariq (anothropic claude code builder)

For years, we’ve treated AI like a black box-stuffing it with massive prompts and hoping for perfect outputs. But that approach breaks fast in real-world systems.

A better pattern is emerging.

Anthropic’s work with Claude Code introduces a powerful concept called “Skills”-and it’s quietly redefining how modern AI systems are built, scaled, and trusted.

Let’s break it down in a clean, practical way.

Watch on YouTube

---

What Are AI Skills (Really)?

At first glance, you might think skills are just instruction files.

They’re not.

A skill is an environment.

Think of it like a mini operating system for your AI agent:

• A folder (not just text)
• Includes scripts, APIs, configs, and data
• Can store memory and logs
• Can trigger tools and hooks dynamically

Instead of forcing an AI to “remember everything,” you give it structured access to what it needs-when it needs it.

This is the shift from prompt engineering → system design.

---

The 9 Types of AI Skills (That Actually Work)

After analyzing real-world usage, most effective skills fall into clear categories:

1. Library & API Skills

Teach AI how to correctly use tools and internal systems. Focus: usage patterns + edge cases.

---

2. Product Verification Skills

AI doesn’t just generate code-it tests it.

• Runs flows (e.g., signup, checkout)
• Uses tools like browsers or CLI environments
• Verifies outputs step-by-step

👉 This is where reliability comes from.

---

3. Data Fetching & Analysis Skills

Connect AI to real data systems.

• Query pipelines
• Monitoring dashboards
• Cohort analysis

Think: turning AI into a data analyst.

---

4. Workflow Automation Skills

Automate repetitive team tasks:

• Standups
• Ticket creation
• Weekly summaries

These are simple-but high ROI.

---

5. Code Scaffolding Skills

Generate structured boilerplate:

• New services
• Migrations
• Internal apps

Perfect when templates involve both code + human rules.

---

6. Code Quality & Review Skills

Enforce standards automatically:

• Style guides
• Testing practices
• AI-driven code review

---

7. CI/CD & Deployment Skills

Let AI manage shipping code:

• Monitor PRs
• Retry failures
• Deploy safely with rollback

---

8. Debugging & Runbook Skills

Turn AI into an on-call engineer:

• Investigate alerts
• Correlate logs
• Produce structured reports

---

9. Infrastructure Operations Skills

Handle sensitive operations with guardrails:

• Cleanup resources
• Manage dependencies
• Investigate costs

---

The Real Secret: Skills Are Built Around Failures

Here’s the counterintuitive insight:

The best skills don’t document success-they capture failure.

Instead of telling AI what it already knows, focus on:

• Edge cases
• Known bugs
• “Gotchas” unique to your system

This is where most AI systems break-and where skills shine.

---

Best Practices for Building High-Impact Skills

1. Don’t Waste Tokens on the Obvious

AI already knows general programming. Focus only on what’s unique to your system.

---

2. Build a “Gotchas” Section

This is the highest-value part of any skill. Continuously update it based on real failures.

---

3. Use Progressive Disclosure

Don’t overload context.

Instead:

• Organize files into folders
• Let AI discover details when needed
• Separate references, examples, and templates

👉 This keeps systems scalable and efficient.

---

4. Give AI Tools, Not Just Instructions

Include:

• Scripts
• Helper functions
• Reusable components

This shifts AI from guessing → composing.

---

5. Add Memory to Your Skills

Store past outputs:

• Logs
• JSON files
• Databases

Now your AI:

• Learns from history
• Tracks changes
• Improves over time

---

6. Avoid Over-Controlling the Model

Too many rules = fragile system.

Instead:

• Give guidance
• Allow flexibility
• Let AI adapt to context

---

7. Use On-Demand Guardrails

Don’t restrict everything globally.

Activate controls only when needed:

• Block dangerous commands
• Restrict file edits
• Protect production systems

👉 Balance freedom with safety.

---

Scaling Skills Across Teams

Skills become even more powerful when shared.

Two common approaches:

• Store them inside repositories
• Build an internal marketplace

The key is curation:

• Avoid duplicates
• Promote proven skills
• Let useful ones gain traction organically

---

The Bigger Shift: From Prompts to Systems

Here’s the bottom line:

AI doesn’t fail because it’s not smart enough. It fails because we design it poorly.

Skills represent a fundamental shift:

• From stateless prompts → persistent systems
• From instructions → environments
• From guessing → verifying

If you’re building with AI today, this is the direction things are heading.

---

Final Thought

The best way to understand skills isn’t to overthink them.

Start small:

• One skill
• One problem
• One “gotcha”

Then iterate.

That’s exactly how the most powerful AI systems are being built today.