GitHub collection
drvoss/everything-copilot-cli
Imported from GitHub — is this yours?
113 skills imported from this repository.
- Stars
- 49
- Forks
- 12
- License
- MIT
Skills (113)
actions-debugging
Use when a GitHub Actions workflow fails — diagnose the run log, identify the root cause, and apply a targeted fix
autopilot-patterns
Use when you're ready to let Copilot execute a multi-step plan autonomously — configures appropriate guardrails, handles plan-to-autopilot transitions, and sets safety boundaries.
background-agent
Use when a task is too long to block the current session or should run autonomously — delegates to a cloud background agent via & or /delegate so work can continue on GitHub while you keep moving locally, not in a local async PowerShell session.
cross-session-memory
Use when you need to recover context, decisions, or artifacts across multiple Copilot CLI sessions — search prior session history and resume with the right files, notes, and state.
ide-switching
Use when moving between VS Code and Copilot CLI in the same session — transfers context between environments so you don't lose state when switching from editor to terminal.
plan-mode-mastery
Use when starting a complex multi-step task to create an approved plan, track todos in SQL, and execute with checkpoints
session-management
Use when a task spans multiple steps or sessions and needs structured state tracking — leverages the built-in SQLite session database for todos, dependencies, and batch operation progress.
stack-detector
Use when starting work on an unfamiliar codebase or onboarding a contributor and you need to know which skills and rules from this collection apply — scans the project's tech stack (package.json, config files, lockfiles) and recommends the most relevant ones for the detected tech
ai-visibility
Use when you want your product to surface in AI-generated answers (ChatGPT, Perplexity, Gemini) — creates llms.txt, optimizes structured data, and configures AI crawler access for GEO.
content-strategy
Use when you need a content plan to grow organic traffic for a product or new area — produces keyword research, topic clusters, and a content calendar targeting your category.
actions-debugging
Use when a GitHub Actions workflow fails — diagnose the run log, identify the root cause, and apply a targeted fix
agentic-engineering
Use when designing or decomposing a task for agent execution — applies 15-minute task units, eval-first loops, and explicit input/output contracts so agents work reliably without implicit state
autopilot-patterns
Use when you're ready to let Copilot execute a multi-step plan autonomously — configures appropriate guardrails, handles plan-to-autopilot transitions, and sets safety boundaries.
background-agent
Use when a task is too long to block the current session or should run autonomously — delegates to a cloud background agent via & or /delegate so work can continue on GitHub while you keep moving locally, not in a local async PowerShell session.
context-prime
Invoke when starting a session (or resuming after a break) on a repo before making changes, to load live project context (structure, recent commits, test status)
copilot-memory
Use when you need to understand, review, or curate GitHub Copilot's repository-level memory — the persistent facts Copilot reuses across CLI, cloud agent, and code review for the same repository
cross-session-memory
Use when you need to recover context, decisions, or artifacts across multiple Copilot CLI sessions — search prior session history and resume with the right files, notes, and state.
ecosystem-intake
Use when monitoring a curated ecosystem source and you need to turn new items into concrete adopt/adapt/reject backlog candidates — combines GitHub-native reading with SQL triage and repository-fit scoring.
fleet-parallel
Use when you need to run the same task across many files, components, or contexts in parallel — triggers /fleet mode for batch refactoring, mass testing, or bulk review. NOT when sequential order matters.
github-code-search
Use when you need real-world implementation examples or cross-repository context — search GitHub's global code index with the built-in MCP tools and reuse the results as grounded context.
github-codespaces-efficiency
Use when optimizing GitHub Codespaces — faster startup times, lower spend, slimmer devcontainers, right-sizing machines, or scoping prebuilds.
github-issue-triage
Use when you have a backlog of unorganized GitHub Issues — bulk-reads, prioritizes, and labels issues at scale using `gh` (the default when installed) or Copilot's built-in GitHub MCP tools when exposed, and proposes assignees
ide-switching
Use when moving between VS Code and Copilot CLI in the same session — transfers context between environments so you don't lose state when switching from editor to terminal.
knowledge-curator
Use when repeated lessons, pitfalls, or decisions should move from temporary session context into durable project guidance — curate what to keep, what to discard, and where it belongs.
mcp-builder
Use when you need to build a new MCP server — plan the tool surface, implement the server, register it in Copilot CLI, inspect the config, and test the tools end to end.
mcp-ecosystem
Use when Copilot CLI's built-in tools do not cover a service you need — for example PostgreSQL, Redis, Jira, Slack, or an internal API — and you need to add an MCP server beyond the default GitHub MCP. NOT when the built-in tools already cover the task.
multi-model-strategy
Use when choosing which AI model to use for a task — pick the right model family and tier based on cost, speed, context needs, and reasoning depth
plan-mode-mastery
Use when starting a complex multi-step task to create an approved plan, track todos in SQL, and execute with checkpoints
scope-guard
Use when a task must stay inside a narrow file or directory boundary, or when risky commands need an explicit stop rule — define the writable surface first so the agent does not drift.
session-management
Use when a task spans multiple steps or sessions and needs structured state tracking — leverages the built-in SQLite session database for todos, dependencies, and batch operation progress.
stack-detector
Use when starting work on an unfamiliar codebase or onboarding a contributor and you need to know which skills and rules from this collection apply — scans the project's tech stack (package.json, config files, lockfiles) and recommends the most relevant ones for the detected tech
task-intake-router
Use when a request arrives and the right execution path is unclear — routes the work to the correct mode, agent type, model tier, and delegation pattern before implementation starts.
team-planner
Use when a task is too large or multi-domain for a single agent — assemble a specialist team, assign work via SQL tracking, dispatch with /fleet or task tool, and synthesize results
token-cost-optimizer
Use before a large Copilot task when model choice, context size, or parallelism could drive up billed usage — estimate cost pressure early and apply Copilot-specific reduction tactics before you run
api-and-interface-design
Use when defining a public API, CLI, webhook, or SDK surface — lock the contract first so compatibility, validation, and versioning stay intentional instead of accidental
code-review
Use when reviewing code changes for quality, correctness, and security — runs a structured checklist with severity-rated findings
context-engineering
Use when designing prompts or agent tasks to optimize information delivery — minimize noise, maximize signal for AI agents
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
deprecation-and-migration
Use when removing old APIs, migrating to new patterns, or cleaning up legacy code — treats code as liability and follows a structured removal process
fix-build-errors
Use when a build, compilation, or type-check fails — diagnose the error, identify root cause, and apply the minimal fix to get green
fix-github-issue
Use when you have a GitHub Issue number or link and want it resolved end-to-end — reads the issue, locates the bug, applies a fix, writes tests, and opens a PR from the terminal.
improve-codebase-architecture
Use when a codebase feels hard to change, test, or navigate — surface architectural friction, identify deeper module seams, and walk one candidate into a concrete refactoring direction.
nestjs-prisma
Use when building a NestJS application with Prisma — covers PrismaService setup as an injectable singleton, repository pattern integration, and testing with Prisma mocks.
nextjs-prisma
Use when working on a Next.js App Router project that uses Prisma as the ORM — covers server component data fetching, singleton client setup, and type-safe query patterns.
performance-optimization
Use when performance is a real concern — measure first, isolate the bottleneck, and prove the improvement instead of guessing
pr-multi-perspective-review
Review a pull request from 6 perspectives (PM, Dev, QA, Security, DevOps, UX) for comprehensive, bias-free feedback
react-vitest
Use when adding or improving tests in a React project that uses Vitest — covers component testing with Testing Library, mocking hooks, and coverage configuration.
receiving-code-review
Use when you have just received code review feedback (human or agent) and are about to act on it — verify each item against the codebase before implementing, and push back with technical reasoning instead of performative agreement
refactor-clean
Use when code has grown complex, duplicated, or cluttered — clean up structure and remove dead code without changing observable behavior
skill-creator
Use when you want to create a new SKILL.md file — describe a workflow and this skill generates a properly structured, frontmatter-complete SKILL.md that follows this repository's conventions
source-driven-development
Use when implementing framework-specific or library-specific code — verify non-trivial APIs against official documentation before writing them, and record the source in task notes, docs, or the PR.
spec-driven-development
Use before starting any non-trivial feature to write a technical spec first — prevents misaligned implementation and scope creep
systematic-debugging
Use when a bug is non-obvious or has resisted quick fixes — applies a 4-phase root cause analysis to find and permanently resolve the issue rather than patching symptoms
tdd-workflow
Use when starting a new feature or function to write failing tests first, then implement the minimal code to pass (Red→Green→Refactor)
add-to-changelog
Use when you've shipped a feature, fix, or breaking change and need to update CHANGELOG.md — follows Keep a Changelog format and syncs version numbers across package manifests.
api-documentation
Use when source code has changed and API docs are stale, or a new endpoint lacks documentation — generates accurate docs from implementation, not guesswork.
architecture-decisions
Use when making significant, hard-to-reverse technical decisions to document context, rationale, and consequences as Architecture Decision Records (ADRs)
document-generate
Use when a feature, module, or whole project needs missing documentation created from scratch - read the codebase, map the public surface with Diataxis (tutorial/how-to/reference/explanation), and generate the missing docs with cross-links.
doc-update
Use when code has changed and documentation may be out of date — identifies stale docs, finds gaps between implementation and docs, and applies targeted updates.
create-prd
Use when you're ready to define a feature before building it — generates a structured PRD using Jobs-to-be-Done thinking, success metrics, and explicit scope boundaries.
feature-prioritization
Use when you have a backlog of features and need to rank them for the next sprint — scores each feature using Impact × Confidence × Effort matrix with SQL tracking for transparent prioritization.
launch-strategy
Use when you're preparing to launch a product or feature publicly — builds a structured checklist covering positioning, distribution, messaging, and success metrics from private beta to GA.
opportunity-solution-tree
Use when you need to ensure every feature in the backlog connects to a measurable business outcome — applies Teresa Torres' OST framework to map outcomes → opportunities → solutions → experiments.
product-capability
Use when engineering needs testable, implementable technical requirements — not a PRD but a capability spec with acceptance criteria, task breakdown, and traceability from requirement to implementation ticket
agent-governance
Use when designing or reviewing an AI agent system that needs policy-based access controls, intent classification, tool-level rate limiting, trust scoring for multi-agent workflows, or append-only audit trails.
agent-owasp-check
Use when auditing an AI agent system against the OWASP Agentic Security Initiative Top 10 — checks tool access, prompt boundaries, memory handling, and operational safeguards across the agent pipeline.
evaluate-repository
Use when you need a security health scorecard of a codebase — scores 7 dimensions (secrets, dependencies, input validation, auth, error handling, supply chain, and AI agent governance) with a prioritized remediation plan.
gha-security-review
Use when reviewing GitHub Actions workflows for exploitable vulnerabilities — finds pwn-request patterns, expression injection, credential escalation, config poisoning, and supply chain risks, and reports only HIGH and MEDIUM confidence findings with concrete attack paths.
input-validation
Use when writing or reviewing code that processes user input — validates and sanitizes to prevent SQL injection, XSS, CSRF, and other injection attacks. NOT when the code path doesn't touch user-supplied data.
mcp-implementation-security-review
Use when reviewing the source code of an MCP server or client implementation — not just its runtime config — for authentication, session, rate-limit, schema-validation, and SDK-usage vulnerabilities, with file/line-cited findings mapped to OWASP Top 10
pr-security-review
Use when reviewing a pull request for security issues — automatically analyzes the diff for vulnerabilities, hardcoded secrets, injection risks, and broken access control before merging
secret-detection
Use when you suspect API keys, tokens, or passwords are hardcoded in source code or committed to git history — scans and guides safe removal without breaking existing integrations.
security-bounty-hunter
Use when the goal is practical vulnerability discovery for responsible disclosure or bounty submission — focuses on remotely reachable, exploitable issues that qualify for real reports rather than a broad best-practices review
security-scan
Use when you want a quick security pass on code changes or dependencies — checks OWASP Top 10 patterns, runs dependency audits, and surfaces critical vulnerabilities with targeted fixes.
threat-model-analyst
Use when a repository, system, or major change needs a structured STRIDE-A threat model — map architecture, data flows, trust boundaries, abuse cases, and prioritized findings, or update an existing model with a change-focused diff.
browser-devtools
Use when verifying frontend behavior at runtime — DOM validation, network inspection, performance profiling with browser DevTools
e2e-testing
Use when you need end-to-end tests for critical user flows that unit tests can't cover — scaffolds Playwright/Cypress tests from the happy path through edge cases.
test-coverage
Use when test coverage falls below target or a new module has no tests — identifies untested code paths and writes targeted unit or integration tests to close the coverage gap.
commit-workflow
Use when you're about to commit (especially with a mixed diff) to stage changes, split into atomic commits, and write Conventional Commit messages with emoji
conventional-branch
Use when creating or validating a Git branch name so the branch follows a conventional type/description format, matches the work being done, and starts from the right base branch.
cost-audit
Use when AI inference costs are growing unexpectedly, when comparing model choices by cost/quality ratio, or when optimizing token usage across a multi-model pipeline — produces an actionable cost reduction plan
deep-research
Use when a question requires comprehensive evidence gathering from multiple sources, systematic synthesis, and traceable citations — produces a structured research brief rather than a quick answer
deployment-canary
Use when a release has been deployed to a limited audience and must be observed before full rollout — defines success signals, watch windows, rollback triggers, and investigate handoffs.
doubt-driven-development
Use when a non-trivial decision should not stand without a fresh-context challenge - isolate the artifact and contract, run an adversarial review before committing, and reconcile the findings while change is still cheap.
finishing-a-development-branch
Use when implementation is complete and tests pass but the branch itself is not yet resolved — verify tests, detect worktree vs. normal checkout, then present merge/PR/keep/discard options and execute the chosen cleanup
github-actions-efficiency
Use when auditing GitHub Actions workflows for efficiency — reducing CI minutes, cutting costs, eliminating redundant runs, or optimizing caching and concurrency.
grill-me
Use when a plan still has hidden assumptions — default to one question at a time for dependent branches, batch only truly independent questions when it saves real round-trips, and keep stress-testing the plan until dependencies, risks, and decisions are explicit before implementa
grill-with-docs
Use when a plan must be stress-tested against the codebase's existing language and decisions — grill it against current docs, glossary terms, and ADRs before implementation begins
implementation-review
Use after an implementation pass lands — compare the original task spec or handoff against the delivered diff, classify each requested item, and produce an actionable follow-up report.
interview-me
Use when a request is underspecified and you need to discover what the user actually wants before writing a plan, spec, or code - default to one question at a time when later questions depend on earlier answers, switch to a numbered batch only for independent high-latency clarifi
outside-voice
Use when you need an independent second opinion before, during, or after implementation — run challenge, consult, or review mode in a direct builder-to-builder voice
prompt-optimizer
Use when a rough prompt, vague idea, or task description needs to become a finished copy-pasteable prompt for a chat-based LLM - rewrite it into one ready-to-send prompt with no blanks, no placeholders, and a clear output shape.
security-audit
Use when a codebase needs a formal security audit beyond a quick scan — applies OWASP Top 10 and STRIDE threat modeling from a CSO perspective to surface systemic vulnerabilities.
sprint-retro
Use at the end of a sprint to run a data-driven retrospective — analyzes session history and git metrics to surface what shipped, what slowed you down, and concrete improvements.
sprint-workflow
Use when starting a new feature, refactor, or multi-step dev task — runs the full sprint cycle (Think → Plan → Build → Review → Test → Ship → Monitor) using Copilot CLI's plan/autopilot modes.
using-git-worktrees
Use when you need multiple branches checked out at once — create isolated working directories for parallel development without cloning the repository repeatedly
verification-before-completion
Use before claiming any task is done — run the exact command that proves the fix works, read the output, and only then report success.