What Is Agent Skill in AI?

An agent skill is a reusable package of instructions, context, and optional files that teaches an AI agent how to perform a specific repeatable job. A prompt asks the agent to do something once. A skill gives the agent a durable operating procedure it can discover, load, follow, verify, and improve over time.

That direct definition matters because "skill" is often used loosely. OpenAI describes Codex skills as packages of instructions, resources, and optional scripts in its Codex Agent Skills documentation. Anthropic's Agent Skills overview uses the same core idea for Claude: reusable filesystem-based resources for domain-specific workflows, context, and best practices.

The practical test is simple: if the agent needs the same judgment, source order, stop conditions, and proof of completion more than once, the work may deserve a skill. If the user only needs one answer, a prompt is usually enough.

An agent skill is a maintained operating procedure for an AI agent.

It usually answers seven questions:

That is why Agent Skills vs Prompts is the first boundary to get right. A prompt can be excellent and still be disposable. A skill is meant to survive multiple runs, multiple users, and multiple revisions.

A useful agent skill has three properties: it is discoverable, procedural, and packaged. Discoverable means a short name and description help the agent know when the skill is relevant; Anthropic's skill authoring best practices put real weight on naming because it affects selection. Procedural means the skill changes how the agent works: what to inspect first, what to run, when to stop, and how to prove completion. Packaged means the workflow can include more than a single instruction blob. The open Agent Skills overview, VS Code's Agent Skills documentation, and GitHub's Copilot CLI skill docs all describe a folder-based pattern.

Different platforms have different installation paths, but strong skills tend to contain the same parts.

The file list should reflect the job. A launch-email skill may need brand examples and a short offer template. A failing-CI skill may need CLI commands, log-reading rules, reusable scripts, and severity definitions.

How to Create an Agent Skill goes deeper on authoring, but the structural rule is the same: keep the main file focused on the workflow contract, and move long background material into references that the agent loads only when needed.

Progressive disclosure is the design pattern that keeps skills useful instead of turning them into giant always-on prompts. OpenAI's Codex docs say Codex starts with each skill's name, description, and path, then loads the full SKILL.md only when the skill is selected. Anthropic's engineering post, Equipping agents for the real world with Agent Skills, describes the same pattern: metadata first, core instructions when triggered, deeper resources only as needed.

Context is finite. Loading every team policy, API guide, product checklist, and formatting rule into every conversation makes the agent slower and less focused. A skill lets the agent start with a small routing hint and pull in the full procedure only for the task that needs it.

Not every task needs the same depth. A support-triage skill might include a short first-pass procedure in SKILL.md, a references/severity-policy.md file for edge cases, and a scripts/summarize-ticket-export.ts script for large exports. Most tickets may only need the first file. Escalations can load the policy. Large batches can run the script.

Anthropic's overview notes that bundled files do not consume context until accessed. That lets a skill include examples, templates, checklists, and domain docs without forcing every run to carry all of them. The tradeoff is routing: community discussions around Codex skills often focus on direct invocation and automatic selection because a technically correct skill is not useful if the agent never loads it.

A prompt is the right tool for one-off intent. A skill is the right tool for repeatable procedure.

Prompt:

Skill:

1. Read the README, quickstart, package files, and changed examples.
2. Run install and smoke-test commands if the repo provides them.
3. Compare SDK usage against current official docs.
4. Check whether setup requires hidden credentials, paid resources, or unpublished services.
5. Report blockers with file paths, commands, and reproduction notes.
6. Return publish, publish with caveats, or do not publish.

The prompt asks for a result. The skill defines a repeatable review method. That is why a skill can be tested, versioned, shared, and rated after real runs. How Agent Skill Works goes deeper on the loading and execution path.

Rules and custom instructions are usually broad and persistent. Skills are narrower and task-triggered.

Cursor's official Rules documentation describes persistent instructions at user, team, and project levels, including AGENTS.md. That is the right place for conventions that should affect nearly every task: package manager choice, generated-file rules, test requirements, or design-system constraints.

A skill is different. It should not be active for every task. "Use our tone of voice" can be a rule. "Turn customer interview notes into a product opportunity memo with quotes, confidence levels, and follow-up questions" should be a skill. "Migrate a Next.js route from Pages Router to App Router with tests and rollout notes" should be a skill.

The failure mode is stuffing everything into persistent instructions. Agent Skill vs Rules covers that line in more detail, but the short version is: rules govern the workspace; skills perform the job.

A tool gives the agent an action. A skill tells the agent how to use actions toward an outcome.

The Model Context Protocol tools specification describes tools as named capabilities with schemas that let models interact with external systems. A browser tool can click. A shell tool can run tests. A CRM tool can fetch a customer record. None of those tools decides what a good support escalation, compliance review, or release check requires.

A skill can coordinate those tools:

• Use the CRM tool to fetch the last three enterprise tickets.
• Use the docs search tool to check whether the reported feature is documented.
• Use the browser to reproduce the issue in a staging account.
• Use the shell to run a focused regression test.
• Return a severity recommendation with evidence and uncertainty.

The tool is callable capability. The skill is procedural judgment. The more actions an agent can take, the more important it becomes to define source order, permissions, stopping points, and verification.

An MCP server is an integration layer. An agent skill is an operating procedure.

The official Model Context Protocol introduction frames MCP as a standard way for AI applications to connect to data sources, tools, and workflows. Anthropic's original MCP announcement describes the same architecture.

That makes MCP and skills complementary. An MCP server might expose:

• search_docs(query)
• get_ticket(ticket_id)
• create_linear_issue(summary, body, labels)
• run_deploy_check(environment)

A support-escalation skill can define when to call those tools, which source wins when ticket data conflicts with docs, what customer details must be excluded from the final report, and when a human must approve issue creation.

Agent Skill vs MCP covers the architecture tradeoffs. The key distinction is enough here: MCP connects the agent to systems; a skill tells the agent how to perform a repeatable job using those systems.

A workflow is the larger business process. A skill is the agent-performed procedure inside that process. In incident response, the full workflow may include alerting, ownership assignment, rollback approval, postmortem scheduling, and executive reporting. A skill might handle one part: triage a production incident from logs and recent deploys, then produce a severity assessment with evidence.

This distinction prevents overbuilding. Deterministic routing belongs in automation. Policy approvals belong with humans or governance systems. A skill is most useful where the work requires language, judgment, source synthesis, and evidence, but still repeats often enough to standardize.

A subagent is usually a delegated worker with its own context, tools, or specialty. A skill is the procedure that can guide an agent or subagent. A lead coding agent may delegate authentication review to a security-focused subagent; that subagent might use a security-reviewing skill for source order, threat categories, severity labels, and final report format. The subagent is the actor. The skill is the method.

Agent skills are especially useful where teams already have informal runbooks trapped in people's heads.

Engineering teams use skills for PR review, failing CI diagnosis, migration playbooks, release QA, dependency upgrades, security review, and repo onboarding. GitHub's Copilot CLI docs describe skills as a way to modify Copilot's behavior for particular tasks, while VS Code positions skills as reusable folders Copilot can load for specialized work.

Product, research, and operations teams use skills for customer interview synthesis, competitive research briefs, sales-call follow-up, launch checklists, incident summaries, policy interpretation, and repetitive document workflows. A research skill can require primary sources first and community sources only as anecdotal evidence. A sales follow-up skill can require the transcript, CRM fields, promised next steps, and a draft that separates commitments from speculation.

Skillfully's audience is skill authors: experts and teams who want repeatable workflows to be used, measured, and improved. Once a skill is published, the interesting question is whether agents use it for the right jobs, where they get stuck, and what feedback should change the next version.

A weak skill says:

A stronger documentation skill says:

1. Read the changed API surface, existing docs page, and release note draft.
2. Identify whether the change is new behavior, changed behavior, deprecation, or bug fix.
3. Update the smallest relevant doc page.
4. Add one runnable example if the feature changes developer behavior.
5. Preserve existing terminology unless the docs glossary says otherwise.
6. Run the docs link checker or explain why it could not run.
7. Return changed files, unresolved questions, and verification output.

The stronger versions are not longer for the sake of being longer. They encode decisions the author would otherwise repeat every time.

Use a normal prompt when the request is rare, low-risk, and easy to specify in one message. "Summarize this article for me" does not need a skill unless the summary format, source checks, audience, and evidence requirements repeat.

Use a rule when the instruction should apply broadly. Code style, package manager choice, documentation update requirements, and repository safety rules usually belong in project instructions. Turning every convention into a skill makes routing harder.

Use a script or test when the work is deterministic. If the job is "sort this JSON file," "generate this index," or "validate these frontmatter fields," write code. The skill can tell the agent to run the script, but the script should own the mechanical check.

Use an MCP server or platform integration when the missing piece is access. If the agent cannot read your issue tracker or call your deployment system, a skill will not create that capability. Give the agent the tool first, then write the skill that governs its use.

Before turning a workflow into a skill, ask:

• Does the job happen repeatedly?
• Are there trusted sources the agent should inspect before acting?
• Are there tools or scripts the agent should use in a defined order?
• Are there permission, privacy, or production-safety stop rules?
• Is the output shape stable enough to specify?
• Can another person inspect the evidence and decide whether the run succeeded?
• Will feedback from real runs improve the next version?

If most answers are yes, create the skill. If only one or two are yes, keep the prompt or write a smaller rule. A skill is a unit of reusable expertise, not a place to store every good idea.

The durable value of an agent skill is not the markdown file. It is the transfer of working knowledge into a form an agent can use at the right moment. The best skills say what to inspect, what to ignore, what to run, what evidence matters, what can go wrong, and how to report the result.

For skill authors, that makes skills a practical publishing unit. A skill can capture an expert's method, a team's internal runbook, or a product workflow that should be repeated with less drift. For teams operating agents, skills create a feedback loop: if an agent selects the wrong skill, skips a source, overuses a tool, or returns weak evidence, the author has a concrete artifact to fix.

That is the clearest definition: an agent skill is reusable procedural knowledge, packaged so an AI agent can load it only when relevant and use it to complete a specific job with evidence.