Skills catalog¶
Auto-generated from skills/*/SKILL.md frontmatter. Do not edit by hand — run:
python docs/scripts/generate_skills_catalog.py
Each entry links to the skill in the repository. Full bodies load on activation (progressive disclosure).
| Skill | Description |
|---|---|
| advanced-evaluation | This skill should be used for LLM-as-a-Judge evaluation techniques — direct scoring, pairwise comparison, rubric generation, reference-based grading, bias mitigation, calibration, and evaluator reliability measurement. Route deterministic evaluation checks and pipeline design to evaluation. Route agent harness design to harness-engineering. |
| amazonq-context-architecture | Understand how Amazon Q Developer assembles context — .amazonq/rules/ glob loading, README and AmazonQ.md defaults, /context profiles, context file token budgets, and IDE vs CLI context channels. Use when tuning what Q sees, diagnosing oversized context files, or budgeting against token limits. Do not activate for general context theory (context-fundamentals) or authoring rules (amazonq-customization). |
| amazonq-customization | Author Amazon Q Developer steering files — .amazonq/rules/ markdown rules, nested rule organization, custom CLI agents, MCP configuration, and AmazonQ.md scaffolds. Use when writing Q project rules, when rules are ignored, or when rule bloat degrades responses. Do not activate for Q context loading internals (amazonq-context-architecture) or general prompt theory (context-fundamentals). |
| amazonq-session-management | Manage the context-window lifecycle in Amazon Q Developer IDE chat and CLI — /context monitoring, /compact summarization, automatic compaction nudge at ~80% capacity, /clear, and saved conversations. Use when Q forgets earlier decisions, context approaches limits, or planning multi-phase CLI work. Do not activate for rule authoring (amazonq-customization) or general compression theory (context-compression). |
| antigravity-context-architecture | Understand how Google Antigravity assembles and persists context — AGENTS.md discovery, Knowledge Items, Skills in .agents/, Artifacts (plans, task lists, walkthroughs), Editor vs Manager surfaces, and browser/tool subagents. Use when tuning Antigravity context behavior, designing durable project memory, or diagnosing agent drift across sessions. Do not activate for general context theory (context-fundamentals) or authoring AGENTS.md (antigravity-customization). |
| antigravity-customization | Author Google Antigravity steering files — root and nested AGENTS.md, .agents/skills/ with SKILL.md manifests, workflows, and MCP configuration. Use when writing project instructions for Antigravity, when agents ignore conventions, or when AGENTS.md bloat degrades responses. Do not activate for Artifact lifecycle (antigravity-session-management) or general prompt theory (context-fundamentals). |
| antigravity-session-management | Manage persistent context across long Google Antigravity agent sessions — Artifact review cycles, Knowledge Item curation, Manager Surface handoffs, and deciding when to spawn fresh agents vs continue. Use when Antigravity agents lose thread across async runs, Artifacts go stale, or multi-agent work needs coordination. Do not activate for AGENTS.md authoring (antigravity-customization) or general compression theory (context-compression). |
| context-compression | This skill should be used for designing and evaluating compression strategies for long-running agent sessions — hierarchical summarization, selective retention, compaction triggers, quality thresholds, and handoff summaries. Route foundational context concepts to context-fundamentals, failure diagnosis to context-degradation, and token-level efficiency tactics to context-optimization. |
| context-degradation | This skill should be used for diagnosing and mitigating context degradation — lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context. Route foundational conceptual work to context-fundamentals, token-efficiency tactics to context-optimization, and compression strategy design to context-compression. |
| context-fundamentals | This skill should be used to explain or reason about the foundational concepts of context engineering — what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills — debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development. |
| context-optimization | This skill should be used for token-level efficiency tactics — observation masking, prefix caching, context partitioning, budget allocation, retrieval precision, format optimization, and trajectory-level token reduction. Route foundational concepts to context-fundamentals, failure diagnosis to context-degradation, compression strategies to context-compression, and filesystem offloading to filesystem-context. |
| copilot-context-architecture | Understand how GitHub Copilot assembles, budgets, and governs context — the client-side prompt wishlist, Jaccard snippet ranking, FIM prompts, server-side semantic RAG index, and enterprise privacy controls. Use when tuning Copilot context behavior, deciding what Copilot can and cannot see, diagnosing irrelevant completions, or making governance decisions about Copilot deployments. Do not activate for general context theory (context-fundamentals) or Copilot CLI session compaction (copilot-session-management). |
| copilot-customization | Author the files that steer GitHub Copilot — repository copilot-instructions.md, path-scoped .instructions.md with applyTo globs, prompt files, AGENTS.md, and MCP server configuration. Use when writing or restructuring Copilot customization files, when instructions are being ignored, or when instruction bloat degrades responses. Do not activate for how Copilot internally assembles context (copilot-context-architecture) or general system-prompt theory (context-fundamentals). |
| copilot-session-management | Manage the context window lifecycle in GitHub Copilot CLI and agent sessions — monitoring usage with /context, automatic and manual compaction, checkpoints, and deciding between long-running sessions and fresh starts. Use when sessions grow long, Copilot forgets earlier decisions, or planning multi-phase agent work. Do not activate for Copilot's prompt-assembly internals (copilot-context-architecture) or general compression theory (context-compression). |
| cursor-context-architecture | Understand how Cursor assembles, indexes, and budgets context — semantic codebase indexing, @-mention attachments, rule injection, subagent isolation, and context-window compression. Use when tuning what Cursor Agent sees, diagnosing missed files in search, or budgeting against effective context limits. Do not activate for general context theory (context-fundamentals) or authoring .mdc rules (cursor-customization). |
| cursor-customization | Author the files that steer Cursor Agent — .cursor/rules/*.mdc with description/globs/alwaysApply frontmatter, nested AGENTS.md, user rules, and MCP configuration. Use when writing or restructuring Cursor rules, when rules are ignored, or when rule bloat degrades Agent responses. Do not activate for Cursor indexing internals (cursor-context-architecture) or general prompt theory (context-fundamentals). |
| cursor-session-management | Manage the context-window lifecycle in Cursor Agent and CLI sessions — reading the context ring, automatic conversation compression, manual /compress, and deciding when to start fresh chats. Use when Cursor forgets earlier decisions, the context ring is near full, or planning multi-phase agent work. Do not activate for Cursor indexing or @-mentions (cursor-context-architecture) or general compression theory (context-compression). |
| evaluation | This skill should be used for building deterministic evaluation frameworks for agent systems — assertion-based checks, regression testing, pass/fail criteria, metric design, and structured evaluation pipelines. Route LLM-as-judge techniques, rubric generation, and evaluator bias mitigation to advanced-evaluation. Route agent harness design to harness-engineering. |
| filesystem-context | This skill should be used for filesystem-based context management — scratch pads, plan persistence, tool output offloading, sub-agent communication via shared files, dynamic skill loading, and just-in-time context discovery using standard file operations. Route memory architecture decisions to memory-systems, compression strategies to context-compression, and hosted runtime infrastructure to hosted-agents. |
| harness-engineering | This skill should be used for designing autonomous agent harnesses — the operating loop that manages agent execution with locked evaluation metrics, durable logs, novelty gates, rollback mechanisms, human approval boundaries, and safety constraints. Route evaluation framework design to evaluation, LLM-as-judge techniques to advanced-evaluation, and multi-agent coordination to multi-agent-patterns. |
| hosted-agents | This skill should be used when building background coding agents that run in remote sandboxed environments — pre-built images, warm sandbox pools, filesystem snapshots, multiplayer support, multi-client interfaces, and self-spawning patterns. Route multi-agent coordination patterns to multi-agent-patterns, individual tool design to tool-design, and filesystem offloading patterns to filesystem-context. |
| kiro-context-architecture | Understand how Amazon Kiro assembles context — workspace and global steering files with inclusion modes, foundational steering docs, spec artifacts (requirements/design/tasks), file references, and MCP integration. Use when tuning what Kiro sees across spec-driven workflows or diagnosing missing project context. Do not activate for general context theory (context-fundamentals) or authoring steering files (kiro-customization). |
| kiro-customization | Author Amazon Kiro steering files in .kiro/steering/ and ~/.kiro/steering/ — inclusion modes (always, fileMatch, manual, auto), foundational docs, AGENTS.md, hooks, and MCP configuration. Use when writing or restructuring Kiro steering, when guidance is ignored, or when always-on steering bloat degrades responses. Do not activate for spec lifecycle management (kiro-session-management) or general prompt theory (context-fundamentals). |
| kiro-session-management | Manage durable context across long Kiro spec-driven sessions — treating requirements/design/tasks artifacts as session memory, refreshing specs vs continuing chat, and using manual steering on demand. Use when Kiro drifts from agreed specs, multi-phase spec work spans days, or chat context diverges from steering files. Do not activate for steering inclusion modes (kiro-customization) or general compression theory (context-compression). |
| memory-systems | This skill should be used when designing agent memory architectures — short-term scratchpads, long-term persistence, entity tracking, vector RAG, knowledge graphs, and the file-system-as-memory pattern. Route filesystem-specific offloading patterns to filesystem-context, cross-session handoff summaries to context-compression, and multi-agent state sharing to multi-agent-patterns. |
| multi-agent-patterns | This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified. Route project-level pipeline decisions to project-development, hosted sandbox infrastructure to hosted-agents, and individual tool design to tool-design. |
| project-development | This skill should be used for LLM project lifecycle decisions — task-model fit analysis, pipeline architecture design, structured output schemas, batch processing strategies, cost estimation, and deployment planning. Route individual tool design to tool-design, multi-agent topology decisions to multi-agent-patterns, and evaluation framework design to evaluation. |
| tool-design | This skill should be used for the tool-interface layer of an agent system — writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Route project-shape and pipeline architecture decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns. |
Generated 28 skills.