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 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.

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. Want a copy-paste beginner lab? Try the Beginner Skills Tutorial.

---

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-errors	Diagnose and resolve build failures
improve-codebase-architecture	Use when a codebase feels hard to change, test, or navigate — surface architectural friction and walk one deeper-module candidate into a concrete refactoring direction
performance-optimization	Measure first, isolate bottlenecks, and prove performance improvements
pr-multi-perspective-review	6-lens PR review: PM / Dev / QA / Security / DevOps / UX
review	Compare changes against a pinned git reference on two separate axes: repository standards and originating spec
receiving-code-review	Verify review feedback against the codebase and push back with technical reasoning instead of performative agreement
prototype	Use when a design question is still fuzzy — build a throwaway logic or UI prototype that answers one question fast and is meant to be deleted or absorbed
refactor-clean	Remove dead code, simplify logic safely
diagnose	Build the fastest feedback loop first, rank the leading hypotheses, and instrument only what narrows the search
source-driven-development	Verify framework and library APIs against current official docs before implementing
spec-driven-development	Write a technical spec before coding — defines interface, structure, and boundaries first
context-engineering	Optimize information delivery to AI agents — minimize noise, maximize signal
deprecation-and-migration	Safely remove old APIs and migrate to new patterns with a 3-phase process
skill-creator	Describe a workflow → get a SKILL.md scaffolded in minutes
systematic-debugging	4-phase root cause analysis (reproduce → isolate → hypothesize → verify) before fixing
zoom-out	Step one abstraction level up from a local code detail, map owners and callers, and restate the system in project vocabulary

Combo Skills (activate when two technologies are used together):

Skill	Description
nextjs-prisma	Type-safe data fetching and Server Actions for Next.js App Router + Prisma projects
react-vitest	Component testing setup and patterns for React + Vitest projects
nestjs-prisma	PrismaService singleton, repository pattern, and unit testing for NestJS + Prisma

Documentation Skills (6)

Skill	Description
add-to-changelog	Keep a Changelog format, semver version sync
doc-update	Sync docs when implementation changes
document-generate	Create missing Diataxis documentation from scratch for a feature, module, or project
api-documentation	Generate and maintain API docs from source
code-tour	Generate VS Code CodeTour .tour files for codebase onboarding
architecture-decisions	Document hard-to-reverse technical decisions as Architecture Decision Records (ADRs)

Security Skills (12)

Skill	Description
agent-owasp-check	Audit an AI agent system against the OWASP Agentic Security Initiative Top 10
agent-governance	Add policy controls, approval gates, trust scoring, and append-only audit trails to agent systems
agent-supply-chain	Verify integrity manifests, detect tampering, and enforce promotion gates for agent plugins and MCP bundles
evaluate-repository	7-dimension scorecard (1–10) with remediation plan
gha-security-review	Review GitHub Actions workflows for exploitable CI/CD attack paths such as pwn requests, expression injection, and credential escalation
security-scan	OWASP Top 10 + dependency audit
secret-detection	Find hardcoded secrets in source and git history
input-validation	Prevent injection attacks (SQL, XSS, CSRF)
security-bounty-hunter	Bug-bounty-perspective vuln hunting with proof-of-concept steps
pr-security-review	Automated PR security analysis — auth, injection, secrets, OWASP Top 10
threat-model-analyst	Build or update a STRIDE-A threat model with trust boundaries, abuse cases, and change-focused findings
mcp-implementation-security-review	Review the source code of an MCP server or client implementation for auth, session, rate-limit, schema-validation, and SDK-usage vulnerabilities, with file/line-cited findings

Workflow Skills (26)

Skill	Description
commit-workflow	Conventional commits + emoji, atomic split guidance
conventional-branch	Create or validate Git branch names that follow a conventional type/description format before parallel work starts
doubt-driven-development	Challenge a non-trivial decision with a fresh-context adversarial review before it stands
release	tag → GitHub Release → publish (npm/PyPI/Docker)
finishing-a-development-branch	Verify tests, detect worktree state, then present merge/PR/keep/discard options and execute cleanup
verification-before-completion	Prove a task is done with fresh command output before claiming success
sprint-workflow	Full sprint: Think → Plan → Build → Review → Test → Ship → Monitor
deployment-canary	Post-release canary checks, rollback thresholds, and promote/hold decisions
security-audit	OWASP Top 10 + STRIDE threat modeling
sprint-retro	Data-driven retros using git metrics
cost-audit	Audit AI inference token spend and recommend model/prompt optimizations
github-actions-efficiency	Audit GitHub Actions workflows for CI minutes, caching, concurrency, trigger scope, and wasted runs
council	Convene a 4-voice adversarial decision council for high-stakes choices
deep-research	Systematic multi-source research with structured synthesis
grill-me	Stress-test a plan with one-question-at-a-time interrogation until assumptions, dependencies, and risks are explicit
grill-with-docs	Stress-test a plan against existing docs, glossary terms, and ADRs before implementation begins
handoff	Create a portable markdown handoff for the next session, agent, or machine without duplicating existing artifacts
implementation-review	Compare a delivered diff against the original task spec and produce actionable follow-up feedback
interview-me	Discover what the user actually wants before writing a plan, spec, or code
llm-wiki	Use when research or domain knowledge keeps getting rediscovered across sessions — build a supplementary markdown wiki that compounds synthesized knowledge without replacing GitHub or committed project guidance
outside-voice	Get an independent second opinion before, during, or after implementation with challenge, consult, and review modes
prompt-optimizer	Rewrite rough prompts into a finished, copy-pasteable prompt for chat-based LLMs with no placeholders
to-issues	Break a plan, spec, or PRD into thin dependency-aware issues that each deliver a verifiable vertical slice
triage	Use when a single issue needs structured triage — classify it, reproduce if needed, request missing information, and leave a durable brief or close-out note in the tracker
using-git-worktrees	Create isolated working directories for parallel branch work without recloning the repo
wayfinder	Use when a task is too large or ambiguous to finish in one session — build a destination-centric plan with breadth-first triage, an explicit Deferred section, and a confirmation gate before implementation starts

Product Skills (5)

Skill	Description
create-prd	JTBD-grounded PRD template
feature-prioritization	Impact × Confidence × Effort matrix
opportunity-solution-tree	Teresa Torres' OST framework
launch-strategy	Alpha → Beta → GA launch checklist
product-capability	Transform requirements into SRS-style capability specs with ACs and traceability

Testing Skills (6)

Skill	Description
test-coverage	Identify gaps and write targeted tests
e2e-testing	E2E test scaffolding for critical paths
eval-harness	Build LLM pipeline evaluation suites with SQL-tracked test cases
qa-review	Review QA strategy across test pyramid balance, test quality, reliability, and CI defect reporting
browser-devtools	Verify frontend behavior at runtime — DOM validation, network inspection, performance profiling
ux-audit	Structured usability review — quick scan (6 Krug checks) or deep audit (15-dimension Jobs/Ive framework)

Content & Marketing Skills (3)

Skill	Description
ai-visibility	GEO optimization: llms.txt, AI crawler access
content-strategy	Keyword research, topic clusters, content calendar
seo	Technical SEO audit: Core Web Vitals, structured data, crawl issues

Rules

Coding rules and guidelines, organized by scope:

• Common Rules — Universal best practices (error handling, logging, naming conventions)
• Language-Specific Rules — TypeScript, Python, Go, C#, Java
• Framework-Specific Rules — Next.js, React, Vue, Prisma, Playwright, NestJS, Cloudflare Workers, Vitest

Orchestration

The Multi-AI Orchestration system (see dedicated section below).

---

Guides

Guide	Description
Quick Start	Get up and running in 5 minutes
Shortform Guide	Concise reference for everyday use
Longform Guide	Deep dive into every feature
Security Guide	Security best practices and scanning
Copilot Exclusive Features	Features only available in Copilot CLI
Copilot vs Claude Code	Compare strengths, tradeoffs, and when to use each tool
Migration from Claude Code	Step-by-step migration path with concept mapping
Native Hooks + GitHub Actions	Complement Copilot's in-session hooks with Git Hooks / Actions / Prompt Guards
Orchestration Guide	Multi-AI orchestration patterns and setup
Skill Writing Best Practices	Write trigger-first descriptions that actually fire
Skill Testing Guide	Test trigger accuracy and output quality for promptware, with Promptfoo as an optional output-quality supplement
QA Agent Guide	Design QA agents that catch real bugs via boundary-crossing comparison
Beginner Skills Tutorial (EN)	Copy-paste lab to feel the difference between plain and skill-guided prompting
Beginner Skills Tutorial (KO)	Korean version of the beginner hands-on skills lab
Beginner Skills Tutorial (JA)	Japanese version of the beginner hands-on skills lab
Beginner Skills Tutorial (ZH)	Chinese version of the beginner hands-on skills lab

All guides are in the guides/ directory.

---

Multi-AI Orchestration ★

Two layers — the distinction matters.

Copilot-native: GitHub MCP, /model switching, Plan Mode, Autopilot, Fleet, Background Agents, and the session SQL database are built into Copilot CLI.

Community pattern: cross-tool orchestration with Claude Code, Codex CLI, Cursor CLI, and Antigravity CLI (agy) is documented in this repository as a shell/MCP/pipeline workflow pattern. It depends on those external CLIs being installed and is not an official built-in Copilot feature.

The Idea

No single AI is best at everything. Claude excels at reasoning, Codex at rapid implementation, Cursor at repo-aware multi-file editing, Antigravity (agy) at multi-model/multimodal analysis, and Copilot at GitHub integration. What if you could use all of them from one place?

┌────────────────────────────────────────────────────────────────┐
│                       GitHub Copilot CLI                        │
│                   (Orchestrator / Meta-Hub)                     │
├────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌────────────┐ │
│  │ Claude Code│  │  Codex CLI │  │ Cursor CLI │  │ Antigravity│ │
│  │ (Reasoning)│  │(Impl./Gen.)│  │(Repo edits)│  │(agy·multi- │ │
│  │            │  │            │  │            │  │model/vision│ │
│  └────────────┘  └────────────┘  └────────────┘  └────────────┘ │
│                                                                  │
└────────────────────────────────────────────────────────────────┘

5 Orchestration Patterns (Patterns 1–5: cross-AI)

Pattern	How It Works	Best For
Shell Invocation	Copilot spawns other CLIs via shell commands	Simple delegation
MCP Bridge	Connect agents via Model Context Protocol servers	Structured tool sharing
Message IPC	Inter-process communication via files/pipes	Real-time collaboration
Pipeline	Chain agents sequentially — output of one feeds the next	Multi-stage workflows
Agent Council	Multiple agents deliberate and vote on decisions	Critical decisions

6 Additional Patterns (Intra-team orchestration, Patterns 6–11)

Pattern	How It Works	Best For
Fan-Out Parallel	Dispatch independent subtasks simultaneously	Batch operations
Producer-Reviewer	Iterative produce→review feedback loop	Artifact refinement
Hierarchical Delegation	Nested orchestrators (root→domain→specialists)	Large multi-domain tasks
Iterative Refinement	Self-correction loop with measurable exit criteria	Quality-sensitive generation
Review Trio	3-way review for non-PR artifacts (RFC, schema, architecture)	Pre-publish review
Sub-Agent Sandboxing	Constrain delegated agents with worktree, scope, and permission boundaries	High-safety delegation

Tool Specialization

Each AI tool in the orchestration ecosystem has a distinct specialization. Copilot CLI acts as the coordinator that brings them together:

AI Tool	Specialization	Role in the Workflow
Copilot CLI	GitHub integration · multi-model flexibility · orchestration	Meta-hub / coordinator
Claude Code	Deep reasoning · large-context analysis	Reasoning specialist
Codex CLI	Rapid code generation · boilerplate	Implementation specialist
Cursor CLI	Repo-aware multi-file editing · IDE-shared context · headless JSON/CI	Repo-aware editor
Antigravity CLI (agy)	Multi-model backend (Gemini 3.x/Claude/GPT-OSS) · multimodal · Google grounding · background subagents	Multi-model / multimodal specialist

References & Proven Frameworks

The orchestration system is informed by real-world multi-agent frameworks:

• microsoft/autogen — Microsoft AutoGen framework
• crewAIInc/crewAI — CrewAI role-based agents
• langchain-ai/langgraph — LangGraph state machines
• geekan/MetaGPT — MetaGPT multi-agent SOP
• openai/swarm — OpenAI Swarm patterns

See the full Orchestration Guide for implementation details.

---

What Makes Copilot CLI Unique

Copilot CLI is purpose-built around your GitHub workflow. Here's what you get out of the box:

Capability	Details
GitHub-Native MCP	Issues, PRs, Actions, and code search — zero extra setup
20+ Model Selection	Switch between GPT, Claude, Gemini families (example tiers) per task — check /model for the current roster
IDE ↔ CLI Context Sharing	Seamless switching between VS Code, JetBrains, and the terminal
Plan Mode	Structured text planning with approval workflow before any code is written
Autopilot Mode	Autonomous task execution with guardrails (Experimental)
Background Agents	Delegate to cloud agents via & / /delegate; resume with /resume
Fleet Mode	Parallel agent execution — split work across multiple agents simultaneously
Session SQL Database	Built-in SQLite per session for structured state and todo tracking
Cross-Session Memory	Search prior session history with session_store and /resume
LSP Integration	Language Server Protocol for precise, symbol-aware code intelligence
Multi-AI Orchestration	Coordinate Claude Code, Codex, Cursor CLI, Antigravity (agy) from a single hub (community pattern)

See the Copilot Exclusive Features guide for a deep dive into each capability.

---

Migration from Another Tool

Coming from another AI coding tool? The skill format is nearly identical, so migration is straightforward:

CLAUDE.md rules        →  .github/copilot-instructions.md
.claude/commands/      →  .github/skills/
.claude/settings.json  →  mcp-configs/ & contexts/
Claude Code Hooks      →  Native Copilot Hooks + Git Hooks / GitHub Actions / Prompt Guards

The migration script automates most of the work:

node scripts/migrate-from-claude.js /path/to/your/project

See the full Migration Guide and Hooks Guide.

---

Contributing

Contributions are welcome! Here's how you can help:

1. Add agents — Define new agent roles in agents/
2. Create skills — Build reusable workflows in skills/
3. Write rules — Add coding guidelines in rules/
4. Share orchestration patterns — Contribute to orchestration/
5. Improve guides — Enhance documentation in guides/
6. Add examples — Show real-world setups in examples/

Development

# Install dependencies
npm install

# Validate configs
npm run validate

# Run tests
npm test

# Lint markdown
npm run lint:md

Please read the existing guides and follow the established patterns before submitting a PR.

---

License

MIT © Everything Copilot CLI Contributors

---

_{Built for the GitHub Copilot CLI community}

_{Acknowledges the pioneering work of everything-claude-code and awesome-claude-code}