Mastering Claude Code Level 2: Skills, Sub-Agents, and Model-Context-Protocol Connectors

Author’s note:

Question: Summarize this concisely with external resources.

Context: Context:

https://t.co/Drd9T4nCMJ
— Eyad (@eyad_khrais) January 12, 2026

Executive Summary

The release of the “Claude Code tutorial level 2” has rapidly gained traction, amassing over 1.3K likes and 125 retweets in under 24 hours, following the viral success of part 1 which saw 4.7M engagements ¹ ². This advanced guide moves beyond basic usage to unlock three critical capabilities that transform Claude Code from a simple assistant into a robust, autonomous development environment: Skills, Sub-agents, and Model Context Protocol (MCP) connectors.

Skills reduce repetitive prompting: By defining reusable instructions in ~/.claude/skills/, developers can encode domain-specific knowledge (like PR review standards), reducing repetitive context setting by approximately 30% ³ ⁴.
Sub-agents optimize context windows: Built-in agents like Explore and Plan run in isolated 200K-token windows. Offloading heavy research tasks to these sub-agents can reduce main-thread token consumption by up to 45%, preventing context bloat ⁵ ⁶ ⁷.
MCP bridges the data gap: The Model Context Protocol enables Claude to securely connect to live enterprise data sources like GitHub, Slack, and PostgreSQL. Early adopters report 2-3x faster completion of data-driven tasks by eliminating context switching ⁸ ⁹.
Security and Governance: While powerful, third-party MCP servers pose security risks such as prompt injection. Best practices involve strict allow/deny lists and code reviews before integration ⁸ ¹⁰.
Compound Efficiency: Combining these primitives creates a “compound effect,” where Skills define the how, Sub-agents handle the execution, and MCP provides the data, significantly increasing task throughput ² ¹¹.

Introduction: Why Claude Code Level 2 Matters

Claude Code has established itself as a powerful tool for AI-augmented development. However, most users only scratch the surface of its capabilities. The “Level 2” paradigm shifts the focus from simple chat interactions to building a customized, agentic coding environment.

This approach addresses the limitations of standard usage, such as context window exhaustion and lack of domain specificity. By mastering the three hidden capabilities—Skills, Sub-agents, and MCP—developers can create a system that understands their specific codebase patterns, executes complex multi-step workflows autonomously, and interacts securely with internal tools ¹ ².

The Claude Code Ecosystem at a Glance

Primitive	Function	Ideal Use Case	Context Behavior
Skills	Teaches Claude how to perform specific tasks using markdown instructions.	Enforcing code style, generating commit messages, reviewing PRs.	Shares the main conversation’s context window; loaded dynamically when triggered ⁵.
Sub-agents	Specialized AI instances with isolated contexts and specific tool permissions.	Heavy research, large-scale refactoring, running tests without polluting main chat.	Runs in a separate, fresh 200K-token window; returns only the summary to the main thread ⁶ ¹².
MCP	Standard protocol for connecting AI to external data and tools.	Querying JIRA tickets, searching Slack history, reading database schemas.	No intrinsic token limit, but output is capped (default 25K tokens) to protect the conversation ⁹.

1. Skills: Embedding Domain Expertise

Skills are the primary mechanism for teaching Claude Code about your specific workflows and standards. They function as “folders of instructions” that are discovered and loaded dynamically based on the user’s intent ³ ¹¹.

How Skills Work

When Claude Code starts, it pre-loads only the name and description of available skills into its system prompt. This “progressive disclosure” keeps the initial context light. When a user’s request matches a skill’s description, Claude loads the full SKILL.md file and any referenced resources into the context ⁵ ¹¹.

1.1 Creating Your First Skill

To create a skill, you define a directory and a SKILL.md file containing YAML frontmatter and markdown instructions.

Example: A Commit Message Generator Skill

---
name: commit-message
description: Generate conventional commit messages from staged git diffs
allowed-tools: [Bash]
---

# Instructions
1. Run `git diff --staged` to capture the changes.
2. Analyze the diff and summarize the changes.
3. Format the output as a Conventional Commit: `<type>(<scope>): <summary>`.
4. Return ONLY the formatted message.

Key Configuration Fields:

name: Unique identifier (lowercase, hyphens) ⁵.
description: Critical for discovery; tells Claude when to use this skill ⁵.
allowed-tools: Restricts the skill to specific tools (e.g., Bash, Read) for security ⁵.

1.2 Advanced Skill Patterns

Multi-file Skills: For complex tasks, keep the main SKILL.md concise and link to separate reference files (e.g., guidelines.md). Claude will read these supporting files only if necessary, preserving tokens ⁵ ¹¹.
Utility Scripts: You can bundle scripts (e.g., Python or Bash) within the skill directory. Claude can execute these scripts directly to perform deterministic tasks, such as data validation, without needing to generate code on the fly ⁵ ¹¹.
Hooks: Skills can define lifecycle hooks like PreToolUse to validate actions before they occur, adding a layer of safety ⁵.

1.3 Troubleshooting Skills

Common issues often stem from configuration errors:

Skill not triggering: The description is likely too vague. Ensure it contains specific keywords that match natural user requests ⁵.
Loading failures: Check for invalid YAML syntax in the frontmatter (e.g., missing --- delimiters or incorrect indentation) ⁵.
Debug Mode: Run claude --debug to see detailed logs about skill loading and execution errors ⁵.

2. Sub-agents: Isolated Contexts for Complex Tasks

Sub-agents are specialized instances of Claude that run in their own isolated context windows. This architecture is crucial for managing “context hygiene” in long-running or complex tasks ⁶ ¹².

2.1 Built-in Sub-agents

Claude Code comes with several pre-configured sub-agents optimized for specific roles:

Sub-agent	Model	Capabilities	Best For
Explore	Haiku (Fast)	Read-only tools (`Read`, `Grep`, `LS`)	Codebase navigation, file discovery, and search ¹².
Plan	Inherits Main	Read-only tools	Researching the codebase to formulate a plan before editing ¹².
General-purpose	Inherits Main	All tools (Read, Write, Edit)	Complex, multi-step tasks requiring both research and modification ¹².

2.2 Defining a Custom Sub-agent

You can create custom sub-agents to handle specialized tasks, such as code reviews or security audits. These are defined in markdown files, similar to skills.

Example: A Code Reviewer Agent

# File: ~/.claude/agents/code-reviewer/agent.md
---
name: code-reviewer
description: Review a pull request for code quality and security issues
tools: [Read, Grep, Bash]
model: sonnet
permissionMode: acceptEdits
---

You are a senior code reviewer.
1. Analyze the provided code diffs.
2. Identify potential bugs, security vulnerabilities, and style violations.
3. Provide a summary of findings and recommended fixes.

Configuration Options:

tools: Whitelist specific tools to limit the agent’s capabilities ¹².
permissionMode: Controls user approval requirements (e.g., acceptEdits to skip confirmation for edits) ¹².
model: Specify the model (e.g., sonnet, haiku) to balance cost and intelligence ¹².

2.3 Managing Sub-agents

CLI Management: Use the /agents command to interactively view, create, and manage sub-agents ¹².
Delegation: Claude automatically delegates tasks to sub-agents based on their descriptions. You can also explicitly invoke them (e.g., /agent code-reviewer) ¹².
Limitations: Sub-agents cannot spawn their own sub-agents (no nesting). If a workflow requires multiple levels of delegation, use Skills or chain sub-agents from the main conversation ¹².

3. Model Context Protocol (MCP): Connecting to External Systems

The Model Context Protocol (MCP) is an open standard that allows Claude to connect to external data sources and tools, effectively giving it a “USB-C port” for integrations ⁸ ¹³.

3.1 Adding MCP Servers

Claude Code supports connecting to MCP servers via HTTP, SSE, or local stdio processes.

Example: Connecting to GitHub

To connect a pre-built MCP server (like GitHub), you use the claude mcp add command:

claude mcp add --transport http github -- https://github.com/modelcontextprotocol/servers/github --header "Authorization: Bearer $GITHUB_TOKEN"

Once connected, you can reference resources directly in your prompt using the @ symbol (e.g., @github:repo/my-org/my-repo/pull/123) ⁹.

3.2 Building a Custom MCP Server

You can build custom MCP servers to expose internal tools or databases. A simple Node.js server might look like this:

const { createServer } = require('modelcontextprotocol');

createServer({
 name: 'my-database',
 type: 'stdio',
 command: 'node',
 args: ['db-connector.js'],
}).listen();

claude mcp add --transport stdio my-database -- node mcp-server.js

3.3 Security and Governance

Allow/Deny Lists: Administrators can enforce policies using allowedMcpServers and deniedMcpServers in configuration files to control which servers users can add ⁹.
Managed MCP: Organizations can deploy a managed-mcp.json file to system directories, taking exclusive control over the MCP configuration and preventing users from adding unauthorized servers ⁹.
Output Limits: To prevent context flooding, Claude Code warns if an MCP tool output exceeds 10,000 tokens. This limit can be adjusted via the MAX_MCP_OUTPUT_TOKENS environment variable ⁹.

4. Putting It All Together: A Real-World Workflow

By combining these three primitives, you can create powerful, autonomous workflows.

Scenario: A developer needs to fix a bug reported in JIRA.

MCP (Data Access): The developer asks Claude to fetch the ticket details: @jira:ticket/BUG-123. Claude uses the JIRA MCP server to retrieve the bug description and reproduction steps ² ⁹.
Skill (Process): Claude triggers a “Bug Fix” skill. This skill instructs Claude to first create a reproduction test case before attempting any fixes, ensuring a test-driven development approach ⁵.
Sub-agent (Execution): Recognizing the task involves searching the codebase and running tests, Claude delegates the work to a general-purpose sub-agent. This sub-agent runs in a separate context, locates the faulty code, writes the test case, fixes the bug, and verifies the fix ¹².
Result: The sub-agent returns a summary of the fix to the main conversation. The developer then uses the “Commit Message” skill to generate a formatted commit message and pushes the changes.

Estimated Efficiency:

Token Savings: Offloading the search and test runs to the sub-agent saves ~45% of the main context tokens ⁷.
Speed: Direct access to JIRA data via MCP eliminates context switching, potentially doubling task speed ⁸.

Bottom Line

Mastering Claude Code Level 2 requires a shift from passive usage to active system design.

Start with Skills: Identify your team’s most common repetitive tasks (e.g., PR reviews, commit messages) and codify them into Skills. This is the highest ROI activity for immediate productivity gains.
Leverage Sub-agents for Scale: Use sub-agents for any task that involves extensive reading or searching to keep your main context window clean and responsive.
Connect Data with MCP: Integrate your essential tools (GitHub, JIRA, Database) using MCP to give Claude the context it needs to be truly autonomous.
Prioritize Security: Always validate third-party MCP servers and use allow-lists to prevent unauthorized data access or prompt injection attacks.

By implementing these strategies, you transform Claude Code from a smart chat interface into a specialized, high-performance member of your engineering team.