drvoss/everything-copilot-cli

# GitHub Actions Debugging

## Why This is Copilot-Exclusive

GitHub access is built into Copilot CLI with no extra setup: the built-in GitHub MCP server (full
tool set when `gh` is absent, or when restored with the flags in the note below) or `gh`, which
the model is expected to use when it is installed. Either way you can list workflows, inspect run details, download job logs,
and analyze failures in one conversation.
What is exclusive is the built-in GitHub MCP server, which needs no token or extension setup; when `gh` is installed, the model mostly uses `gh`, which any agent with a shell can also run.

> **Note:** When `gh` is on PATH, Copilot CLI omits the Actions MCP tools (`actions_list`, `actions_get`, `get_job_logs`) and the model is expected to use `gh` instead,
> e.g. `gh run list --workflow <file>`, `gh run view <run-id> --log-failed`, `gh run view --job <job-id> --log`. To call the MCP tools,
> start the session with `--add-github-mcp-tool=<name>` for every GitHub MCP tool you need (it replaces the default set, so include default ones you still use), or `--enable-all-github-mcp-tools`, which also enables write tools.

# Autopilot Mode Patterns

## Why This is Copilot-Exclusive

Copilot CLI's **Autopilot mode** lets the agent work autonomously through a plan without
stopping for approval at each step. Combined with Plan Mode's structured todos and Fleet's
parallelism, this creates a spectrum of autonomy levels — from fully interactive to fully
autonomous — that you can dial in per task. Claude Code has auto and bypass permission modes
too; Copilot's autopilot differs in continuing from an approved plan until the task is complete.

## When to Use

- Well-defined tasks with clear acceptance criteria
- Repetitive operations across many files (migrations, formatting, refactors)

# Background Delegation

## What It Is

**Background Delegation** hands off tasks to a cloud-based Copilot coding agent on GitHub.
Your terminal is immediately freed. The agent works on a branch in GitHub and opens an
AI-generated pull request (against the current branch by default; choose another target with
/delegate --base). You review the result in that PR.

This is distinct from async PowerShell (for local long-running processes like builds/servers),
which still uses `mode: "async"` in the powershell tool.

## When to Use

# Cross-Session Memory & Continuity

## Why This is Copilot-Exclusive

Copilot CLI maintains a **cross-session history store** — a read-only SQLite database
(`session_store`) that contains conversation history, file references, and full-text search
across all your past sessions. Combined with `/resume` to continue previous sessions and
session artifacts stored in `files/`, this creates persistent memory across your development
workflow. Claude Code can also continue and resume sessions; this skill covers Copilot's own session history, artifacts, and Chronicle.

## When to Use

- Resuming work on a multi-day task
- Searching past sessions for how you solved a similar problem before

# GitHub PR Workflow Automation

## Why This is Copilot-Exclusive

GitHub access is built into Copilot CLI with no extra setup: the built-in GitHub MCP server (full
tool set when `gh` is absent, or when restored with the flags in the note below) or `gh`, which
the model is expected to use when it is installed. Either way you can list,
search, read, diff, and check CI status on pull requests in one conversation. What is exclusive is the built-in GitHub MCP server, which needs no token or extension setup; when `gh` is installed, the model mostly uses `gh`, which any agent with a shell can also run.

> **Note:** When `gh` is on PATH, Copilot CLI omits the PR read tools (`list_pull_requests`, `search_pull_requests`, `pull_request_read`) and the model is expected to use `gh`
> instead, e.g. `gh pr list`, `gh pr diff <n>`, `gh pr checks <n>`. To call the MCP tools,
> start the session with `--add-github-mcp-tool=<name>` for every GitHub MCP tool you need (it replaces the default set, so include default ones you still use), or `--enable-all-github-mcp-tools`, which also enables write tools.

## When to Use

# IDE ↔ CLI Switching

## Why This is Copilot-Exclusive

GitHub Copilot exists in **both VS Code and the terminal** under a single subscription and
unified platform. You can start a conversation in VS Code's Copilot Chat, switch to the CLI
for batch automation, and return to VS Code for visual debugging — all with the same model
access, same MCP servers, and same GitHub integration. Claude Code can connect to an IDE from the terminal, but Copilot is one product with native chat in both VS Code and the CLI.

## When to Use

- Visual tasks (diffing, debugging UI, extension-based tooling) → VS Code
- Batch operations, automation, scripting → CLI
- Large refactors that benefit from both visual review and automated execution

# Plan Mode Mastery

## Why This is Copilot-Exclusive

Copilot CLI has a **dedicated Plan Mode** activated by Shift+Tab that fundamentally changes
how you interact with the agent. Instead of executing immediately, Copilot creates a structured
plan with SQL-backed todo tracking, presents it in the terminal for review, and lets you choose
between interactive execution, autopilot, or fleet mode. Claude Code also has a plan permission mode;
Copilot's differs in linking the plan to SQL todos and to the autopilot/fleet hand-off.

> **Using another tool?** This skill describes Copilot CLI's own features (Plan Mode, the
> `exit_plan_mode` tool, SQL todos, Autopilot, Fleet). Cursor, Antigravity, and Claude Code do not
> have these, so there use only the general ideas — plan first, track steps, checkpoint — and
> ignore the tool-specific commands.

# Session SQL Database Management

## Why This is Copilot-Exclusive

Copilot CLI includes a **built-in SQLite database per session** accessible via a native `sql`
tool. It comes with pre-built `todos` and `todo_deps` tables and supports creating any custom
tables you need. This structured data layer enables proper task tracking, batch processing, and
state management — all queryable with SQL. Claude Code has no database; state management is
limited to reading/writing files or keeping everything in the conversation context.

## When to Use

- Tracking progress on multi-step tasks with dependencies
- Batch-processing items (issues, files, test cases) with status tracking

# Stack Detector

## Why This is Copilot-Exclusive

This skill is specific to the **everything-copilot-cli collection**: the recommendation table
maps detected technologies to skill and rule file paths that only exist in this repository.
Other AI agents can also inspect file systems, but this skill's value is the curated mapping
to this specific collection's skills and rules — not the file-scanning mechanics itself.

## When to Use

- At the start of a session on an unfamiliar codebase, before or alongside `context-prime`
- When you want focused recommendations for which skills and rules apply to this project
  (`context-prime` loads broad context; `stack-detector` targets specific recommendations)

# AI Visibility (GEO — Generative Engine Optimization)

Search is shifting from Google links to AI-generated answers. Users ask ChatGPT, Claude,
Perplexity, and Gemini instead of searching. If your product isn't cited in those
answers, you're invisible to a growing segment of your audience.

GEO (Generative Engine Optimization) is the practice of making your content easy for
AI systems to find, understand, cite, and recommend.

## The llms.txt Standard

`llms.txt` is a proposed standard (similar to `robots.txt`) that helps LLMs understand
your site's structure and find your most important content.

# Content Strategy

Content strategy is the intersection of what your audience searches for, what
you have authority to say, and what supports your business goals. This skill
helps you build a data-driven content plan — not a random blog schedule.

## Core Framework

```text
Business Goal → Target Audience → Keyword Research → Topic Clusters → Content Calendar
```

## Step 1: Define Your Content Goals

# SEO

Improve search visibility through technical correctness, performance, and content relevance — not gimmicks.

> **Distinct from [`ai-visibility`](../ai-visibility/SKILL.md):** This skill covers traditional search engine optimization (Google, Bing). `ai-visibility` covers GEO — optimizing for AI crawlers, llms.txt, and AI citation surfaces.

## When to Use

- Auditing crawlability, indexability, canonicals, or redirects
- Improving title tags, meta descriptions, and heading structure
- Adding or validating structured data (JSON-LD)
- Improving Core Web Vitals (LCP, INP, CLS)
- Keyword research and URL-to-keyword mapping
- Planning internal linking or sitemap/robots changes

# GitHub Actions Debugging

## Why This is Copilot-Exclusive

GitHub access is built into Copilot CLI with no extra setup: the built-in GitHub MCP server (full
tool set when `gh` is absent, or when restored with the flags in the note below) or `gh`, which
the model is expected to use when it is installed. Either way you can list workflows, inspect run details, download job logs,
and analyze failures in one conversation.
What is exclusive is the built-in GitHub MCP server, which needs no token or extension setup; when `gh` is installed, the model mostly uses `gh`, which any agent with a shell can also run.

> **Note:** When `gh` is on PATH, Copilot CLI omits the Actions MCP tools (`actions_list`, `actions_get`, `get_job_logs`) and the model is expected to use `gh` instead,
> e.g. `gh run list --workflow <file>`, `gh run view <run-id> --log-failed`, `gh run view --job <job-id> --log`. To call the MCP tools,
> start the session with `--add-github-mcp-tool=<name>` for every GitHub MCP tool you need (it replaces the default set, so include default ones you still use), or `--enable-all-github-mcp-tools`, which also enables write tools.

# Agentic Engineering

Design tasks so AI agents can execute them reliably. This is not about *using* Copilot features — it is about **architecting work** so agents succeed on the first attempt, fail loudly when they can't, and hand off cleanly to the next agent.

## Why This is Copilot-Exclusive

The patterns here are specific to Copilot CLI's agent execution model: `task()` dispatch, `read_agent` / `write_agent` lifecycle, SQL session state, and background agents with `mode: "background"`. They don't map directly to interactive coding sessions in other tools.

## When to Use

- Decomposing a large task before dispatching it to an agent or fleet
- Designing a multi-agent workflow where context must transfer between agents
- Debugging why an agent produced incorrect or incomplete output
- Establishing quality standards for a new agentic workflow

# Autopilot Mode Patterns

## Why This is Copilot-Exclusive

Copilot CLI's **Autopilot mode** lets the agent work autonomously through a plan without
stopping for approval at each step. Combined with Plan Mode's structured todos and Fleet's
parallelism, this creates a spectrum of autonomy levels — from fully interactive to fully
autonomous — that you can dial in per task. Claude Code has auto and bypass permission modes
too; Copilot's autopilot differs in continuing from an approved plan until the task is complete.

## When to Use

- Well-defined tasks with clear acceptance criteria
- Repetitive operations across many files (migrations, formatting, refactors)

# Background Delegation

## What It Is

**Background Delegation** hands off tasks to a cloud-based Copilot coding agent on GitHub.
Your terminal is immediately freed. The agent works on a branch in GitHub and opens an
AI-generated pull request (against the current branch by default; choose another target with
/delegate --base). You review the result in that PR.

This is distinct from async PowerShell (for local long-running processes like builds/servers),
which still uses `mode: "async"` in the powershell tool.

## When to Use

# Context Prime

## Why This is Copilot-Exclusive

Copilot CLI reads `.github/copilot-instructions.md` automatically on every session start.
This skill layers *additional* context loading on top of that — fetching live project state
(recent commits, file structure, test status) that static instructions can't capture.

## When to Use

- At the start of any session before making changes to an unfamiliar codebase
- When resuming work after a long break (branch has moved, dependencies changed)
- Before running a large autopilot or fleet task — ensure the AI has full context
- When onboarding a new contributor — demonstrate the project structure interactively

# Copilot Memory

Copilot Memory is GitHub Copilot's repository-level memory layer. It lets Copilot learn durable
facts about a codebase over time and reuse them across Copilot CLI, Copilot cloud agent, and
Copilot code review.

## Why This is Copilot-Exclusive

This is not the same thing as session history:

- **`cross-session-memory`** is your local CLI session history and artifacts
- **Copilot Memory** is repository-scoped memory that Copilot validates and reuses across products

Copilot Memory is unique because it spans multiple Copilot surfaces for the same repository and is

# Cross-Session Memory & Continuity

## Why This is Copilot-Exclusive

Copilot CLI maintains a **cross-session history store** — a read-only SQLite database
(`session_store`) that contains conversation history, file references, and full-text search
across all your past sessions. Combined with `/resume` to continue previous sessions and
session artifacts stored in `files/`, this creates persistent memory across your development
workflow. Claude Code can also continue and resume sessions; this skill covers Copilot's own session history, artifacts, and Chronicle.

## When to Use

- Resuming work on a multi-day task
- Searching past sessions for how you solved a similar problem before

# Ecosystem Intake

Curated lists are only useful if they turn into decisions. This skill converts ecosystem
inputs like `awesome-claude-code`, release notes, or community skill collections into a
structured **adopt / adapt / reject** backlog for this repository.

## Why This is Copilot-Exclusive

The value is not generic web research. The value is combining **GitHub-native repository
inspection** with **session SQL tracking** in one workflow:

- GitHub MCP or `web_fetch` to read the upstream list or repo state
- SQL tables to track candidate items and triage status
- Copilot task routing to decide whether a candidate becomes a new skill, an update, or a rejection

# Fleet Mode Parallel Execution

## Why This is Copilot-Exclusive

Copilot CLI's **Fleet mode** launches multiple autonomous agents in parallel, each working
on an independent subtask in its own context window. This is a fundamentally different
execution model — not just "run commands in parallel" but full AI agents running concurrently
with their own tool access. Those subagents are also steerable: if an in-flight agent starts
drifting, you can send a follow-up message to correct course instead of waiting for the whole
run to finish.

## When to Use

- Refactoring the same pattern across many files simultaneously

# GitHub Code Search as Context

## Why This is Copilot-Exclusive

Copilot CLI includes built-in GitHub MCP tools for global code search and repository
inspection. That makes it practical to search for real implementations on GitHub, read
the matching files, and bring the results back into your current task without leaving
the CLI.

## When to Use

- You want grounded implementation examples before writing a new pattern
- You need to compare how multiple repositories solve the same problem
- You want to inspect real API usage instead of relying only on memory or docs

# GitHub Codespaces Efficiency

Audit GitHub Codespaces efficiency with a GitHub-native lens. Focus on devcontainer size,
startup time, machine sizing, prebuild scope, and idle-time discipline without stripping away
tools the team relies on every day.

## Why This is Copilot-Exclusive

GitHub Codespaces is a GitHub-native development environment. This skill is most useful when
you can inspect repository configuration, correlate it with `gh`-based Codespaces metadata,
and turn the result into Copilot-driven GitHub workflow guidance.

## When to Use

# GitHub Issue Triage & Management

## Why This is Copilot-Exclusive

GitHub access is built into Copilot CLI with no extra setup: the built-in GitHub MCP server (full
tool set when `gh` is absent, or when restored with the flags in the note below) or `gh`, which
the model is expected to use when it is installed. When exposed, the MCP issue tools add sub-methods for comments,
labels, and sub-issues. Either way Copilot reasons over the results directly. What is exclusive is the built-in GitHub MCP server, which needs no token or extension setup; when `gh` is installed, the model mostly uses `gh`, which any agent with a shell can also run.

> **Note:** When `gh` is on PATH, Copilot CLI omits these issue tools (`list_issues`, `search_issues`, `issue_read`) and the model is expected to use `gh` instead,
> e.g. `gh issue list --state open --label <label>`, `gh issue view <n> --comments`, `gh search issues "<query>"`. To call the MCP tools,
> start the session with `--add-github-mcp-tool=<name>` for every GitHub MCP tool you need (it replaces the default set, so include default ones you still use), or `--enable-all-github-mcp-tools`, which also enables write tools.

## When to Use

# GitHub PR Workflow Automation

## Why This is Copilot-Exclusive

GitHub access is built into Copilot CLI with no extra setup: the built-in GitHub MCP server (full
tool set when `gh` is absent, or when restored with the flags in the note below) or `gh`, which
the model is expected to use when it is installed. Either way you can list,
search, read, diff, and check CI status on pull requests in one conversation. What is exclusive is the built-in GitHub MCP server, which needs no token or extension setup; when `gh` is installed, the model mostly uses `gh`, which any agent with a shell can also run.

> **Note:** When `gh` is on PATH, Copilot CLI omits the PR read tools (`list_pull_requests`, `search_pull_requests`, `pull_request_read`) and the model is expected to use `gh`
> instead, e.g. `gh pr list`, `gh pr diff <n>`, `gh pr checks <n>`. To call the MCP tools,
> start the session with `--add-github-mcp-tool=<name>` for every GitHub MCP tool you need (it replaces the default set, so include default ones you still use), or `--enable-all-github-mcp-tools`, which also enables write tools.

## When to Use

# IDE ↔ CLI Switching

## Why This is Copilot-Exclusive

GitHub Copilot exists in **both VS Code and the terminal** under a single subscription and
unified platform. You can start a conversation in VS Code's Copilot Chat, switch to the CLI
for batch automation, and return to VS Code for visual debugging — all with the same model
access, same MCP servers, and same GitHub integration. Claude Code can connect to an IDE from the terminal, but Copilot is one product with native chat in both VS Code and the CLI.

## When to Use

- Visual tasks (diffing, debugging UI, extension-based tooling) → VS Code
- Batch operations, automation, scripting → CLI
- Large refactors that benefit from both visual review and automated execution

# Knowledge Curator

Not every useful insight belongs in a one-off chat. Knowledge Curator turns repeated lessons from
session history into maintainable project guidance so future sessions start from better defaults.

## Why This is Copilot-Exclusive

Copilot CLI gives you three building blocks that work well together:

- **Session artifacts** for saving structured notes during a task
- **`/resume`** for continuing a past session with its artifacts and SQL state
- **`session_store` search** for finding prior discussions and patterns later

The key constraint matters: `session_store` is **read-only historical memory**, not a writable

# MCP Builder

`mcp-ecosystem` helps you install and configure existing servers. This skill is for when
you need to **build a new MCP server** for your own domain, APIs, or internal tools.
Copilot CLI makes that loop faster with native MCP management commands and workspace/user config
surfaces.

## Why This is Copilot-Exclusive

Copilot CLI has a practical MCP authoring loop built around:

- `copilot mcp add` — quick user-level server registration
- `copilot mcp list` / `copilot mcp get` — inspect what Copilot will load
- shared config paths such as workspace `.mcp.json`

# MCP Server Ecosystem

## Why This is Copilot-Exclusive

Copilot CLI ships with a **built-in GitHub MCP server** providing 20+ tools for Issues, PRs,
Actions, code search, and repository management — zero configuration required (with `gh` on PATH,
only a small default subset is exposed and the model is expected to use `gh` for the rest). Beyond that, it
has a practical MCP management flow through `copilot mcp add`, `copilot mcp list`,
`copilot mcp get`, user config at `~/.copilot/mcp-config.json`, workspace config in `.mcp.json`,
and plugin-provided MCP servers. Claude Code supports MCP but has no built-in GitHub server and a
different configuration workflow.

## When to Use

# Multi-Model Strategy

## Why This is Copilot-Exclusive

Copilot CLI provides a **broad model selection** that can be switched at any time via the
`/model` command or per-agent via the `model` parameter. This lets you mix premium review
models, code-focused implementation models, and fast/cheap exploration models in one workflow
instead of forcing every step through the same model family.

## When to Use

- Deciding whether Copilot Auto should handle model choice or whether to override it manually
- Matching model strengths to task requirements
- Optimizing cost for high-volume operations (use cheaper models for exploration)

# Plan Mode Mastery

## Why This is Copilot-Exclusive

Copilot CLI has a **dedicated Plan Mode** activated by Shift+Tab that fundamentally changes
how you interact with the agent. Instead of executing immediately, Copilot creates a structured
plan with SQL-backed todo tracking, presents it in the terminal for review, and lets you choose
between interactive execution, autopilot, or fleet mode. Claude Code also has a plan permission mode;
Copilot's differs in linking the plan to SQL todos and to the autopilot/fleet hand-off.

> **Using another tool?** This skill describes Copilot CLI's own features (Plan Mode, the
> `exit_plan_mode` tool, SQL todos, Autopilot, Fleet). Cursor, Antigravity, and Claude Code do not
> have these, so there use only the general ideas — plan first, track steps, checkpoint — and
> ignore the tool-specific commands.

# Scope Guard

Scope Guard is a Copilot-native way to reduce blast radius. It combines explicit file ownership,
prompt-level boundaries, and approval checkpoints so the agent treats one area as writable and
everything else as read-only unless you reopen the scope.

## Why This is Copilot-Exclusive

Copilot CLI now has native `preToolUse`/`postToolUse` hooks that can allow/deny tool calls (see
[`guides/hooks-to-github-actions.md`](../../../guides/hooks-to-github-actions.md)), but scope-guard
is still the right pattern when you want a boundary enforced through the planning/approval flow
itself rather than a separate hook script. It combines several useful primitives:

- **Plan Mode approval** before execution starts

# Session SQL Database Management

## Why This is Copilot-Exclusive

Copilot CLI includes a **built-in SQLite database per session** accessible via a native `sql`
tool. It comes with pre-built `todos` and `todo_deps` tables and supports creating any custom
tables you need. This structured data layer enables proper task tracking, batch processing, and
state management — all queryable with SQL. Claude Code has no database; state management is
limited to reading/writing files or keeping everything in the conversation context.

## When to Use

- Tracking progress on multi-step tasks with dependencies
- Batch-processing items (issues, files, test cases) with status tracking

# Stack Detector

## Why This is Copilot-Exclusive

This skill is specific to the **everything-copilot-cli collection**: the recommendation table
maps detected technologies to skill and rule file paths that only exist in this repository.
Other AI agents can also inspect file systems, but this skill's value is the curated mapping
to this specific collection's skills and rules — not the file-scanning mechanics itself.

## When to Use

- At the start of a session on an unfamiliar codebase, before or alongside `context-prime`
- When you want focused recommendations for which skills and rules apply to this project
  (`context-prime` loads broad context; `stack-detector` targets specific recommendations)

# Sub-Agent Sandboxing

Sub-Agent Sandboxing protects the main workflow from delegated tasks that spiral, retry
indefinitely, or make changes in the wrong environment. It complements file-scope controls by
adding runtime guardrails around how a sub-agent is allowed to execute.

## Why This is Copilot-Exclusive

This pattern depends on Copilot CLI's delegated-agent workflow: separate `task()` execution lanes,
background lifecycle management, approval checkpoints, and the ability to route risky work into a
different checkout or environment before merging it back.

## When to Use

# Task Intake Router

Copilot CLI gives you multiple execution paths: interactive mode, Plan Mode, Autopilot,
`task` agents, `/fleet`, background delegation, and per-agent model selection.
This skill turns an incoming request into an explicit routing decision so you do not
default to the wrong mode out of habit.

## Why This is Copilot-Exclusive

The value is not generic triage. The value is mapping work onto **Copilot CLI primitives**
that can be combined in one session:

- **Plan Mode** for structured decomposition
- **Autopilot** for execution after approval

# Team Planner (Copilot-Native)

A Copilot CLI-native redesign of the “harness meta-skill” concept.

It does **not** assume Claude Code primitives like TeamCreate/TaskCreate exist. Instead, it uses
Copilot CLI’s actual primitives:

- `task` tool (agent types: `explore`, `task`, `general-purpose`, `code-review`, `security-review`, `research`, `rubber-duck`)
- `/fleet` for parallel sub-agent execution
- SQL **session database** for tracking (`sql` tool)
- `read_agent` / `write_agent` for monitoring and follow-ups

The lead planner acts as the **conductor**: it assigns ownership, coordinates sequencing,
and decides when a second model should challenge or review another agent's output.

# Token Cost Optimizer

Token Cost Optimizer is a proactive cost-control skill for GitHub Copilot. It helps you reduce
metered usage before and during a task by choosing the right model path, cutting unnecessary
context, and avoiding parallel work that burns credits without enough payoff.

## Why This is Copilot-Exclusive

GitHub Copilot now exposes cost-sensitive control surfaces that matter directly in the CLI:

- **Model pricing** for token-based usage across Copilot models
- **Premium request multipliers** that vary by model and feature surface

This skill focuses on Copilot-native levers such as `/model`, Auto model selection, `/compact`,

# API and Interface Design

Define the contract before the implementation. This skill is for **public or cross-team interfaces**
where downstream consumers can depend on every observable behavior, including the ones you did not
mean to promise.

## When to Use

- Designing a new public HTTP API, CLI command, webhook, SDK surface, or plugin contract
- Changing an existing interface that other teams, tools, or customers already consume
- Clarifying breaking-change policy before implementation starts
- Auditing a CLI or SDK that already shipped — see "Audit mode" below
- Tightening the interface section of `spec-driven-development` for a compatibility-sensitive feature

# Code Review

## When to Use

- Reviewing pull requests before merge
- Auditing code changes after a feature branch is complete
- Self-reviewing your own changes before committing
- Investigating code quality concerns raised by teammates

## Prerequisites

- Changes are committed or staged in git
- Access to the repository and its test suite
- Understanding of the project's coding standards

# Context Engineering

## When to Use

- Delegating a complex task to an AI agent
- An agent keeps repeating the wrong approach
- Agent quality drops as the context grows longer
- Designing a pipeline where multiple agents collaborate

> Difference from `context-prime` (Copilot-specific):
>
> - `context-prime`: loads live project context at session start
> - `context-engineering`: structures the best possible information for a specific task

# C++ Debugging

`systematic-debugging` gives you the language-neutral method. This skill adds the
native C++ toolchain and runtime techniques that matter once the bug involves
crashes, corrupted memory, UB, or platform-specific debugger state.

## When to Use

- A C++ process crashes with a segmentation fault, access violation, or abort
- The bug depends on object lifetime, ownership, or move/copy behavior
- Behavior changes between debug and release builds
- AddressSanitizer, UndefinedBehaviorSanitizer, or a debugger is needed to see the failure clearly
- A native test hangs, deadlocks, or corrupts memory without a clear stack trace

# Deprecation and Migration

## When to Use

- API/함수를 제거하거나 교체할 때
- 라이브러리 또는 패턴을 마이그레이션할 때
- 레거시 코드를 점진적으로 제거할 때
- Breaking change를 포함한 메이저 버전 릴리즈 준비

> 코드는 자산이 아닌 **부채**다. 유지해야 할 코드가 많을수록 비용이 증가한다.

## Prerequisites

- 현재 사용처 파악 (`grep -rn "deprecated_api"`)

# Diagnose

Diagnose is for problems that are still poorly shaped. Before deep debugging, build the smallest
feedback loop that proves whether each change helps or hurts. A fast loop usually does more for bug
finding than another round of guesswork.

## When to Use

- The symptom is real, but the shortest reliable repro is still unclear
- A bug, regression, or performance issue needs a faster test loop before fixing
- Multiple causes seem plausible and you need to rank them instead of chasing all of them
- The system is large enough that targeted instrumentation beats broad logging

## When NOT to Use

# Fix Build Errors

## When to Use

- Build or compilation fails after code changes
- CI pipeline reports build failures
- TypeScript, ESLint, or other static analysis errors
- Dependency resolution failures after package updates
- Build works locally but fails in CI (or vice versa)

## Prerequisites

- Access to the build command and its output
- The project's build toolchain is installed

# Fix GitHub Issue

## When to Use

- You have a GitHub Issue number and want to resolve it from scratch
- Debugging a reported bug with a clear reproduction case
- Picking up an issue from the backlog and implementing the fix
- Fast-track for "good first issue" or well-scoped bug reports

**Differentiation from `github-issue-triage`**: This skill *fixes* issues (code changes, tests,
PR). `github-issue-triage` is for *organizing and classifying* issues in bulk.

## Prerequisites

# Implement

A structured five-step loop for turning a specification (PRD, issue, or design doc) into
committed, reviewed code. Complements [`tdd-workflow`](../tdd-workflow/SKILL.md) (which focuses
on the Red→Green→Refactor micro-cycle) and
[`verification-before-completion`](../../workflow/verification-before-completion/SKILL.md)
(which enforces proof before claiming done). This skill governs the **macro** flow: from
spec to commit.

## When to Use

- You have a PRD, issue, or spec and need a repeatable path from "start" to "merged"
- You want to enforce `/review` and type-checking as gates before every commit
- You need a structured sequence that doesn't skip test coverage or review under deadline pressure

# Improve Codebase Architecture

Use this skill when local cleanup is not enough and the problem is architectural shape:
too many shallow modules, leaky seams, or a design that is hard to test through the
public interface.

## When to Use

- The codebase is correct enough to run, but hard to extend safely
- Understanding one concept requires bouncing across too many tiny modules
- Tests are brittle because the interesting behavior leaks across current seams
- A refactor candidate needs architectural reasoning before code changes start

## When NOT to Use

# NestJS + Prisma Combo Skill

## When to Use

- Setting up Prisma in a NestJS project for the first time
- Implementing a data access layer using Prisma as the ORM
- Writing unit tests for services that depend on Prisma
- Debugging connection pooling or client lifecycle issues

## Workflow

### 1. PrismaService Setup

```typescript

# Next.js + Prisma Combo Skill

## When to Use

- Setting up Prisma in a new Next.js App Router project
- Reviewing or refactoring data-fetching logic in Server Components
- Debugging Prisma client instantiation issues (hot-reload client explosion)
- Implementing type-safe CRUD operations across Server Actions and API routes

## Workflow

### 1. Singleton Client Setup

Ensure Prisma client is instantiated only once across hot reloads:

# Performance Optimization

Do not optimize by instinct. Start with measurement, change one thing at a time, and confirm the
result with the same metric you used at the beginning.

## When to Use

- A user or monitoring system reports a slow page, endpoint, query, or job
- A new feature needs a performance baseline before release
- You suspect a regression and need evidence before changing code
- A hot path is doing real work at scale and latency or throughput matters

## When NOT to Use

# PR Multi-Perspective Review

## When to Use

- Before merging any significant PR — to catch issues a single reviewer might miss
- When the PR touches multiple concerns (UI + API + infra all at once)
- For PRs with external impact: public API changes, auth logic, billing flows
- As a pre-merge gate in high-stakes or regulated environments

**Differentiation from `code-review`**: `code-review` is a single technical pass.
This skill runs **6 distinct lenses** simultaneously, surfacing business, quality, and
operational issues that a developer reviewer alone would not flag.

## Prerequisites

# Prototype

A prototype is disposable code that answers a question faster than debate. Keep it close
to the real area, make it easy to run, and optimize for learning rather than polish.

## When to Use

- The user says "prototype this", "try a few designs", or "let me play with it"
- A state model or workflow is hard to reason about on paper
- You need several UI directions before picking one
- The fastest way to answer the question is to build a small runnable artifact

## When NOT to Use

# React + Vitest Combo Skill

## When to Use

- Setting up Vitest in a React (Vite-based) project for the first time
- Writing component tests using React Testing Library
- Mocking context providers, hooks, or module dependencies in tests
- Configuring coverage thresholds for CI enforcement

## Workflow

### 1. Setup

```bash

# Receiving Code Review

Receiving code review requires technical evaluation, not emotional performance. This skill governs
what happens **between** getting feedback and typing the first edit — not how to produce a review.

**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over
social comfort.

## When to Use

- You just received review comments (from a human, `code-review`, `review`, or
  `pr-multi-perspective-review`) and are about to act on them
- Feedback includes multiple items and some are unclear or only partially understood
- A suggestion seems plausible but you have not yet checked it against this codebase

# Refactor & Clean Code

## When to Use

- Code is correct but hard to read, modify, or extend
- Duplicated logic exists across multiple files
- Functions or classes have grown too large
- Preparing code for a new feature that requires structural changes
- After a rapid prototype that needs production-quality cleanup

## Prerequisites

- Existing tests that cover the code to refactor (add tests first if missing)
- All tests passing before starting

# Review

Review compares the diff between `HEAD` and a pinned git reference along two deliberately separate
axes:

- **Standards** - does the change follow this repository's documented conventions?
- **Spec** - does the change match the originating issue, PRD, or spec?

Run the two axes in separate agent sessions in parallel, then report them side by side. Keeping them
independent prevents coding-standard findings from hiding scope or requirement mismatches, and vice
versa.

## When to Use

# Skill Creator

A meta-skill that produces new SKILL.md files. Describe what the skill should do,
and this skill generates a complete, convention-compliant SKILL.md file ready to commit.

## When to Use

- You want to add a new skill but are unsure of the required structure
- You have a workflow in mind and want to formalize it as a skill
- You are migrating a skill from another source and need to adapt it to this repo's format
- You need to translate an external slash-command or Claude-oriented pattern into Copilot-native primitives
- Bootstrapping multiple skills quickly for a new domain

## When NOT to Use

# Source-Driven Development

AI agents can confidently generate outdated or deprecated framework code. Source-driven
development replaces memory-based implementation with a repeatable loop:
**detect the version, fetch the official source, implement from that source, then
capture the reference in durable notes**.

## When to Use

- Writing framework-specific code you have not touched recently
- Using a library that changed versions since the last time you used it
- Implementing middleware, routing, configuration, hooks, or SDK integration
- Seeing deprecation warnings or suspecting API drift
- Asking an AI agent to write code where stale training data could mislead it

# Spec-Driven Development

## When to Use

- 구현에 2시간 이상 걸리는 기능을 시작할 때
- 요구사항이 불명확한 기능을 작업할 때
- 다른 팀이 소비하는 인터페이스를 설계할 때
- `/create-prd` 실행 후 제품 스펙을 기술 스펙으로 전환할 때
- Copilot의 Plan Mode에 진입하기 전 사전 정의가 필요할 때

## DO NOT use when

- 범위가 명확한 단순 버그 수정
- 복사 변경이나 사소한 UI 조정