# VS Code Copilot Customization vs Claude Code: 5 Primitives Compared (2026) In April 2026, VS Code shipped a unified **Chat Customizations** editor that surfaces five customization primitives in one place: custom agents, agent skills, custom instructions, prompt files, and hooks. The framing is useful — but it is also the framing Anthropic landed at independently for Claude Code, which exposes the same five primitives under slightly different names and slightly different file paths. If you use both tools (or are choosing between them), the decision is almost never about *what* you can customize. It is about which file path, which YAML frontmatter, and which lifecycle event you have to remember. This guide compares the 5 primitives side-by-side, with concrete file paths, working snippets, and a verdict per primitive. This is **Episode 1 of 8** in the Agent Customizations UI series. Source: [The Agent Customizations UI Nobody Knows About — Visual Studio Code on YouTube](https://www.youtube.com/watch?v=AZzCk-WGks4). ## Learning Outcomes By the end of this guide, you will be able to: 1. Map each of the 5 customization primitives between VS Code Copilot and Claude Code by file path and frontmatter 2. Write a working SKILL.md, agent, prompt, instruction, or hook that runs in either tool 3. Know which primitive to reach for given a specific automation goal 4. Identify the **one** primitive where the two tools genuinely differ in capability (not just file path) 5. Avoid the most common gotcha: confusing skills with custom commands, and prompts with instructions --- ## The 5 Primitives at a Glance | # | Primitive | VS Code Copilot path | Claude Code path | What it does | |---|---|---|---|---| | 1 | Custom Instructions | `.github/copilot-instructions.md`, `AGENTS.md`, `*.instructions.md` | `CLAUDE.md`, `.claude/rules/*.md` | Persistent project rules loaded every session | | 2 | Prompt Files | `.github/prompts/*.prompt.md` | `.claude/commands/*.md` (legacy) or `.claude/skills//SKILL.md` | Reusable prompt templates invoked with `/name` | | 3 | Custom Agents | `.github/agents/*.agent.md` | `.claude/agents/.md` | Personas with their own system prompt and tool list | | 4 | Agent Skills | `.github/skills//SKILL.md` | `.claude/skills//SKILL.md` | Auto-loaded capabilities — can bundle scripts and supporting files | | 5 | Hooks | `.github/hooks/*.json` | `.claude/settings.json` (`hooks` key) | Shell commands fired at lifecycle events | Two notes before the deep dives: - **Skills are an open standard now.** Both tools follow the [Agent Skills](https://agentskills.io) spec, so a `SKILL.md` written for one frequently works in the other if you put it under the right directory. This is the most portable primitive of the five. - **VS Code Copilot reads Claude formats.** Microsoft documented that Copilot also reads `.claude/agents/`, `.claude/skills/`, and `CLAUDE.md` for compatibility. Claude Code does not currently read `.github/copilot-instructions.md`, so the cross-compat goes one way. --- ## Module 1: The 5 Primitives in Depth ### Lesson 1: Custom Instructions — Persistent Project Rules **The job**: tell the AI conventions it should always follow in this project, without re-typing them each session. **VS Code Copilot.** The default and simplest location is `.github/copilot-instructions.md` at repo root. Plain markdown, no frontmatter required. Applies to every chat request workspace-wide. For finer control, drop file-scoped rules in `.github/instructions/` with `.instructions.md` extension and a `applyTo` glob in YAML frontmatter: ```text --- name: api-style description: REST conventions for handlers applyTo: "src/api/**/*.ts" --- - All endpoints must validate input with zod - Return errors as { error: { code, message } } - Log with `lib/logger.ts`, never console.log ``` Copilot also reads `AGENTS.md` at the repo root and `CLAUDE.md` (workspace, `~/.claude/CLAUDE.md`, or `CLAUDE.local.md`) — which is what makes a single `CLAUDE.md` portable across both tools. **Claude Code.** The canonical file is `CLAUDE.md` at the project root, with `.claude/rules/*.md` for path-scoped overrides. The path syntax in Claude Code rules uses a `paths` field instead of Copilot's `applyTo`: ```text --- paths: - "src/api/**/*.ts" --- # API Development Rules - All endpoints must validate input - Use the standard error response format - Include OpenAPI documentation comments ``` `CLAUDE.md` files load by walking up the directory tree from the working directory. Files over ~200 lines reduce adherence — split with `.claude/rules/` or with `@path` imports. Claude also has an **auto memory** system at `~/.claude/projects//memory/MEMORY.md` that is *written by Claude itself*; Copilot has no equivalent. **Verdict — Lesson 1**: Roughly tied if you use a single `CLAUDE.md`, since both tools read it. Claude wins on **path-scoped rules with first-class auto-loading** (`paths:` frontmatter that triggers when a matching file is opened) and the auto-memory loop. Copilot's `applyTo` is the same concept under a different field name. ### Lesson 2: Prompt Files — Reusable Templates **The job**: capture a workflow you run repeatedly ("review this API for security", "scaffold a Convex mutation") and invoke it with a slash command. **VS Code Copilot.** Workspace prompts live in `.github/prompts/*.prompt.md`. User prompts live in your VS Code user data directory. The format is YAML frontmatter plus a markdown body: ```text --- name: review-api description: Perform REST API security review agent: ask --- Review this API for security issues: - Authentication and authorization - Input validation - Rate limiting - Security event logging ``` Invoke with `/review-api` in chat, or via the Command Palette **Chat: Run Prompt**. Frontmatter supports `agent`, `model`, and `tools` overrides per prompt. **Claude Code.** Custom slash commands historically lived in `.claude/commands/.md`. As of late 2025, Anthropic merged custom commands into skills: a file at `.claude/commands/deploy.md` and a skill at `.claude/skills/deploy/SKILL.md` both expose `/deploy` and behave the same way. Existing `.claude/commands/` files keep working, but skills are recommended because they support a directory of supporting files. A minimal prompt-equivalent skill: ```text --- name: review-api description: Perform REST API security review disable-model-invocation: true --- Review the file the user mentions for: - Authentication and authorization - Input validation with zod - Rate limiting - Security event logging ``` The `disable-model-invocation: true` line is the key trick: it makes the skill behave like a prompt file (only the user can invoke it, never auto-loaded by Claude on its own). **Verdict — Lesson 2**: Tied for basic prompts. Claude wins for **prompts that need supporting files** (a SKILL.md plus templates, scripts, or examples in the same directory) because Copilot prompts are single-file. ### Lesson 3: Custom Agents — Specialized Personas **The job**: spawn a persona (security reviewer, architect, debugger) with its own system prompt and a restricted tool list, so it can't accidentally edit code when you only want analysis. **VS Code Copilot.** Workspace agents live in `.github/agents/*.agent.md`. Frontmatter fields include `name`, `description`, `tools` (array of allowed tools), `model`, `handoffs` (transition buttons between agents), and `agents` (subagents this one can invoke). ```text --- name: security-reviewer description: Read-only security analyst tools: ['search/codebase', 'web/fetch'] model: gpt-4o --- You are a senior application-security reviewer. Read code, identify OWASP Top 10 risks, and report findings. Do not modify any files. ``` Tool restriction is enforced — a security reviewer with no `edit` tool literally cannot edit. Copilot also recognizes `.claude/agents/` for cross-tool compat. **Claude Code.** Subagents live in `.claude/agents/.md` (project) or `~/.claude/agents/.md` (personal). The frontmatter has a deeper feature set: `description`, `prompt`, `tools`, `disallowedTools`, `model`, `permissionMode`, `mcpServers`, `hooks`, `maxTurns`, `skills`, `initialPrompt`, `memory`, `effort`, `background`, `isolation`, `color`. ```text --- name: code-reviewer description: Read-only code reviewer. Use proactively after edits. tools: ['Read', 'Grep', 'Glob'] model: sonnet memory: user --- You are a senior code reviewer. Focus on quality, security, and best practices. Do not modify files. ``` Two Claude-only capabilities worth calling out: - **Persistent memory per subagent.** `memory: user` gives the subagent a directory at `~/.claude/agent-memory/` where it accumulates insights across invocations. - **Isolation.** `isolation: worktree` runs the subagent in a separate git worktree so its file edits don't pollute the main checkout until merged. **Verdict — Lesson 3**: **Claude Code wins**. Same core concept (persona + tool list), but Claude's frontmatter exposes worktree isolation, per-agent memory, hooks, MCP servers, and effort levels. Copilot's `handoffs` field is the only thing it has that Claude doesn't expose directly. ### Lesson 4: Agent Skills — Auto-Loaded Capabilities **The job**: a capability Claude or Copilot can decide to load on its own when relevant, and that may include scripts, examples, or reference material — not just a prompt. This is the most important primitive in 2026, and it is the primitive where the two tools have **converged on a single open standard**. Both tools store skills as a directory containing `SKILL.md`: ```text my-skill/ ├── SKILL.md # Required - YAML frontmatter + body ├── reference.md # Optional - loaded on demand ├── examples/ # Optional - example outputs └── scripts/ # Optional - executable helpers └── helper.py ``` **Path conventions.** Project skills go in `.github/skills//`, `.claude/skills//`, or `.agents/skills//`. Personal skills go in `~/.copilot/skills//`, `~/.claude/skills//`, or `~/.agents/skills//`. Both tools recognize all three project paths; pick one for portability. **Frontmatter shared by both tools:** ```text --- name: pr-summary description: Summarize changes in a pull request. Use when asked about a PR or to draft a PR description. allowed-tools: Bash(gh *) --- ## Pull request context - PR diff: !`gh pr diff` - PR comments: !`gh pr view --comments` ## Your task Summarize this pull request highlighting risks... ``` The `description` is what the model reads to decide whether to load the skill. Front-load the trigger phrase. The body is what gets injected when the skill activates. **Where the tools diverge:** - Claude extends the spec with `disable-model-invocation`, `user-invocable`, `context: fork` (run in subagent), `paths` (auto-load when working with matching files), `effort`, and `model`. It also resolves `` !`shell` `` and `${VAR}` substitutions before injection. - Copilot exposes `argument-hint`, `user-invocable`, and `disable-model-invocation`. Argument substitution patterns are similar. **Skills vs custom instructions — the practical distinction.** Custom instructions apply *universally*. Skills apply *on demand*. If you write "always use 2-space indent" it is an instruction. If you write "when the user asks for a security review, do X, Y, Z and run script.sh" it is a skill. Putting the second one in CLAUDE.md/`copilot-instructions.md` wastes context tokens every session. Putting the first one in a skill means Claude may forget it. **Verdict — Lesson 4**: **Tied** by design — both implement the same Agent Skills open standard. Claude's extensions (`context: fork`, `paths`, shell substitution) are nicer if you live in Claude Code. The skills you write are largely portable. ### Lesson 5: Hooks — Lifecycle Automation **The job**: deterministically run a shell command at a specific point in the agent's workflow. Auto-format on edit. Block dangerous Bash. Log every prompt. This is the primitive most prone to subtle breakage, because it uses real JSON config and runs real shell commands with real exit codes. **VS Code Copilot.** Hooks live in `.github/hooks/*.json` (workspace) or `~/.copilot/hooks/` (user). Copilot also reads `.claude/settings.json` for cross-tool compat. Eight lifecycle events: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PreCompact`, `SubagentStart`, `SubagentStop`, `Stop`. ```json { "hooks": { "PostToolUse": [ { "type": "command", "command": "npx prettier --write \"$TOOL_INPUT_FILE_PATH\"" } ] } } ``` This auto-formats every file Copilot edits. Output appears in the **GitHub Copilot Chat Hooks** output channel. **Claude Code.** Hooks live in `.claude/settings.json`, `.claude/settings.local.json`, `~/.claude/settings.json`, plugin `hooks/hooks.json`, or per-skill/agent frontmatter. Events: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, `Stop`, `SessionEnd` (and a few more for compaction). The matcher syntax differs from Copilot — Claude uses a `matcher` field per event: ```json { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "if": "Bash(rm *)", "command": "~/.claude/hooks/block-rm.sh" } ] } ] } } ``` The script communicates back via stdout JSON or exit code: ```bash #!/bin/bash COMMAND=$(jq -r '.tool_input.command') if echo "$COMMAND" | grep -q 'rm -rf'; then jq -n '{ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: "Destructive command blocked" } }' else exit 0 fi ``` Claude additionally supports four non-shell handler types: `http` (POST to URL), `mcp_tool` (call an MCP tool), `prompt` (yes/no decision via Claude itself), and `agent` (spawn a subagent for verification). Copilot is shell-only. **Verdict — Lesson 5**: **Claude Code wins on flexibility** (more event types, non-shell handlers, structured permission decisions). Copilot wins on **simplicity** if you only need "format-on-save"-style automation. --- ## Module 2: The Unified UI The video that prompted this guide shows a real win for VS Code: the **Chat Customizations editor** (Preview), opened via Command Palette → `Chat: Open Chat Customizations` (or the gear icon in the chat panel). It surfaces all five primitives plus MCP servers and plugins in one screen, with a generate-with-AI option for each. Claude Code's equivalent is split across multiple commands: `/agents` (subagents), `/memory` (CLAUDE.md and rules), `/permissions` (tool allow/deny), and direct file editing for skills and hooks. There is also `/init` for bootstrapping a CLAUDE.md. **Verdict — UI**: VS Code Copilot wins. A single discovery surface beats five commands when you are first onboarding. By the time you are fluent, this matters less — you are editing files in your editor anyway. --- ## Module 3: When to Pick Which | Situation | Reach for | |---|---| | Writing your first customization, want a single screen to see everything | **VS Code Copilot** (Chat Customizations UI) | | Need a subagent isolated to a git worktree | **Claude Code** (only one with `isolation: worktree`) | | Want hooks that decide via HTTP/MCP/another agent, not just shell | **Claude Code** (only one with non-shell hook handlers) | | Need persona-with-tool-restriction for read-only review | Tied — both expose `tools` array on agents | | Want a skill that bundles a Python script + reference docs | Tied — both implement the Agent Skills spec | | Running on a team where some devs use Cursor, OpenCode, or other Claude-compatible tools | **Claude Code formats** (`.claude/`, `CLAUDE.md`, `SKILL.md`) — most portable | | Auto-format every file the agent edits | Either — Claude's `PostToolUse` hook with `prettier --write` is one line; Copilot's is the same line | **Overall verdict.** If you need maximum control (per-agent memory, worktree isolation, HTTP hooks, path-scoped rules with first-class lazy loading), **Claude Code** wins on raw capability. If you need the lowest-friction onboarding and the unified discovery UI, **VS Code Copilot** wins on ergonomics. The skills you write are largely portable between them — that is the right place to invest if you want to hedge. --- ## References - [Customize AI in Visual Studio Code (overview)](https://code.visualstudio.com/docs/copilot/customization/overview) - [Use Agent Skills in VS Code](https://code.visualstudio.com/docs/copilot/customization/agent-skills) - [Custom agents in VS Code](https://code.visualstudio.com/docs/copilot/customization/custom-agents) - [Custom instructions for VS Code Copilot](https://code.visualstudio.com/docs/copilot/customization/custom-instructions) - [Prompt files](https://code.visualstudio.com/docs/copilot/customization/prompt-files) - [Hooks](https://code.visualstudio.com/docs/copilot/customization/hooks) - [Claude Code: Create custom subagents](https://code.claude.com/docs/en/sub-agents) - [Claude Code: Extend Claude with skills](https://code.claude.com/docs/en/skills) - [Claude Code: Hooks reference](https://code.claude.com/docs/en/hooks) - [Claude Code: Memory and CLAUDE.md](https://code.claude.com/docs/en/memory) - [Agent Skills open standard](https://agentskills.io) - Source video: [The Agent Customizations UI Nobody Knows About | Visual Studio Code](https://www.youtube.com/watch?v=AZzCk-WGks4)