Why Anthropic Engineers Stopped Building New Agents: The Power of AI Skills

Anthropic engineers recently shared a surprising lesson from their internal research: they stopped building a new autonomous agent for every single task. Instead of deploying an army of specialized agents, they shifted their focus toward building modular AI skills for a single capable agent.

Today is October 8, 2026. As autonomous systems enter production across software development, research, and business operations, the multi-agent trend is hitting a wall of complexity. Teams that spun up separate agents for writing, code review, data extraction, and customer support are spending more time managing coordination failures than getting work done. Understanding how AI skills solve this bottleneck changes how you design automated workflows.

The Multi-Agent Complexity Trap

When developers first explore agentic automation, the natural instinct is division of labor. You create an agent for research, an agent for drafting content, an agent for sending emails, and a supervisor agent to orchestrate them all.

In theory, specialized agents sound elegant. In practice, this pattern introduces severe operational friction:

• State synchronization overhead: Every agent maintains its own conversation history, memory buffer, and prompt engineering instructions. Passing state reliably between agents requires extensive glue code and error handling.
• Compounding failure rates: If each agent has a ninety percent success rate, chaining four agents together reduces the overall task success rate to under sixty-six percent.
• Maintenance fatigue: Updating a shared business rule requires auditing every agent's system prompt individually.

Think about your smartphone. The underlying hardware is the processor, the agent loop is the operating system, and skills are the applications. When you need a new capability on your phone, you do not buy another phone; you install an application. AI skills apply this exact principle to agent architecture.

What Is an AI Skill?

At its simplest, an AI skill is a structured directory containing an instruction file, typically named skill.md or defined with standard metadata. It encapsulates the domain knowledge, operational constraints, and workflow steps required to complete a specific task.

A standard skill file contains two primary components:

1. Frontmatter metadata: A clear name and a concise description. The description is written specifically for the language model, explaining under what circumstances the skill should activate.
2. Procedural instructions: Clear, step-by-step guidance in plain English describing how to perform the work, which tools to invoke, and what output structure to produce.

Because a skill is stored as plain text alongside your project or user configuration, versioning, reviewing, and updating skills uses the exact same version control tools you use for ordinary code.

The Architecture of Progressive Disclosure

The real technical breakthrough behind skills is an architectural pattern known as progressive disclosure.

If an agent loaded the complete text of fifty different skills into its context window at the start of every session, it would consume tens of thousands of tokens before you even typed a query. This token bloat increases latency, drives up API costs, and dilutes the model's attention across irrelevant instructions.

Progressive disclosure solves this cleanly:

1. Lightweight discovery: On startup, the agent only reads the names and short descriptions of all available skills. This summary consumes a tiny fraction of the context window.
2. Intent matching: When you submit a request, the agent evaluates your prompt against its skill catalog.
3. On-demand activation: Only when a skill matches your request does the agent read the full skill.md file into active memory, executing the detailed steps with precision.

The toolbox stays closed until the specific tool is needed, keeping the agent fast, accurate, and cost-effective.

How to Build an AI Skill Step by Step

Creating an AI skill does not require writing complex Python orchestrations or managing distributed queues. There are three primary methods to construct a production-ready skill, ranging from direct manual authoring to automated workflow capture.

Step 1: Author the Skill Structure Manually

Writing a skill by hand is the best way to understand its internal mechanics. You define the boundary conditions, trigger rules, and operational workflow directly.

Create a folder for your skill and write a skill.md file:

---
name: youtube-researcher
description: Identifies viral content themes and outlier videos in a specified niche. Use when asked to find YouTube trends, viral topics, or video ideas.
---

### Workflow Instructions
1. Search the target niche on the video database.
2. Filter for uploads published within the last 30 days.
3. Identify videos with an outlier multiplier of at least 2x average channel views.
4. Group the top results into distinct thematic patterns.
5. Provide actionable title structures based on the top performers.

In this setup, the description provides the exact semantic anchors your agent uses to determine relevance during intent classification.

Step 2: Use Interactive Agent-Assisted Generation

The most practical everyday approach is to have your agent interview you to produce the skill. Rather than writing documentation from scratch, you explain your manual routine in conversation, and the agent asks structured clarifying questions.

You can initiate this workflow with a focused prompt:

I want to turn my repetitive task into a reusable AI skill. Ask me detailed questions one by one about my inputs, edge cases, tool dependencies, and desired output formats until you have enough information to write a comprehensive skill.md file.

The agent will systematically clarify:

• What APIs or command-line tools are required.
• How unexpected errors or empty search results should be handled.
• What formatting style or schemas the final deliverable must follow.

Once the dialogue concludes, the agent compiles the answers into a finalized skill file ready for deployment.

Step 3: Record and Automate Manual Workflows

The third method leverages screen recording and browser automation. For data entry, portal navigation, or file processing tasks that are difficult to verbalize, you record yourself performing the task.

The agent analyzes the sequence of user actions:

• Identifying which directories were opened.
• Extracting the naming conventions used for generated files.
• Tracing the exact parameters copied between enterprise web forms.

The agent translates these observed interactions into deterministic shell commands and validation steps, creating a skill that mirrors your exact operational routine.

Discovering, Sharing, and Securing Community Skills

Because the modern AI skill ecosystem uses open standards, a single skill folder can be shared across multiple agent platforms, including Claude, Cursor, Hermes, and custom agent runtimes.

Community repositories on GitHub and curated skill marketplaces offer pre-built skills for common engineering tasks, such as generating API documentation, auditing pull requests, and inspecting cloud infrastructure.

However, incorporating third-party skills introduces security responsibilities:

• Script execution risks: Skills can invoke local shell commands, fetch network dependencies, or read local configuration files.
• Malicious prompt injection: A poorly constructed or adversarial skill could attempt to exfiltrate environment variables or private API keys.
• Mandatory auditing: Before activating any downloaded skill, inspect the text completely or instruct your local assistant to scan the skill file for suspicious network calls, credential access, or shell substitutions.

Conclusion

The multi-agent paradigm was an intuitive first step toward AI autonomy, but modular skills offer a far more reliable engineering foundation. By consolidating capabilities into reusable text-based instructions and loading them through progressive disclosure, developers can build resilient, cost-effective assistants that expand their capabilities over time without compounding architectural complexity.

Merits

• Consolidates system maintenance into a single core agent rather than multiple brittle sub-agents.
• Minimizes context window consumption through progressive disclosure and on-demand loading.
• Simplifies version control and peer review by storing procedures as plain markdown text.
• Enables seamless cross-platform skill portability across modern agent environments.
• Lowers operational API costs and latency by eliminating unnecessary inter-agent chatter.

Demerits

• Complex multi-step reasoning still requires careful instruction engineering inside the skill file.
• Poorly defined skill descriptions can cause false-positive activations or missed triggers.
• Third-party skills present potential security risks if executable scripts are included without auditing.
• Monolithic agent loops can struggle if a single prompt triggers multiple overlapping skills simultaneously.

Caution

This article is for educational purposes only. Procedures, code samples, and placeholder configurations must be adapted to your specific environment and security policies. Always inspect and audit third-party AI skills before deploying them on systems with access to production data or private credentials.

Frequently asked questions

• Why are engineers moving away from multi-agent systems? — Multi-agent systems often introduce high coordination overhead, compounding failure rates, and difficult state management compared to a single agent equipped with modular skills.
• What is an AI skill? — An AI skill is a structured folder containing instructions, typically in a markdown file, that teaches an agent how and when to execute a specific task.
• What is progressive disclosure in AI agents? — Progressive disclosure is a design pattern where an agent only loads skill names and descriptions initially, loading full instructions only when a task matches.
• How does an agent know which skill to use? — The agent compares the user prompt against the semantic descriptions in its skill catalog to select the relevant tool.
• Can AI skills run code? — Yes, skills can include instructions to invoke shell commands, command-line scripts, or external APIs depending on the permissions granted to the agent.
• Are community skills safe to install? — Community skills should always be audited before use because they can potentially execute unauthorized scripts or access sensitive files if not verified.
• Do AI skills work across different AI tools? — Yes, open skill specifications allow compatible markdown skills to function across tools like Claude, Cursor, Antigravity, and other modern agent frameworks.

Tags

#aiagents #anthropic #softwareengineering #promptengineering #automation #artificialintelligence #developers #aiarchitecture #llm #techguide