Everything Copilot Cli

everything-copilot-cli

A Copilot-first guide & configuration system for GitHub Copilot CLI Agents · Skills · Rules · Multi-AI Orchestration

한국어 · 日本語 · 中文

---

What is this?

everything-copilot-cli is a Copilot-first operating kit for AI-assisted software delivery on GitHub.

This repository is built around three ideas:

• GitHub as the system of record — Issues, PRs, Actions, and code search are first-class inputs, not afterthoughts
• Copilot CLI as the orchestration hub — the coordination layer that routes tasks to the right model or agent and synthesizes results back through GitHub
• Model choice as a routing decision — GPT, Claude, and Gemini each have strengths inside Copilot; external specialists like Codex CLI can be orchestrated when a separate tool is the better fit

The result is a curated collection of agents, skills, rules, MCP configurations, and orchestration patterns — portable where possible, Copilot-native where it matters.

> See [Multi-AI Orchestration](#multi-ai-orchestration-) for how this repo's community patterns coordinate Claude Code, Codex CLI, Cursor CLI, and Antigravity CLI (agy) as external specialist workers.

---

Design Principles

| Principle | What it means in practice | |-----------|--------------------------| | GitHub as system of record | Every workflow starts and ends in GitHub. Issues are task inputs. PRs are agent outputs. Actions are the observability layer. | | Copilot CLI as orchestration hub | Copilot does not just generate code — it coordinates specialists. Claude reasons deeply, Codex generates fast, Cursor edits repos with IDE-shared context, Antigravity (agy) covers multi-model/multimodal analysis; Copilot routes and synthesizes. | | Model choice is routing, not loyalty | No single model wins every task. Skills and patterns in this repo are designed to route work to the strongest model for each subtask. | | Portable core, Copilot-native layer | Most skills work in any agentskills.io-compatible runtime. Copilot-exclusive capabilities are clearly separated in skills/copilot-exclusive/ so you always know what depends on native Copilot features. |

---

Why Copilot CLI?

Three capabilities make Copilot CLI a strong hub for multi-AI development workflows:

GitHub-native access — Copilot CLI ships with a built-in GitHub MCP server. Issues, PRs, Actions logs, and code search are structured tool calls, not scraped text. No extra GitHub integration layer is required.

Multi-model routing — Within Copilot CLI you can switch between model families such as GPT, Claude, and Gemini with /model or per-agent overrides in the same session. Use a premium reasoning model for architecture, a fast model for boilerplate, and a cheaper model for triage.

Orchestration primitives — Plan Mode, Autopilot, Fleet, Background Delegation, and the built-in SQLite session database give you building blocks for complex multi-agent workflows. When a separate specialist tool is the better fit, this repository's orchestration patterns show how to delegate to Codex CLI, Claude Code, Cursor CLI, or Antigravity CLI (agy) and bring the result back through GitHub.

Full capability reference (11 features)

| # | Advantage | Description | |---|-----------|-------------| | 1 | GitHub-Native Integration | Issues, PRs, Actions, code search — all via built-in MCP. No extra setup. | | 2 | 20+ Model Selection | GPT, Claude, Gemini families (example tiers, not exhaustive) — pick the right model per task. Check /model for the current roster since it changes over time. | | 3 | IDE ↔ CLI Seamless Switching | Same Copilot context in VS Code, JetBrains, and the terminal. | | 4 | Plan Mode | Structured text planning — Copilot builds a step-by-step implementation plan before writing any code. | | 5 | Autopilot Mode | Autonomous task execution with guardrails. (Experimental) | | 6 | Background Agents | Delegate to cloud Copilot agents via & or /delegate; resume anytime with /resume. | | 7 | Fleet Mode | Parallel agent execution — split work across multiple agents simultaneously. | | 8 | Session SQL Database | Built-in SQLite per session for structured data, todo tracking, and state. | | 9 | Cross-Session Memory | Search and reuse prior session history via session_store. | | 10 | LSP First-Class Support | Language Server Protocol integration for precise code intelligence. | | 11 | Multi-AI Orchestrator | Orchestrate Claude Code, Codex, Cursor CLI, Antigravity (agy) from Copilot as the meta-hub (community pattern). |

---

Quick Start

Install one of the following plugins:

# Add this repository's marketplace
copilot plugin marketplace add drvoss/everything-copilot-cli

# Install the full collection (recommended)
copilot plugin install everything-copilot-cli@everything-copilot-cli

# Focused workflows only
copilot plugin install copilot-native-workflows@everything-copilot-cli

Choose only one: the full collection already includes the nine focused workflow skills, so installing both causes name overlap. Plugins install skills only. To also seed instructions, rules, contexts, and agents into a target project, keep using the clone + setup flow:

# 1. Install GitHub Copilot CLI
npm install -g @github/copilot

# 2. Clone this repository
git clone https://github.com/drvoss/everything-copilot-cli.git
cd everything-copilot-cli

# 3. Verify the cloned repository
npm install && npm run setup

# 4. Install the collection into your project
npm run setup -- --target /path/to/your-project

The first command runs a quick verification for the documented clone + setup flow. The second command is also run from this repository root and installs into the project path passed through --target.

During step 4, setup offers these profiles:

| Profile | Recommended? | Installs | |---|---|---| | minimal | For light touch onboarding | .github/copilot-instructions.md only | | recommended | Yes | Starter instructions, agents, skills, and rules | | full | For advanced setups | Everything, including contexts | | custom | When you want full control | Lets you choose each component with explanations |

Setup writes project instructions to .github/copilot-instructions.md, installs custom agents to .github/agents/, project skills to .github/skills/, and rules to .github/copilot/rules/. The full profile also installs contexts to .github/copilot/contexts/.

This repository's npm run setup path is still the fastest way to install the full profile in one pass. If you only want to add or remove individual skills, GitHub Copilot CLI v1.0.72+ also supports native skill management:

# Install a skill from a local file into this repository
copilot plugins install --skill ./skills/development/fix-build-errors/SKILL.md --scope project

# Install a skill from a URL into this repository
copilot plugins install --skill https://example.com/path/to/SKILL.md --scope project

# Install a skill from a local directory
copilot plugins install --skill ./skills/development/fix-build-errors

# Remove an installed skill by name
copilot plugins remove --skill fix-build-errors

Use npm run setup when you want this repository's instructions, rules, contexts, agents, and skills installed together. Use the native copilot plugins install/remove --skill commands when you want to manage one skill at a time through the CLI. The --scope project flag is documented for file and URL installs into the repository; the directory example above intentionally omits that flag. Copilot also supports marketplace management and per-resource enable/disable controls; see the [plugin and marketplace lifecycle guide](guides/copilot-exclusive-features.md#plugin-and-marketplace-lifecycle).

Then open a terminal and start using Copilot CLI with the installed agents, skills, and rules:

# Start a session in your project directory
cd your-project
copilot

After copilot starts, you can quickly check whether the installation was picked up:

- The startup banner should mention your project custom instruction and show additional project skills and agents.
- `/instructions` should show the installed project instructions.
- `/skills` should show project skills, not just built-in ones.
- `/agent` should show custom agents such as `planner`.
- If you only see built-in skills and no project agents, the collection was not discovered in this repository yet.

# Use the planner agent (inside the session)
> Design a REST API for user management — use plan mode

# Run TDD workflow
> Add tests for the auth module using TDD

# Orchestrate multiple AIs
> Claude reasons architecture, Codex implements, Copilot reviews — delegate accordingly

> For detailed instructions, see the [Quick Start Guide](guides/the-quickstart-guide.md). > Want a copy-paste beginner lab? Try the [Beginner Skills Tutorial](guides/the-beginner-skills-tutorial.md).

---

Repository Structure

everything-copilot-cli/
├── agents/                        # Agent definitions (8 core agents)
│   ├── planner.md
│   ├── architect.md
│   ├── code-reviewer.md
│   ├── security-reviewer.md
│   ├── tdd-guide.md
│   ├── build-error-resolver.md
│   ├── doc-updater.md
│   └── refactor-cleaner.md
│
├── skills/                        # Reusable workflow skills (109 total)
│   ├── copilot-exclusive/         #   ★ Copilot-only skills (26)
│   ├── development/               #   Dev skills (25)
│   ├── documentation/             #   Doc skills (6)
│   ├── security/                  #   Security skills (12)
│   ├── testing/                   #   Test skills (6)
│   ├── workflow/                  #   Workflow skills (26)
│   ├── product/                   #   Product skills (5)
│   └── content/                   #   Content & GEO skills (3)
│
├── rules/                         # Coding rules & guidelines
│   ├── common/                    #   Universal rules (6)
│   ├── languages/                 #   Language-specific: TS, Python, Go, C#, Java, C++
│   └── frameworks/                #   Framework rules (8)
│
├── orchestration/                 # ★ Multi-AI Orchestration
│   ├── patterns/                  #   11 orchestration patterns
│   ├── configs/                   #   MCP bridge configs
│   ├── skills/                    #   Orchestration skills (9)
│   ├── templates/                 #   Reusable orchestrator templates
│   └── examples/                  #   Real-world examples (6)
│
├── guides/                        # 16 comprehensive guides
├── mcp-configs/                   # MCP server configurations (7 files; 6 configs + README)
├── examples/                      # Project-specific copilot-instructions
│   ├── nextjs-app/
│   ├── python-api/
│   ├── dotnet-webapp/
│   └── monorepo/
│
├── contexts/                      # Context presets
├── references/                    # Checklist & pattern references (14 files across root + subdirectories)
│   ├── github-actions-efficiency/ #   Actions efficiency audit references
│   ├── github-codespaces-efficiency/ # Codespaces efficiency guidance
│   ├── security-scan/             #   Stack-specific security guidance
│   ├── testing-patterns.md        # AAA structure, mocking, component/API/E2E patterns
│   ├── security-checklist.md      # OWASP Top 10, auth, input validation, security headers
│   ├── performance-checklist.md   # Core Web Vitals, frontend/backend optimization
│   ├── accessibility-checklist.md # WCAG 2.1 AA, keyboard nav, screen reader, forms
│   └── ecosystem-monitoring-playbook.md # Monitoring cadence, prompt archetypes, adopt/adapt/reject output contract
├── scripts/                       # Setup & migration tools
└── tests/                         # Test suite

---

Core Components

Agents (8 Core)

Pre-configured agent definitions — each with a specific role, system prompt, and tool set.

| Agent | Purpose | |-------|---------| | planner | Breaks tasks into structured plans with dependency tracking | | architect | Designs system architecture and component boundaries | | code-reviewer | Reviews code for bugs, logic errors, and security issues | | security-reviewer | Focused security audit with OWASP/CWE classification | | tdd-guide | Test-Driven Development workflow — red/green/refactor | | build-error-resolver | Diagnoses and fixes build/compilation errors | | doc-updater | Keeps documentation in sync with code changes | | refactor-cleaner | Identifies and executes safe refactoring opportunities |

Skills (109 Total · 8 Categories)

Reusable, composable workflows organized by category. All follow the agentskills.io spec.

★ Copilot-Exclusive Skills (26)

Skills that leverage capabilities unique to GitHub Copilot CLI:

| Skill | Description | |-------|-------------| | context-prime | Load project context at session start (README, file tree, commits, stack) | | session-management | Built-in SQLite for todo tracking and structured state | | plan-mode-mastery | Structured text planning with approval workflow | | autopilot-patterns | Autonomous execution with guardrails | | background-agent | Delegate to cloud agents via & / /delegate | | fleet-parallel | Parallel agent execution with /fleet | | github-code-search | Search GitHub's global code index for real implementation examples and use the results as grounded context | | github-pr-workflow | Full PR lifecycle via built-in GitHub MCP | | github-issue-triage | Bulk issue classification and triage | | github-codespaces-efficiency | Audit GitHub Codespaces startup time, machine sizing, prebuild scope, and spend without stripping required dev tools | | actions-debugging | Debug CI failures with native Actions access | | cross-session-memory | Search and resume prior session context | | copilot-memory | Review and curate repository-level Copilot memory shared across CLI, cloud agent, and code review | | knowledge-curator | Promote repeated lessons into durable project guidance | | mcp-builder | Build a new MCP server with config validation and hot-reload | | multi-model-strategy | Pick the right model per task | | mcp-ecosystem | Extend with custom MCP servers | | ide-switching | Seamless VS Code ↔ CLI context sharing | | scope-guard | Lock a task to a narrow writable surface and add explicit stop rules for risky work | | team-planner | Assemble specialist agent teams via SQL roster + /fleet dispatch | | agentic-engineering | Design 15-min task units, eval-first loops, and explicit I/O contracts | | stack-detector | Scan project tech stack and recommend relevant skills and rules from this collection | | task-intake-router | Route incoming work to the right mode, agent type, model, and delegation path | | ecosystem-intake | Convert curated ecosystem sources into adopt/adapt/reject backlog candidates | | sub-agent-sandboxing | Constrain delegated work with loop thresholds, circuit breakers, and sandbox escalation before accepting output | | token-cost-optimizer | Proactively reduce Copilot usage cost before large autonomous or parallel tasks |

Development Skills (25)

| Skill | Description | |-------|-------------| | api-and-interface-design | Define public APIs, CLIs, webhooks, or SDK contracts before implementation | | tdd-workflow | Red → Green → Refactor cycle | | code-review | Structured review with severity levels | | cpp-debugging | Use when a C++ failure involves memory lifetime, undefined behavior, native crashes, or debugger-only state — debug with symbols, sanitizers, and platform-native debuggers before patching symptoms | | fix-github-issue | Read issue → locate bug → fix → test → PR | | implement | Turn a PRD, spec, or set of issues into committed code via a five-step TDD → validate → review → commit loop | | `fix-build-e

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: drvoss
• Source: drvoss/everything-copilot-cli
• License: MIT

Install and usage instructions live in the source repository linked above.