Whats new in VS Code: Customizations explained for beginners

Why this section is new

In recent VS Code + Copilot updates, the editor moved from only “chat responses” to a more customizable AI workflow.

That new Customizations section helps you teach Copilot:

1. Who should do the job (Agent)
2. What reusable capability to run (Skill)
3. How to behave by default (Instructions)
4. What to run automatically on events (Hooks)
5. How to connect external tools and data (MCP Servers)
6. What extra runtime capabilities to load (Plugins)

Quick mental model

flowchart TD
    U[You ask in Chat] --> I[Instructions apply]
    I --> A[Agent is selected]
    A --> S[Skill may run]
    S --> M[MCP server or Plugin tools may be called]
    A --> H[Hooks may trigger before or after events]
    M --> R[Result returned in chat/editor]
    H --> R

Agents

What it is

An Agent is a role-based AI worker. Different agents are optimized for different tasks.

Examples:

• Coding agent: edits files, runs checks, fixes errors.
• Explore agent: reads the codebase and reports findings.
• Commit reminder agent: helps with commit workflow.

When to use Agents

Use an Agent when you want to change how the work is executed, not just the answer style.

• Use a coding-focused agent for implementation and refactoring.
• Use an exploration-focused agent for searching and analysis.
• Use a workflow-focused agent for release/commit support.

Skills

What it is

A Skill is a packaged, reusable procedure or domain recipe.

A skill usually contains:

• When it should be used
• How to collect context
• Which steps/tools to run
• What output format to return

When to use Skills

Use a Skill when the task repeats and you want consistency.

• “Set up a new project”
• “Review test failures”
• “Analyze API surface”

If Agents are people, Skills are their playbooks.

Instructions

What it is

Instructions are your global/local behavior rules for Copilot.

Examples:

• Always run tests after edits
• Keep responses concise
• Prefer TypeScript
• Avoid changing public APIs unless requested

When to use Instructions

Use Instructions for persistent preferences and quality guardrails.

• Team coding standards
• File formatting rules
• Safety constraints
• Tone and response format

If something should apply almost every time, it belongs in Instructions.

Hooks

What it is

Hooks run actions automatically on events.

Common event ideas:

• Before tool execution
• After file save/change
• Before final response
• After task completion

When to use Hooks

Use Hooks for automation and enforcement.

• Auto-run linter on save
• Validate required metadata in new content files
• Trigger a checklist before finalizing output

Hooks reduce manual repetition.

MCP Servers

What it is

MCP (Model Context Protocol) Servers let Copilot talk to external systems in a structured way.

That can include:

• Databases
• Internal APIs
• Issue trackers
• Docs systems
• Business tools

When to use MCP Servers

Use MCP when Copilot needs real, live data or external actions.

• “Read table schema from SQL Server”
• “Fetch order status from internal system”
• “Search enterprise docs”

Without MCP, Copilot mainly uses local files + built-in tools.

Plugins

What it is

Plugins extend functionality with additional runtime integrations.

Depending on your setup, plugins can provide:

• New commands
• New tool adapters
• App-specific actions

When to use Plugins

Use Plugins when a product or workflow needs a dedicated extension layer that is not covered by your default agent + skill setup.

When to use which one

Decision diagram

flowchart TD
    Q[What do you need?] --> B{Behavior rule or one-time task?}
    B -->|Behavior rule| I[Use Instructions]
    B -->|Task execution| C{Need specialist workflow?}
    C -->|Yes| A[Pick Agent]
    C -->|No| S[Use default Agent]

    A --> D{Task repeats often?}
    S --> D
    D -->|Yes| K[Create or use Skill]
    D -->|No| E[Run direct prompt]

    E --> F{Need external system data/action?}
    K --> F
    F -->|Yes| M[Use MCP Server]
    F -->|No| G{Need auto trigger on event?}
    M --> G
    G -->|Yes| H[Add Hook]
    G -->|No| P[Optional Plugin only if needed]

Beginner to intermediate learning path

Stage 1: Beginner (Week 1)

Focus only on:

1. Basic chat prompting
2. One useful Instruction file
3. One default Agent for coding

Goal: Get consistent outputs.

Stage 2: Early practical (Week 2)

Add:

1. One Skill for repeated tasks (for example, article creation checklist)
2. One simple Hook (for validation/lint)

Goal: Save time on repeated work.

Stage 3: Intermediate (Week 3-4)

Add:

1. MCP server for one real data source
2. Optional plugin if workflow needs it
3. Separate agents for exploration vs implementation

Goal: Move from “assistant” to “automated teammate”.

Practical examples for your blog workflow

1. Instructions: enforce frontmatter fields for every new post.
2. Agent: use coding agent for file creation and formatting.
3. Skill: create a “new article template” skill with title, tags, metadata checks.
4. Hook: run a metadata validator before final response.
5. MCP: pull publish queue data from a content calendar system.
6. Plugin: integrate a custom tool if your pipeline requires special commands.

Common mistakes to avoid

1. Using Instructions for one-time tasks. Use prompt or skill instead.
2. Creating too many agents early. Start with one or two.
3. Adding hooks without understanding trigger scope.
4. Expecting MCP to work without server auth/config.
5. Installing plugins before proving a real need.

Final checklist

Before adding a new customization, ask:

1. Is this a preference? Use Instructions.
2. Is this a role? Use Agent.
3. Is this a repeatable method? Use Skill.
4. Is this event automation? Use Hook.
5. Is this external data/action? Use MCP Server.
6. Is this an extra integration surface? Use Plugin.

If you follow this order, you will quickly move from beginner to intermediate without over-complicating your setup.