Copilot Customization Selector

Customization Selector

This skill helps you decide which GitHub Copilot customization option to use for your specific needs.

When to use this skill

• User asks "what type of customization should I create?"
• User wants to understand differences between instructions, prompts, agents, and skills
• User needs to choose the right approach for a new customization
• User asks "should I use a prompt or an instruction file?"

Quick Decision Flowchart

What do you want to achieve?
│
├─► Define coding standards/rules that apply automatically?
│   └─► Use CUSTOM INSTRUCTIONS (.instructions.md)
│
├─► Create a reusable task template (e.g., "generate tests")?
│   └─► Use PROMPT FILES (.prompt.md)
│
├─► Create a specialized AI persona with specific tools?
│   └─► Use CUSTOM AGENTS (.agent.md)
│
├─► Build portable capabilities with scripts/resources?
│   └─► Use AGENT SKILLS (SKILL.md)
│
└─► Connect external services or APIs?
    └─► Use MCP SERVERS (mcp.json)

Decision Matrix

Detailed Guidance

Use Custom Instructions when

Perfect for:

• Enforcing coding standards across all requests
• Setting language/framework conventions (e.g., "always use TypeScript strict mode")
• Defining commit message or PR description guidelines
• Applying rules to specific file types via applyTo glob patterns
• Sharing team coding practices in version control

File types:

Example use cases:

• "Always use functional React components"
• "Follow PEP 8 for Python files"
• "Include JSDoc comments for all public functions"
• "Use conventional commits format"

Use Prompt Files when

Perfect for:

• Creating reusable workflows (e.g., /create-react-form, /security-review)
• Scaffolding components, API routes, or modules
• Generating tests with consistent patterns
• Running the same task repeatedly with variations
• Need to specify tools and agent for a specific task

Key features:

• Invoked with /promptName in chat
• Can specify agent, tools, and model in frontmatter
• Support variables like ${selection}, ${file}, ${input:name}
• Can reference instruction files for consistent guidelines

Example use cases:

• /create-component - Generate a new React component with tests
• /code-review - Perform a security-focused code review
• /api-route - Scaffold a new API endpoint
• /migration-plan - Generate a database migration strategy

Use Custom Agents when

Perfect for:

• Creating specialized AI personas (planner, reviewer, architect)
• Restricting available tools (e.g., read-only for planning)
• Defining sequential workflows with handoffs
• Different tasks need different tool configurations
• Using a specific model for certain tasks

Key features:

• Define tools list to control what the agent can do
• Use handoffs for guided multi-step workflows
• Specify model for optimal performance per task
• Set infer: false to prevent use as subagent

Example agents:

• Planner - Read-only tools, generates implementation plans
• Reviewer - Focus on security vulnerabilities and code quality
• Architect - Design patterns and system architecture decisions
• Implementer - Full editing capabilities for coding tasks

Use Agent Skills when

Perfect for:

• Creating capabilities that work across VS Code, CLI, and coding agent
• Need to include scripts, examples, or resources
• Building specialized testing/debugging/deployment workflows
• Sharing capabilities with the community
• Want progressive loading (only loaded when relevant)

Key features:

• Open standard at agentskills.io
• Three-level loading: discovery → instructions → resources
• Can include scripts, templates, and example files
• Works across GitHub Copilot in VS Code, CLI, and coding agent

Example skills:

• webapp-testing - Testing workflows with test templates
• github-actions-debug - Debug CI/CD workflows with log analysis
• api-documentation - Generate OpenAPI specs with examples
• database-migrations - Migration scripts with rollback templates

How They Work Together

┌─────────────────────────────────────────────────────────────┐
│                     CUSTOM AGENT                            │
│  (defines persona, tools, model)                            │
│    ├── Can reference: Custom Instructions                   │
│    └── Can be triggered by: Prompt Files (via agent field)  │
├─────────────────────────────────────────────────────────────┤
│                     PROMPT FILE                             │
│  (defines reusable task template)                           │
│    ├── Can specify: agent, tools, model                     │
│    └── Can reference: Instructions via Markdown links       │
├─────────────────────────────────────────────────────────────┤
│                  CUSTOM INSTRUCTIONS                        │
│  (always applied guidelines, foundation layer)              │
├─────────────────────────────────────────────────────────────┤
│                     AGENT SKILLS                            │
│  (portable capabilities, auto-loaded when relevant)         │
│    └── Works independently, loaded based on task context    │
└─────────────────────────────────────────────────────────────┘

Recommended Folder Structure

.github/
├── copilot-instructions.md      # Global project instructions
├── instructions/
│   ├── python.instructions.md   # Python-specific (applyTo: **/*.py)
│   ├── typescript.instructions.md
│   └── security.instructions.md # Security guidelines
├── prompts/
│   ├── create-component.prompt.md
│   ├── code-review.prompt.md
│   └── generate-tests.prompt.md
├── agents/
│   ├── planner.agent.md         # Read-only planning agent
│   ├── reviewer.agent.md        # Code review agent
│   └── implementer.agent.md     # Full coding agent
└── skills/
    ├── webapp-testing/
    │   ├── SKILL.md
    │   └── test-template.js
    └── debugging/
        └── SKILL.md

Common Combinations

Planning → Implementation Workflow

1. Agent: planner.agent.md with read-only tools
2. Handoff: Button to switch to implementation agent
3. Instructions: Shared coding standards apply to both

Consistent Test Generation

1. Skill: webapp-testing with test templates and utilities
2. Prompt: /generate-tests that references the skill patterns
3. Instructions: Test naming conventions and coverage requirements

Security-First Development

1. Instructions: Security guidelines applied globally
2. Agent: security-reviewer.agent.md for dedicated reviews
3. Prompt: /security-audit for on-demand security checks

Version Requirements

References

• Customization Overview
• Custom Instructions
• Prompt Files
• Custom Agents
• Agent Skills
• Agent Skills Standard
• Community Examples

Converted and distributed by TomeVault — claim your Tome and manage your conversions.