Claude Skills 2.0: 7 Game-Changing Features That Transform Prompt Injection Into a Programmable Agent Framework
Claude Skills 2.0: 7 Game-Changing Features That Transform Prompt Injection Into a Programmable Agent Framework
Claude Skills 2.0 is not an incremental update. It is a fundamental paradigm shift—from static markdown instructions injected into conversation context to a fully programmable agent execution platform with isolated sub-agents, runtime data injection, and software-grade testing. Here is what changed, why it matters, and how to start building with it today.
What Are Claude Skills? A Quick Primer
Claude Skills are modular capability packages for Claude Code, Anthropic's CLI-based AI coding assistant. Each Skill bundles instructions, metadata, scripts, and resources that Claude loads automatically when relevant to a task.
Skills 1.0, launched in October 2025, operated as a prompt injection system. A Skill meta-tool existed inside Claude's tool array, containing an <available_skills> list. When triggered, two messages were injected into the conversation—metadata plus the full skill prompt. Claude then followed those injected instructions inline (mikhail.io).
The problem was clear. Skills 1.0 had no isolation, no runtime data access, no parallel execution, no quality measurement, and a hard 15,000-character budget for skill descriptions. Custom commands (.claude/commands/) and Skills (.claude/skills/) existed as two separate systems with overlapping purposes and no interoperability.
Skills 2.0 resolves every one of these limitations.
1. Unified Command and Skill System: One File, Full Power
The most immediately impactful change in Skills 2.0 is the merger of custom commands and skills into a single extension system (code.claude.com).
Before (Skills 1.0):
| System | Path | Capabilities |
|---|---|---|
| Custom Commands | .claude/commands/deploy.md |
Slash command only; no frontmatter, no sub-agents, no dynamic context |
| Skills | .claude/skills/deploy/SKILL.md |
Auto-invocation only; users could not call directly |
After (Skills 2.0):
A single file in either location produces a /deploy slash command and supports every advanced feature—frontmatter control, sub-agent execution, dynamic context, tool restrictions, and model overrides. If both locations contain a same-named skill, the skills/ version takes priority. Backward compatibility is complete: existing custom command files work without modification.
This eliminates the confusion of maintaining two parallel systems and lowers the barrier to adopting advanced features. Add a YAML frontmatter block to any existing command file, and sub-agent execution becomes available instantly.
2. Sub-Agent Execution With context: fork
This is the architectural breakthrough that transforms Skills from reference documents into autonomous agents.
The problem with inline execution: In Skills 1.0, every skill ran inside the main conversation context. Long research tasks or complex analyses consumed the context window rapidly, mixed with prior conversation history, and degraded accuracy.
The solution: Setting context: fork in a skill's frontmatter launches it in an isolated sub-agent. The sub-agent has no access to conversation history—only the SKILL.md content serves as its prompt. When complete, only the result returns to the main conversation (code.claude.com).
---
name: deep-research
description: Deep research on a specific topic
context: fork
agent: Explore
---
Research $ARGUMENTS in depth:
1. Use Glob and Grep to find relevant files
2. Read and analyze code
3. Summarize findings with specific file references
Available agent types:
| Type | Purpose | Key Characteristic |
|---|---|---|
Explore |
Read-only codebase exploration | No Edit/Write tools—safe for research |
Plan |
Implementation planning | Architecture design, tradeoff analysis |
general-purpose |
Full-capability tasks | Access to all tools |
Custom (.claude/agents/) |
Organization-specific agents | Custom-defined agent files |
Why this matters for enterprise teams: Context preservation. Your main conversation retains full coherence while heavy-lifting tasks run in isolation. A code review skill can analyze 50 files without polluting the context you need for follow-up questions.
3. Dynamic Context Injection With !`command`
Skills 1.0 delivered only static text to Claude. If a skill needed the current branch name, PR status, or environment variables, Claude had to execute commands at runtime—consuming additional tokens and introducing latency.
Skills 2.0 introduces the !`command` syntax: shell commands that execute before the skill prompt reaches Claude. The results replace the command inline, so Claude never sees the command itself—only the output (medium.com).
---
name: pr-summary
description: Summarize the current pull request
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---
## Pull Request Context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`
## Task
Summarize this Pull Request and suggest review points.
When Claude receives this skill, !gh pr diff`` has already been replaced with the actual diff output. This is a preprocessing step, which means zero tool-call overhead for context gathering. The practical impact: faster execution, lower token costs, and complete context from the first inference.
4. Granular Invocation and Tool Control
Skills 2.0 introduces fine-grained control over how skills are triggered and what tools they can access.
Claude Code Skills documentation: Create, manage, and share skills to extend Claude's capabilities. Source: code.claude.com
Three Invocation Modes
| Configuration | User / Invocation |
Claude Auto-Invocation | Best For |
|---|---|---|---|
| Default | Enabled | Enabled | General helper skills |
disable-model-invocation: true |
Enabled | Blocked | Deployment, deletion, destructive operations |
user-invocable: false |
Hidden | Enabled | Background knowledge, coding conventions |
Tool Restriction With allowed-tools
allowed-tools: Read, Grep, Glob, Bash(git diff *), Bash(gh pr *)
This configuration permits file reading, search, git diff, and gh pr commands—and blocks everything else. Skills 1.0 could only pre-approve tools for automatic use. Skills 2.0 restricts the scope of available tools, implementing a least-privilege model for each skill.
New Frontmatter Options
| Frontmatter | Function | Status in 2.0 |
|---|---|---|
argument-hint |
Autocomplete hint for arguments | New |
disable-model-invocation |
Block Claude auto-invocation | New |
user-invocable |
Hide from / menu |
New |
model |
Per-skill model override | New |
context |
Sub-agent execution mode | New |
agent |
Sub-agent type selection | New |
hooks |
Skill-scoped lifecycle hooks | New |
5. Skill Creator: Test, Measure, and Refine Like Software
Introducing Agent Skills: Claude can now use Skills with built-in evaluation. Source: claude.com/blog/skills
Before Skills 2.0, measuring whether a skill actually worked required manual trial and error. The Skill Creator introduces software-testing paradigms for AI agent capabilities (claude.com).
| Feature | Description |
|---|---|
| Evals | Define test prompts and expected outcomes; receive pass/fail results. Use as regression tests when modifying skills |
| Benchmarks | Track pass rate, execution time, and token consumption. Integrate with CI systems |
| A/B Comparison | Blind-compare two skill versions (or skill vs. no skill). A judge agent evaluates without knowing which version it scores |
| Multi-Agent Evals | Independent agents run evaluations in parallel with isolated contexts and separate metrics |
| Description Optimization | Analyze skill descriptions against sample prompts to reduce false positives and negatives |
This is the difference between "I think this skill works" and "this skill passes 94% of test cases with a median execution time of 12 seconds." For enterprise teams managing dozens of skills across an organization, measurability is the foundation of reliability.
6. Progressive Disclosure Architecture: Smarter Token Management
Skills 1.0 loaded skill descriptions into a fixed 15,000-character budget. More skills meant truncated descriptions and recognition failures.
Skills 2.0 introduces a three-level hierarchical information disclosure system (platform.claude.com):
| Level | When Loaded | Token Cost | Content |
|---|---|---|---|
| Level 1: Metadata | Always (session start) | ~100 tokens per skill | YAML frontmatter: name + description |
| Level 2: Instructions | On skill trigger | Under 5,000 tokens | SKILL.md body |
| Level 3: Resources/Code | On demand only | Virtually unlimited | Bundled files (executed via Bash, not loaded into context) |
The critical insight about Level 3: Script code never enters the context window. When Claude executes validate.py, the code itself stays outside the context—only the execution result ("Validation passed") consumes tokens. This means you can bundle extensive reference materials, templates, and utility scripts without any context penalty.
The context budget is now dynamically calculated at 2% of the context window (with a 16,000-character fallback), replacing the fixed 15,000-character cap. You can inspect usage with the /context command and override with the SLASH_COMMAND_TOOL_CHAR_BUDGET environment variable.
7. Five Bundled Skills Ship Out of the Box
Skills 2.0 includes five production-ready workflow skills pre-installed in Claude Code:
| Skill | Function | Example Use Case |
|---|---|---|
/batch <instruction> |
Decompose large changes into 5-30 units, each running in an independent git worktree with parallel agents | "Migrate all APIs from REST to GraphQL" |
/simplify [focus] |
Three review agents analyze code quality in parallel, then merge improvements | Post-refactoring quality verification |
/loop [interval] <prompt> |
Repeat a prompt at set intervals during a session | Deployment pipeline monitoring |
/debug [description] |
Analyze debug logs from the current session | Diagnosing unexpected Claude behavior |
/claude-api |
Load Claude API reference for the project's language | SDK usage reference |
These bundled skills demonstrate the sub-agent and parallel execution patterns that Skills 2.0 enables. /batch, for instance, creates separate git worktrees and dispatches independent agents to each—a workflow that was architecturally impossible in Skills 1.0.
Skills 1.0 vs. 2.0: Complete Comparison
| Dimension | Skills 1.0 (October 2025) | Skills 2.0 (2026) |
|---|---|---|
| Core paradigm | Markdown instruction injection | Programmable agent platform |
| Command/Skill relationship | Separate systems | Unified: same file works as slash command and skill |
| Execution model | Inline only | context: fork for isolated sub-agent execution |
| Context injection | Static (file content only) | Dynamic (!`command` for runtime data) |
| Invocation control | Auto-recognition only | User-direct + auto + disable-model-invocation |
| Tool access | No restriction possible | allowed-tools for scope limitation |
| Model selection | Not available | model frontmatter for per-skill override |
| Context budget | Fixed 15,000 characters | Dynamic 2% of context window |
| Evaluation | None | Skill Creator + evals + A/B testing + benchmarks |
| Bundled skills | None | /batch, /simplify, /loop, /debug, /claude-api |
| Deployment scope | Project only | Enterprise > Personal > Project > Plugin (4 tiers) |
| Monorepo support | Limited | Nested directory auto-discovery |
| Namespacing | None | plugin-name:skill-name collision prevention |
Practical Design Patterns for Teams
Pattern 1: Background Knowledge (Auto-Only)
---
name: coding-standards
description: Team coding standards. Auto-referenced for TypeScript.
user-invocable: false
---
## TypeScript Standards
- Functional components only (no class components)
- All props require interface definitions
- Error handling uses the Result type pattern
Hidden from the / menu. Claude references it automatically when writing TypeScript.
Pattern 2: Dangerous Operations (Manual-Only)
---
name: deploy
description: Execute production deployment
disable-model-invocation: true
allowed-tools: Bash(git push *), Bash(gh pr merge *)
---
## Pre-deployment Checks
!`git status`
!`npm test -- --ci 2>&1 | tail -5`
Claude will never auto-trigger this. Only explicit /deploy invocation works.
Pattern 3: Parallel Sub-Agent Workflow
---
name: full-review
description: Code, security, and performance review from three perspectives
context: fork
agent: general-purpose
---
Review from three perspectives in parallel:
1. **Code Quality**: Readability, reusability, SOLID principles
2. **Security**: OWASP Top 10, injection vulnerabilities, auth
3. **Performance**: N+1 queries, unnecessary computation, memory leaks
Skill Organization by Role
Keep simultaneously loaded skills to 8 or fewer per role to maintain Claude's recall accuracy:
| Role | Recommended Bundle |
|---|---|
| Frontend Dev | Coding standards + Component review + Accessibility check + Storybook generation |
| Backend Dev | API design + DB migration + Performance profiling + Security audit |
| Data Analyst | SQL generation + Dashboard report + Anomaly detection + ETL pipeline |
| Product Manager | PRD writing + User stories + Sprint planning + Release notes |
Security Considerations for Enterprise Adoption
Skills must be managed with the same rigor as software installations in enterprise environments (platform.claude.com).
High-risk review items:
- Code execution:
*.py,*.sh,*.jsscripts have full environment access - Network access: URLs, API endpoints, fetch, curl commands create data exfiltration vectors
- Hardcoded credentials: API keys and tokens exposed through Git history
- MCP server references: Can extend access beyond the intended skill scope
Anthropic recommends a 7-item risk rating framework and lifecycle management procedures. Enterprise teams should incorporate these into existing AI governance policies before deploying organization-wide skills.
Frequently Asked Questions
What is Claude Skills 2.0?
Claude Skills 2.0 is a programmable agent framework for Claude Code that enables isolated sub-agent execution, dynamic runtime data injection, granular tool control, and software-grade evaluation of AI agent capabilities. It replaces the prompt injection model of Skills 1.0 with a full agent execution platform.
How does context: fork work in Claude Skills?
When a skill sets context: fork in its YAML frontmatter, Claude launches an isolated sub-agent with no access to the main conversation history. The skill's SKILL.md content becomes the sub-agent's prompt. Upon completion, only the result returns to the main conversation, preserving context window integrity.
Can I use my existing Claude custom commands with Skills 2.0?
Yes. Skills 2.0 is fully backward compatible. Existing .claude/commands/ files work without modification. To access advanced features like sub-agent execution or dynamic context, simply add a YAML frontmatter block to the existing file.
What are the bundled skills in Claude Code?
Claude Code ships with five built-in skills: /batch for parallelized large-scale changes, /simplify for multi-agent code quality review, /loop for periodic task repetition, /debug for session log analysis, and /claude-api for language-specific API reference.
How should enterprise teams manage Claude Skills security?
Treat skills as software installations. Review all bundled scripts for environment access, network calls, and credential exposure. Use allowed-tools to enforce least-privilege access. Apply disable-model-invocation: true to any skill with destructive side effects. Follow Anthropic's 7-item risk rating framework for lifecycle management.
References
| Classification | Source | URL |
|---|---|---|
| Official Documentation | Extend Claude with skills - Claude Code Docs | code.claude.com/docs/en/skills |
| Official Blog | Introducing Agent Skills | claude.com/blog/skills |
| Official Blog | Improving skill-creator: Test, measure, and refine | claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills |
| API Documentation | Agent Skills Overview | platform.claude.com/docs/en/agents-and-tools/agent-skills/overview |
| API Documentation | Skills for enterprise | platform.claude.com/docs/en/agents-and-tools/agent-skills/enterprise |
| API Documentation | Skill authoring best practices | platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices |
| Official Blog | Equipping agents for the real world | claude.com/blog/equipping-agents-for-the-real-world-with-agent-skills |
| GitHub | anthropics/skills repository | github.com/anthropics/skills |
| Technical Analysis | Inside Claude Code Skills (Mikhail Shilkov) | mikhail.io/2025/10/claude-code-skills |
| Technical Analysis | Agent Skills 2.0: From Custom Instructions to Programmable Agents | medium.com/@richardhightower |
This analysis was prepared by the AboutCoreLab AI Content Team on March 16, 2026. Based on Anthropic official documentation and independent technical analysis sources.