夜雨聆风Agent skills are one of the most powerful ways to extend how AI works in the workflow, skills operate behind the scenes to simplify complex workflows.
• Agent skills are structured bundles that include instructions, scripts, and supporting resources. • Agent skills package everything needed to perform a task into a reusable system. • Agents automatically load relevant skills to execute specialized workflows.
Agent skills designed as an open standard, meaning they can work across multiple AI environments, not just VS Code/Claude/Codex.
Agents are increasingly capable, but often don’t have the context they need to do real work reliably, skills solve this by packaging procedural knowledge and company-, team-, and user-specific context into portable, version-controlled folders that agents load on demand.
• Domain expertise: Capture specialized knowledge — from legal review processes to data analysis pipelines to presentation formatting — as reusable instructions and resources. • Repeatable workflows: Turn multi-step tasks into consistent, auditable procedures. • Cross-product reuse: Build a skill once and use it across any skills-compatible agent.
Skill structure
Agent skills are a standardized way to give AI agents new capabilities and expertise.
At a high level, a skill typically includes:
• name: A human-friendly name for your skill (64 characters maximum).• description: a clear description of what the skill does and when to use it.• rules for how it should behave • references to related workflows or dependencies
Agent skills live in the Agent Customizations view alongside prompts and instructions, we can find that there are built-in skills, extension-provided skills, and any custom skills you create, all in one centralized place.
We can say that when we run a slash command like /init, we’re not just issuing a prompt — we’re activating a skill, and skill handles the entire workflow for us.
---name: `init`description: Generate or update chat customization files for AI coding agentsargument-hint: Optionally specify a focus area or pattern to document for agentsdisable-model-invocation: `true`---The purpose of this command is to create or update chat customization files- the agent instructions file (`.github/copilot-instructions.md` or `AGENTS.md`) to help AI coding agents understand the codebase and be immediately productive- skills and custom agents to automate common tasks or enforce conventions in the codebaseThe user can optionally call this command with an argument. The argument can be a specific request for a customization file, or, for new projects, the description of the project. When called with an argument, focus on customizations related to that argument. Only create or modify chat customization files. Never start working on a task in the argument.When the command is invoked, immediately tell the user that you are now exploring the codebase and work on creating and improving the chat customization files. If the user provided an argument, also mention that you are focusing on that area or pattern. Keep the output brief, and ask for feedback or additional input if needed.Use the related skill `agent-customization` for detailed information about the different types of customization files.Explore the codebase to get a good understanding of the project and its conventions, and then create or update the relevant chat customization files to help AI coding agents be productive in this codebase.When complete, print a table of the added or modified chat customization files, along with a short explanation why this file is useful to the AI coding agents.## Workflow1.**Discover existing conventions** Search: `**/{.github/copilot-instructions.md,AGENT.md,AGENTS.md,CLAUDE.md,.cursorrules,.windsurfrules,.clinerules,.cursor/rules/**,.windsurf/rules/**,.clinerules/**,README.md}`2.**Explore the codebase** via subagent, 1-3 in parallel if needed Find essential knowledge that helps an AI agent be immediately productive: - Build/test commands (agents run these automatically) - Architecture decisions and component boundaries - Project-specific conventions that differ from common practices - Potential pitfalls or common development environment issues - Key files/directories that exemplify patterns Also inventory existing documentation (`docs/**/*.md`, `CONTRIBUTING.md`, `ARCHITECTURE.md`, etc.) to identify topics that should be linked, not duplicated.3.**Generate or merge** - New file: Prefer AGENTS.md over `.github/copilot-instructions.md`. If the user already has one of these files, update it instead of creating a new one. - Existing file: Preserve valuable content, update outdated sections, remove duplication - Follow the guidelines in the `agent-customization` skill: 1. **Link, don't embed** principle. Do not copy existing documentation that exists in the workspace, link to them with a Markdown link instead. 2. **Minimal by default**: Only what's relevant and cannot be easily discovered by an agent should be included. Link to other documentation for details. 3. **Concise and actionable**: Every line should guide behavior4.**Iterate** - Ask for feedback on unclear or incomplete sections - If the workspace is complex, suggest creating separate instructions files or skills for specific areas (e.g., frontend, backend, tests)Once finalized, propose related agent-customizations to create next (`/create-(agent|hook|instruction|prompt|skill) …`), explaining the customization and how it would be used in practice.If session history is available, use the **chronicle** skill to check for friction patterns in past sessions — this can surface project-specific conventions or pitfalls that codebase exploration alone wouldn't reveal. Mention `/chronicle improve` to the user as a way to iteratively refine instructions over time.Instead of manually thinking through each step, one skill:
• interprets our request • asks clarifying questions when needed • generates the final output in the correct format
Skill package
Skills are folders of instructions, scripts, and resources that agent loads dynamically to improve performance on specialized tasks.
• Every skill consists of a directory containing at minimum a skill.mdfile, which is the core of the skill.• skill.mdmust start with a YAML frontmatter to hold name and description fields, which are required metadata.• skill.mdcan also contain additional metadata, instructions for agent or reference files, executable scripts, or tools.
We use skills to teach agent how to complete specific tasks in a repeatable way, whether that's creating documents with our company's brand guidelines, analyzing data using our organization's specific workflows, or automating personal tasks.
Skills improve agent’s consistency, speed, and performance on many tasks. Skills work through progressive disclosure—agent determines which skills are relevant and loads the information it needs to complete that task, helping to prevent context window overload.
When we ask agent to complete a task, it reviews available skills, loads relevant ones, and applies their instructions.
The Agent Skills specification is published as an open standard at agentskills.io. This means skills we create aren't locked to Claude/Codex/Copilot or other agents—the same skill format works across AI platforms and tools that adopt the standard.
A reference Python SDK is also available for developers implementing skills support in their own platforms.
Skill vs. projects
Projects provide static background knowledge that's always loaded when we start chats within them.
Skills provide specialized procedures that activate dynamically when needed and work everywhere across agent.
Skill vs. MCP
MCP connects agent to external services and data sources. Skills provide procedural knowledge—instructions for how to complete specific tasks or workflows.
We can use both together: MCP connections give agent access to tools, while skills teach agent how to use those tools effectively.
Skill vs. custom instructions
Custom instructions apply broadly to all the conversations.
Skills are task-specific and only load when relevant, making them better for specialized workflows.
Skill stages
Agents load skills through progressive disclosure, in three stages:
1. Discovery: At startup, agents load only the name and description of each available skill, just enough to know when it might be relevant. 2. Activation: When a task matches a skill’s description, the agent reads the full SKILL.md instructions into context. 3. Execution: The agent follows the instructions, optionally executing bundled code or loading referenced files as needed.
Full instructions load only when a task calls for them, so agents can keep many skills on hand with only a small context footprint.
