GitHub Copilot Más Allá del Autocompletar

What's in this pack

GitHub Copilot in 2026 is not the 2021 product. The ghost-text completion you signed up for is now one tab in a larger surface: Copilot Chat (ask questions about the file or repo), Copilot Edits (multi-file refactors with diff preview), Copilot agent mode (lets Copilot plan, run shell commands, iterate on failing tests until they pass), Copilot Extensions (third-party skills you can @invoke), MCP servers (tool access via Model Context Protocol), and custom instructions (a project-scoped file Copilot reads every turn — same idea as CLAUDE.md or .cursor/rules).

Most devs paying $10–39/month touch the first two and stop there. This pack is for the developer who's ready to drop the autocomplete-only mental model: nine assets that turn Copilot into a real coding partner, with the same rigor you'd give Claude Code or Cursor.

Who this is for: a working developer with a Copilot Pro / Business / Enterprise seat, on VS Code or a JetBrains IDE, who has never opened .github/copilot-instructions.md and isn't sure what agent mode actually does.

Install in this order

1. GitHub Copilot — Official Customization Collection — Start at the source. The official github/awesome-copilot collection ships instructions, prompt files, skills, agentic workflows, and the customization patterns that GitHub itself maintains. Read the README, skim the categories. This is your reference index for everything else in the pack.
2. Awesome Copilot Agents — Instructions, Prompts & MCPs — The community-curated companion list. Where the official collection is conservative, this one is comprehensive: third-party agents, niche instructions, MCP server pairings, and patterns the docs don't cover yet. Bookmark; visit monthly.
3. ai-prompts — Prompt Rules for Cursor/Copilot/Cline — A multi-tool rules library. Even if you live in Copilot, ai-prompts has high-quality copilot-instructions.md templates organized by stack (Next.js, Python, Rust, Go). Copy the one that matches your repo, edit to taste, commit it to .github/.
4. lnai — Unified AI Config for Claude, Cursor, Copilot & More — If you use more than one AI coding tool (or your team does), stop maintaining four config files. lnai lets you define instructions once in a .ai/ directory and auto-syncs to .github/copilot-instructions.md, .cursor/rules/, CLAUDE.md, AGENTS.md, Gemini CLI, Codex. One source of truth.
5. RuleForge — Generate AI Assistant Rules from Repo — Don't write instructions from a blank page. RuleForge scans your repo (stack, conventions, file layout) and generates a starter copilot-instructions.md plus Cursor / Claude variants. Treat its output as draft v0; edit it; commit.
6. Caliber — Auto-Refresh CLAUDE.md and Rules — Instructions go stale the moment your tech stack drifts. Caliber regenerates Copilot instructions, CLAUDE.md, Cursor rules, and AGENTS.md from your current code on a schedule (or pre-commit hook). Set it up once; never have a Copilot session run against a 6-month-old config again.
7. GitHub MCP Server — Official GitHub AI Integration — The official github/github-mcp-server lets any MCP-aware client — including Copilot in agent mode — read PRs, file issues, comment on diffs, trigger Actions, and search code. This is the single highest-leverage MCP you can install. Copilot's agent mode lights up dramatically with it.
8. Security Investigator — Copilot Security Investigation Kit — A real agent-mode workload. Plug this skill in and Copilot can triage suspicious dependencies, review a CVE's blast radius across your repo, and produce a structured incident note — agent mode running for minutes, not seconds, calling tools, iterating. The kind of task that justifies the seat price.
9. Claude Code Agent: LaunchDarkly Flag Cleanup — Despite the "Claude Code" name, this is explicitly written as a GitHub Copilot agent that drives the LaunchDarkly MCP server to clean up stale feature flags safely. A worked example of the agent + MCP combo on a real production chore most teams do badly.

How they fit together

Think of Copilot 2026 as four layers, and this pack populates each one:

Copilot Chat / Edits  ← what you already use (autocomplete + Q&A)
        │
Custom instructions   ← #3 ai-prompts, #5 RuleForge (seed), #6 Caliber (keep fresh)
        │
Unified config        ← #4 lnai (one source of truth across tools)
        │
MCP servers           ← #7 GitHub MCP (the foundation)
        │
Agent mode workloads  ← #8 Security Investigator, #9 LaunchDarkly cleanup
        │
Reference / discovery ← #1 official collection, #2 awesome-copilot

Chat / Edits / Custom instructions / Agent mode / MCP are the five named surfaces. Items #1 and #2 teach you the surface area; #3–#6 own the custom instructions layer; #7 plugs MCP in; #8 and #9 are real agent-mode workloads you can copy.

The load-bearing wall is custom instructions + GitHub MCP. Install #3 (or #5, generated), wire up #7, and your next agent-mode session is already 10× better grounded than baseline. Everything else is upgrades.

Tradeoffs you'll hit

• Copilot vs Claude Code / Cursor — Copilot wins on three things: deepest GitHub.com / PR / Actions integration (no other tool sees your PR threads natively), seat licensing your security team already approved, and stable VS Code / JetBrains support without third-party installs. Claude Code wins on raw capability and terminal-native workflow. Cursor wins on UX polish and .cursor/rules ergonomics. Use Copilot when: PR review, GitHub-native workflows, regulated enterprises where Anthropic/Cursor aren't approved, JetBrains shops. Reach for Claude Code or Cursor when: long autonomous coding sessions, terminal-heavy work, prototyping outside a GitHub repo.
• Custom instructions vs prompt files — Copilot supports both .github/copilot-instructions.md (read every turn, project-wide) and discrete .github/prompts/*.prompt.md files (invoked explicitly). Default to instructions for standing context (stack, conventions, hard NOs) and prompt files for named workflows ("write a migration," "file a bug report"). Don't pile everything into instructions — token budget matters.
• Official collection (#1) vs awesome-copilot (#2) — Overlap is real. Official is conservative and curated by GitHub; awesome-copilot is comprehensive and community-driven. Treat #1 as docs, #2 as discovery. Skim #1 once end-to-end; revisit #2 monthly.
• lnai (#4) vs maintaining four config files — Skip lnai if you only use Copilot. Adopt it the moment you also use Claude Code or Cursor — config drift between tools is a real source of "why did this work yesterday?"
• Agent mode vs Chat for the same task — Chat is conversational, fast, single-turn. Agent mode plans, runs commands, iterates on failures, can take minutes. Use Chat for "explain this function"; reach for agent mode when the task requires running tests, calling MCP tools, or chaining steps.

Common pitfalls

• Copilot instructions too long — Same trap as CLAUDE.md. 30–100 lines is the sweet spot. Copilot reads instructions every turn; bloated files burn context budget and slow latency.
• Forgetting .github/copilot-instructions.md exists — The file lives under .github/, not the repo root. It's invisible in many file trees and easy to miss. Check git ls-files .github/ after install.
• Mixing prompt files into instructions — Putting a long "write a migration" prompt inside instructions means it runs every turn, even when you're just asking what a function does. Move named workflows to .github/prompts/.
• Skipping the org admin step for MCP — On Copilot Enterprise / Business, MCP servers may need org-level approval before agent mode can call them. If GitHub MCP "doesn't work," check org policy before debugging the server.
• Treating agent mode as autocomplete with extra steps — Agent mode is for tasks with a clear success criterion the agent can verify (tests passing, lint clean, flag deleted). Give it open-ended "refactor this nicely" tasks and you'll watch it spin. Pair every agent run with a concrete check.
• Never refreshing instructions — Caliber (#6) exists because nobody updates copilot-instructions.md manually after the first week. Schedule it. Or hook it to your dependency-update PRs.