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.