
Agent Customization
OfficialFreeStreamline your VS Code agent customization process.
Free · Opens the source repo
What Agent Customization does
The Agent Customization skill is designed for developers and designers who need to create, update, and manage customization files for VS Code agents. It supports a variety of file types, including .instructions.md, .prompt.md, and .agent.md, allowing users to tailor agent behavior to their specific needs. This skill is particularly useful for saving coding preferences, troubleshooting issues with agent instructions, and defining tool restrictions. It also aids in creating specialized workflows and packaging domain knowledge effectively.
This skill operates by allowing users to interact with their file system to read and write customization files directly. It includes a decision flow to help users determine which type of customization file they need based on their requirements. By following a structured creation process, users can ensure that their customizations are correctly implemented and validated. The skill also provides references for templates and advanced options, making it easier to adhere to best practices.
The Agent Customization skill is ideal for those who frequently work with VS Code agents and need a systematic approach to managing their configurations. Whether you are part of a development team or an individual developer, this skill can enhance your workflow by providing clear guidelines and tools for customization. It is particularly beneficial when working on collaborative projects where consistent agent behavior is crucial.
However, this skill should not be used for general coding questions or runtime debugging, as it is specifically tailored for agent customization tasks. For quick fixes or single operations, users may prefer to edit files directly without invoking the skill. Overall, the Agent Customization skill is an essential tool for anyone looking to optimize their VS Code agent configurations efficiently.
When to use it
Use this skill when you need to create or modify VS Code agent customization files to improve agent behavior or troubleshoot issues.
When not to use it
Avoid this skill for general coding inquiries or when dealing with runtime debugging, as it is focused solely on agent customization tasks.
What you can build with it
Creating Agent Instructions
Use this skill to create agent instructions that apply universally across your project, ensuring consistent behavior.
Troubleshooting Agent Issues
When your agents are not responding as expected, leverage this skill to review and fix customization files.
Defining Custom Workflows
Utilize this skill to set up specialized workflows or custom agent modes tailored to your specific project needs.
How to install Agent Customization
View source1. Install with the skills CLI
npx skills add microsoft/vscode/agent-customization --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by microsoftAgent Customization
Decision Flow
| Primitive | When to Use |
|---|---|
| agent instructions | Always-on, applies everywhere in the project |
| File Instructions | Explicit via applyTo patterns, or on-demand via description |
| MCP | Integrates external systems, APIs, or data |
| Hooks | Deterministic shell commands at agent lifecycle points (block tools, auto-format, inject context) |
| Custom Agents | Subagents for context isolation, or multi-stage workflows with tool restrictions |
| Prompts | Single focused task with parameterized inputs |
| Skills | On-demand workflow with bundled assets (scripts/templates) |
Quick Reference
Consult the reference docs for templates, domain examples, advanced frontmatter options, asset organization, anti-patterns, and creation checklists. If the references are not enough, load the official documentation links for each primitive.
| Type | File | Location | Reference |
|---|---|---|---|
| agent instructions | copilot-instructions.md, AGENTS.md | .github/ or root | Link |
| File Instructions | *.instructions.md | .github/instructions/ | Link |
| Prompts | *.prompt.md | .github/prompts/ | Link |
| Hooks | *.json | .github/hooks/ | Link |
| Custom Agents | *.agent.md | .github/agents/ | Link |
| Skills | SKILL.md | .github/skills/<name>/, .agents/skills/<name>/, .claude/skills/<name>/ | Link |
User-level: {{VSCODE_USER_PROMPTS_FOLDER}}/ (*.prompt.md, *.instructions.md, *.agent.md; not skills)
Customizations roam with user's settings sync
Creation Process
If you need to explore or validate patterns in the codebase, use a read-only subagent. If the ask-questions tool is available, use it to interview the user and clarify requirements.
Follow these steps when creating any customization file.
1. Determine Scope
Ask the user where they want the customization:
- Workspace: For project-specific, team-shared customizations →
.github/folder - User profile: For personal, cross-workspace customizations →
{{VSCODE_USER_PROMPTS_FOLDER}}/
2. Choose the Right Primitive
Use the Decision Flow above to select the appropriate file type based on the user's need.
3. Create the File
Create the file directly at the appropriate path:
- Use the location tables in each reference file
- Include required frontmatter as needed
- Add the body content following the templates
4. Validate
After creating:
- Confirm the file is in the correct location
- Verify frontmatter syntax (YAML between
---markers) - Check that
descriptionis present and meaningful
Edge Cases
Instructions vs Skill? Does this apply to most work, or specific tasks? Most → Instructions. Specific → Skill.
Skill vs Prompt? Both appear as slash commands in chat (type /). Multi-step workflow with bundled assets → Skill. Single focused task with inputs → Prompt.
Skill vs Custom Agent? Same capabilities for all steps → Skill. Need context isolation (subagent returns single output) or different tool restrictions per stage → Custom Agent.
Hooks vs Instructions? Instructions guide agent behavior (non-deterministic). Hooks enforce behavior via shell commands at lifecycle events like PreToolUse or PostToolUse — they can block operations, require approval, or run formatters deterministically. Hooks can be defined in standalone .json files (see hooks reference) or inline in custom agent frontmatter via the hooks attribute (see agents reference).
Common Pitfalls
Description is the discovery surface. The description field is how the agent decides whether to load a skill, instruction, or agent. If trigger phrases aren't IN the description, the agent won't find it. Use the "Use when..." pattern with specific keywords.
YAML frontmatter silent failures. Unescaped colons in values, tabs instead of spaces, name that doesn't match folder name — all cause silent failures with no error message. Always quote descriptions that contain colons: description: "Use when: doing X".
applyTo: "**" burns context. This means "always included for every file request" — it loads the instruction into the context window on every interaction, even when irrelevant. Use specific globs (**/*.py, src/api/**) unless the instruction truly applies to all files.
Frequently asked questions about Agent Customization
Similar skills
Turborepo
Optimized build system for JavaScript/TypeScript monorepos.
Azure Pipelines Validation
Streamline your Azure DevOps pipeline changes locally.
Azure Developer CLI
Streamline your Azure project workflows with best practices.
Azure Container Registry CLI
Manage Azure Container Registry resources with ease.
Aspire
Build and orchestrate polyglot distributed applications seamlessly.
Vercel CLI
Manage and deploy Vercel projects from the command line.
