Access and Manage All Customizations from One UI

VS Code's new Customization UI centralizes management of AI behaviors for Copilot Chat, accessible via Command Palette ("chat customizations") or the gear icon in Chat view. This dashboard lists built-in and custom items like agents, skills, instructions, hooks, and prompts. Click any to view/edit details, generate new ones, or delete. Generate via UI buttons or Chat slash commands like /create instructions—Copilot drafts the file based on your description, scopes it to user/workspace, and auto-applies to relevant files (e.g., HTML/CSS for accessibility rules).

Key principle: Customizations persist across sessions, reducing repetition. Without them, every prompt requires re-explaining context, styles, or rules, leading to inconsistent results and trial-and-error. With them, define once (e.g., "Apply SOLID principles to all refactors") and Copilot enforces automatically, confirming application in responses.

Common mistake: Scattering files across folders—instead, use the UI for discovery. Test by reloading VS Code after creation. For teams, workspace-level instructions ensure consistent naming, formatting, and architecture, cutting review time.

Quote: "Customization changes that. It lets you define behavior once, reuse it everywhere, and get consistent outputs."

Enforce Rules and Styles with Custom Instructions

Custom instructions are Markdown files acting as a "rule book" for Copilot, applied automatically to matching file types (defined in apply_to metadata). Structure: metadata (description, glob patterns like **/*.js), then bullet-point rules.

Steps to create:

  1. In Chat: /create instructions + description (e.g., "Ensure UI meets WCAG standards, confirm in chat").
  2. Copilot generates .instructions.md (user: ~/.vscode-customizations/; workspace: .vscode-customizations/).
  3. Review/edit in UI: Add confirmation phrases like "Confirmation: Applied WCAG standards."
  4. Test: Ask Copilot to edit code (e.g., "Refactor this script" or "Make UI 80s arcade style")—it analyzes, applies rules, and confirms.

Example before/after: Original calculator JS lacked SOLID separation; post-refactor: Single Responsibility (separate concerns), confirmed in chat. UI update auto-added ARIA labels, alt text for WCAG.

Quality criteria: Instructions must be specific (e.g., "Use semantic HTML, keyboard nav") not vague; include triggers ("when generating/refactoring UI") and confirmation for verification. Benefits scale to teams: Repo-wide consistency without manual reviews.

Quote: "Imagine every developer in the repo having Copilot follow the same coding conventions... This saves a lot of time."

Specialize Agents with Skills and Custom Agents

Agent skills are folders (skill.md + resources/scripts) for domain-specific tasks, loadable across Copilot tools (VS Code, CLI). Custom agents build on skills, assigning personas (e.g., "Security Reviewer") with tools/instructions.

Build a skill:

  1. /create skill + task (e.g., "Update README on feature add, confirm in chat").
  2. Copilot creates folder with skill.md (description, related skills, rules like "Extract feature from convo, append to README features section").
  3. Test: Add feature (e.g., "Add dark/light jingle")—skill auto-updates README.

Build custom agent:

  1. Ask Copilot for prompt: "Suggest custom agent for arcade calculator."
  2. /create agent + persona (e.g., "Arcade App Builder: Knows retro aesthetics, sound effects, HTML/JS/CSS stack").
  3. Select from Chat dropdown (@agentname); it uses codebase knowledge for tasks like "Build tip calculator."

Example: Security agent reviews JS for vulns (categorizes low/medium/high); Arcade agent clones styles/sounds to new app. Trade-off: Domain-focused (great for projects) but overkill for one-offs.

Mistake to avoid: Not scoping (user vs. workspace)—use workspace for teams. Quality: Clear description, minimal tools, architecture awareness.

Quote: "Custom agents enable you to configure the AI to adopt different personas tailored to specific development roles and tasks."

Automate Repetitive Tasks with Hooks and Prompt Files

Hooks run shell commands at agent lifecycle events (e.g., post_tool_use). Prompt files are reusable templates.

Create hook:

  1. UI > Generate hook + spec (e.g., "Run Prettier on post_tool_use").
  2. Edits .vscode-customizations/hooks/prettier.hook.json: Define events (array), command (e.g., npx prettier --write .).
  3. Reload VS Code; test: Edit README—hook auto-formats.

Prompt files: /create prompt for templates (e.g., code review); reference in skills.

Principle: Automate validation (security, formatting) without manual invocation. Events: start_session, user_prompt_submit, post_tool_use. Trade-off: Shell reliance—test commands; no timeout for long runs.

Full workflow example: Build app from scratch—use instructions for styles, agent for features, hook for formatting, skill for docs. Results: Arcade calculator with themes, sounds, WCAG, auto-README, formatted.

Quote: "Hooks enable you to execute custom shell commands at life cycle points during agent sessions... automate workflows, enforce security policies."

Key Takeaways

  • Open Customization UI via gear or "chat customizations" to manage everything in one place.
  • Start with custom instructions for persistent rules: /create instructions + glob patterns + confirmations.
  • Use agent skills for tasks (e.g., README updates) and custom agents for personas—select via @dropdown.
  • Automate with hooks on lifecycle events like post_tool_use for formatters; reload to activate.
  • Generate via Copilot slash commands to skip manual writing; always review/edit.
  • Scope user/workspace for personal/team use; test on real edits/refactors.
  • Check Awesome Copilot repo for community examples.
  • Avoid repetition: Customizations turn Copilot into a context-aware system.
  • For apps: Chain features—instructions for compliance, agents for domain logic, hooks for polish.