copilot-collection

Generates ONLY the animated HTML architecture diagram for a codebase (no surrounding report, no slide deck) — a single self-contained file with zero external dependencies that opens directly in any browser. Use when the user says: "just the diagram", "diagram only", "animated diagram only", "generate an architecture diagram (no report)", "show me the data flow animation", "I only want the diagram", or "self-contained diagram". Do NOT use for: full architecture reports (use the `archflow` skill), slide decks (use `archflow-slides`), static dependency graphs, or editing source code.

Analyzes a codebase and generates animated HTML architecture reports — beautiful, bespoke visualizations with interactive animated diagrams showing how the system works. Three output modes: full report (default), diagram-only (zero external deps), or scroll-snap slide deck. Use when the user says: "visualize the codebase", "explain the architecture", "generate a diagram", "show how the code flows", "create an architecture diagram", "animate the data flow", "explain this repo visually", "show me how this works", or "generate an architecture report". Do NOT use for: editing source code, generating documentation prose (use a regular doc), or producing static dependency graphs (this skill shows one typical request flow end-to-end, not the full graph).

Generates an architecture slide deck for a codebase — a scroll-snap HTML presentation with the animated architecture diagram as a hero slide, plus supporting slides for components, data flow, external services, and insights. Navigate with arrow keys, Page Up/Down, or swipe gestures. Use when the user says: "create a slide deck", "architecture slides", "presentation of the architecture", "scroll-snap presentation", "make slides explaining this codebase", "deck for the architecture", or "slide-style architecture overview". Do NOT use for: full architecture reports (use the `archflow` skill), diagram-only output (use `archflow-diagram`), static dependency graphs, or editing source code.

Authors an Architectural Decision Record (ADR) for a technical decision. Walks through context, considered options, decision, consequences, and references in a numbered, immutable record. Output goes to docs/adr/ (configurable). Forces explicit tradeoff analysis and "what would change this decision" criteria. Use when the user says: "write an ADR for this", "document this decision", "we chose X over Y, capture it", "ADR for the database switch", "record why we picked Lakehouse". Do NOT use for: brainstorming options (use ultrathink instead), documenting code patterns (use a regular doc), recording per-PR rationale (use the PR description).

Adds evaluation capability to an existing agent or pipeline. Walks through designing the eval suite (deterministic + AI-assisted + agentic metrics), building the golden dataset, wiring the runner, and setting up regression tracking. Specific to the eval-framework patterns used in this collection (pytest markers, Fabric Delta backend, Azure AI Evaluation SDK). Use when the user says: "add evals to this agent", "design an eval suite for X", "how do I evaluate this prompt change?", "set up regression tracking for the agent", "I need golden data for this". Do NOT use for: writing the agent's prompts (different skill), training a model (out of scope), running existing evals (just `pytest -m eval`).

Systematic review of a pull request or diff. Walks 8 categories (security, correctness, error handling, types, performance, testing, observability, maintainability) in order of severity. Outputs structured findings with severity, location, and remediation pointer. Designed to be applied consistently across reviewers — same rubric every time. Use when the user says: "review this PR", "review my changes", "code review", "audit this diff", "what's wrong with this PR?", "check before merge". Do NOT use for: simplification only (use simplify skill), security-focused audit (deeper scope), performance-focused profiling, or pure architectural review.

Explores an unfamiliar codebase to build a mental model: identifies entry points, primary modules, build / test commands, dependencies, data flow, and conventions. Outputs a structured "codebase map" document. Designed for onboarding to a new repo, evaluating a fork before contributing, or auditing a repo before adopting it. Use when the user says: "explore this codebase", "I just cloned this repo, give me the overview", "what does this project do?", "onboard me to this code", "summarize the architecture", "is this fork still maintained?". Do NOT use for: writing code (this skill is read-only), reviewing changes (use code-review), or planning a feature in code you already understand.

Re-validates agent knowledge-base content (concepts, patterns, anti-patterns) against authoritative sources. Identifies stale files via `last_validated` date, fetches current docs, surfaces discrepancies, and updates files in place with new validation date. Designed for the 90-day re-validation cycle baked into every agent in this collection. Use when the user says: "re-validate the KB", "are the agents stale?", "check KB freshness", "update KB for <domain>", "run the 90-day check", "did azure-ai-projects change?". Do NOT use for: creating new KBs from scratch (use the agent creation prompt), reviewing KB structure (use code-review), generating new concepts/patterns (manual curation).

Creates a detailed phased implementation plan for a feature or task. Decomposes the work into ordered phases, each with concrete steps, files to touch, tests to write, and explicit definition-of-done. Output is a markdown plan that can be reviewed before execution and later consumed by an executor agent or human contributor. Use when the user says: "plan this feature", "make a plan for X", "break this down into phases", "what's the implementation plan?", "I want to refactor X — plan the work first". Do NOT use for: deciding whether to do something (use ultrathink), designing the architecture (use system-design skill / agent), one-off small fixes (just do them).

Reviews recently changed code for reuse, clarity, and over-engineering. Identifies and proposes fixes for: duplicated logic (DRY violations), dead code, unnecessary indirection, premature generalization, magic numbers, unclear names, deep nesting. Use when the user says: "simplify this", "clean up", "review my changes for simplification", "is this over-engineered?", "DRY check", "remove the cruft", "what can I delete here?". Do NOT use for: full architectural review (use code-review skill), security audit, performance optimization, designing a new feature.

Captures a feature specification before implementation begins. Walks through user need, behavior, edge cases, success criteria, and non-goals. Output is a markdown spec saved to docs/specs/. Used as input by /make-plan to decompose into phases. SDD-lite — pragmatic, not enterprise. Use when the user says: "spec out X", "write a spec for this feature", "before we plan, capture the requirements", "what should X do exactly?", "RFC for this feature". Do NOT use for: small bug fixes, prototypes / spikes, infrastructure refactors with no user-facing change.

Deep deliberation skill for hard architectural decisions, ambiguous requirements, high-stakes refactors, and "why did this fail?" analysis. Forces explicit chain-of-reasoning, considers multiple options, weighs tradeoffs honestly, and emits structured output. Use when the user says: "think hard about this", "deep analysis on...", "compare these approaches", "why did this fail?", "what's the right abstraction?", "should we use X or Y?", "what are we missing?", "this decision matters — don't be glib". Do NOT use for: simple lookups, routine code generation, quick fixes, syntax questions. The deliberation overhead is wasted on easy problems.