What is Skills?
The biggest hidden tax in AI development isn’t just the API subscription — it’s “Context Inflation.” We’ve been over-engineering our prompts, paying a premium to feed models redundant information at every turn. The arrival of Agent Skills changes the math. By treating capabilities as a lightweight, open-format filesystem, we move away from static prompt engineering and toward dynamic context engineering. Instead of paying for a 32k token window full of “just in case” instructions, an agent can now “discover” the specific skill folder — complete with its own .md guides and .py scripts — only when required. It’s the difference between carrying an entire library and just picking the right book off the shelf.
In short skills are modular capabilities that extend Agent functionality . Each Skill packages instructions, metadata, and optional resources (scripts, templates) that LLM/Agent uses automatically when relevant.
Why to use Skills
Skills are reusable, filesystem-based resources that provide your agent domain-specific expertise: workflows, context, and best practices that transform general-purpose agents into specialists. Unlike prompts (conversation-level instructions for one-off tasks), Skills load on-demand and eliminate the need to repeatedly provide the same guidance across multiple conversations
When to Use Skills
The rule of thumb is simple: if you find yourself explaining the same thing to an Agent repeatedly, then you need to write a skill but keep keep SKILL.md under 500 lines.Below are some example:
- Code review standards your team follows
- Commit message formats you prefer
- Documentation format for report
- Brand guidelines for your organization
- Documentation templates for specific types of docs(pdf,ppt,docs)
- Debugging checklists for particular frameworks
How Agents Use Skills:
Agents use a three-tier loading system for skills that keeps context costs proportional to what the agent uses, not what it has installed.
Level 1: Metadata (always loaded , ~100 tokens per skill)
Content type: Instructions. The Skill’s YAML frontmatter (name + description) from each SKILL.md gets injected into the system prompt provides discovery information:
Agent loads this metadata at startup and includes it in the system prompt. This lightweight approach means you can install many Skills without context penalty.
Level 2: Instructions (loaded when triggered, under 5,000 tokens)
Content type: Instructions. The main body of SKILL.md contains procedural knowledge: workflows, best practices, and guidance
When you request something that matches a Skill’s description, Agents reads SKILL.md from the filesystem via bash. Only then does skills Instruction enter the context window.
Level 3: Resources and code (loaded as needed)
Content types: Instructions, code, and resources. Skills can bundle additional materials like Reference files (references/style-guide.md, references/api-schema.md) and scripts (scripts/validate.py) load on-demand during execution. Scripts are executed via bash, and only the output enters context, not the script code itself.
Get Neelam Pawar’s stories in your inbox
Join Medium for free to get updates from this writer.
Remember me for faster sign in
Sample example of Skills:
Skills vs MCP
“Internal Wisdom” (Skills) from “External Reach” (MCP). MCP provides access, Skills provide expertise.
Press enter or click to view image in full size
Skills teach your agent what to do with that data.
Notice the prompt: “Compute metric X using columns A and B of this table.” This isn’t just an observation; it’s a specific recipe. When an agent accesses a ‘Skill’ from its filesystem, it’s not looking up external data. It is retrieving a pre-compiled set of instructions or scripts — the exact logic — required to process information it already “knows” or has just received. This is context engineering at its most dynamic.
Model Context Protocol (MCP) is the universal language for getting agents out of their silos.
While a Skill tells the agent how to process a table, MCP tells the agent where that table actually lives. MCP connects your agent to external systems and data.
Skills vs Tools
Tools -Essential Gears: We’ve been treating our agents like survivalists — strapping every possible tool (Bash, WebSearch, Read/Write) to their belt “just in case” they need them.
Think of Tools as the agent’s basic survival kit. They provide the essential capabilities — like WebFetch or Bash — that let the agent interact with the world. They are the “what.”
Tools live in the context window. Every time you send a prompt, those tool definitions (names, descriptions, parameters) are taking up precious real estate. You’re paying for them on every single turn.
Skills-Specialized Mastery
Skills are “how-to.” They extend an agent’s capabilities with specialized knowledge. A tool might let an agent read a PDF; a Skill gives it the specific script and instructions to extract form-field information from a medical PDF accurately.
Skills are loaded dynamically. They stay tucked away in the filesystem until the agent actually needs them.
Skills vs Sub-Agents
Think of a Subagent as a specialized contractor you hire to get a job done. They have their own isolated context and specific tool permissions. You delegate a task to them — like a “Code Reviewer” subagent — they work independently (sometimes in parallel), and they return the results to the main Agent. But both agents and Subagents can use Skills to enhance their knowledge with specialized knowledge.
Skills, however, aren’t workers; they are the playbooks. While a subagent does the work, a Skill informs how that work should be done. It provides expert knowledge — like language or framework-specific best practices — directly to whoever needs it.
In short: Use Subagents when you need to divide and conquer the labor. Use Skills to ensure that every worker on the team is the smartest version of themselves.
Summary
Popular Github Repo for Skills:
The Agent Skills Directory Discover and install skills for AI agents.
- https://github.com/obra/superpowers
- https://github.com/anthropics/skills
- https://github.com/google/adk-samples/tree/main/python/agents/agent-skills-tutorial
---