Applies KISS, YAGNI, and SOLID principles for clean code with reduced complexity. Use when refactoring or reviewing code for over-engineering.

Polishes working code through successive quality passes in fresh subagents. Use after tests pass when code needs multi-dimension refinement before release.

Provides review-workflow scaffolding for context, evidence, and output. Use at the start of any detailed review to ensure consistent, comparable findings.

Manages Claude Code sessions with naming, checkpointing, and resume strategies. Use when organizing long-running work or resuming across sessions.

Applies layered n-tier architecture with enforced boundaries. Use when designing moderate systems needing clear presentation, domain, and persistence layers.

Applies microservices for independent deployment and per-service scaling. Use when teams need autonomous release cycles with distinct capability scaling needs.

Contract for the project decision journal (tradeoffs and lessons-learned logs). Use when recording a decision, tradeoff, or lesson, or building a consumer hook.

Detect friction signals; graduate patterns into rules. Use for session retrospectives.

Converts webm/mp4 video files to optimized GIFs via ffmpeg with configurable quality settings. Use when post-processing recordings into shareable GIFs.

Generates markdown digests and CSV exports for GitHub initiative health. Use when reporting on issue/PR progress across a milestone or project.

Standardizes release approvals with GitHub-aware checklists and deployment gates. Use before releasing to production to verify all gates pass.

Compresses verbose responses by removing filler and framing to save 200-400 tokens. Use when responses feel bloated or context is filling fast.

Applies NASA Power of 10 rules for safety-critical verifiable code. Use when auditing financial, medical, or high-reliability system code.

Cascades a rebase through an entire PR stack after a base PR merges or upstream changes. Use when a stack needs to incorporate new base branch commits.

Formats review deliverables with consistent structure for comparable findings. Use when finalizing any review or analysis that must be shared or compared.

Creates behavioral rules in markdown to block dangerous commands or restrict AI behavior. Use when adding safety guardrails or preventing specific commands.

Tracks per-agent token usage and flags waste in parallel dispatch. Use when evaluating parallel agent efficiency or after a multi-agent run.

Analyzes code change impact with risk scoring and affected-node mapping. Use before merging to understand what a change touches and what lacks test coverage.

Automates desktop GUI workflows via computer use API with screenshot capture. Use when scripting GUI interactions or recording browser sessions for tutorials.

Guides when to ask clarifying questions versus proceed autonomously. Use to reduce unnecessary clarifying questions when intent is clear.

Delegates tasks to Gemini CLI implementing delegation-core for Google's models. Use when delegation-core selects Gemini or 1M+ token context is needed.

Curate the web-capture index. Use when the capture backlog grows, captures sit unprocessed at seedling/pending, or to surface stored research during work.

Converts a specification into a phased, dependency-ordered implementation plan. Use after specification is complete and before execution begins.

Delegates tasks to Qwen CLI via delegation-core for Alibaba's models. Use when delegation-core selects Qwen or large-context batch processing is needed.

Converts a Claude Code session JSONL file into an animated GIF terminal replay. Use when creating demos or visual evidence from past sessions.

Selects optimal sources for tool calls, balancing accuracy with token cost. Use before research tasks or when deciding whether a claim needs verification.

Enforces token quota management at session start with conservation and compression checks. Use at the start of every session or before large context loads.

Runs parallel prose and craft review agents against a voice profile. Use when checking generated content for AI patterns and voice drift before publishing.

Configures GitHub Actions CI/CD workflows for testing, linting, and deployment. Use when setting up automation for a Python, Rust, or TypeScript project.

Inverts burden of proof for code additions. Use when reviewing PRs, planning refactors, or running unbloat to challenge every addition's necessity.

Applies client-server architecture for web/mobile apps. Use when designing systems with centralized backend services, trust boundaries, or offline-first sync.

Applies CQRS and Event Sourcing for read/write separation and audit trails. Use when designing systems with complex domain logic or full state-change history.

Applies event-driven async messaging to decouple producers and consumers. Use when designing real-time or multi-subscriber systems needing loose coupling.

Applies Functional Core, Imperative Shell to isolate logic from side effects. Use when business logic is entangled with I/O or unit tests are slow and brittle.

Applies hexagonal architecture isolating domain from infrastructure. Use when designing systems where testability and port/adapter separation are priorities.

Applies microkernel architecture with minimal core and plugin extensibility. Use when building platforms where third parties extend core functionality.

Applies modular monolith with enforced internal boundaries. Use when teams want service-level autonomy without distributed system overhead.

Applies serverless FaaS patterns for event-driven workloads. Use when designing bursty workloads with minimal infrastructure and pay-per-execution cost model.

Applies coarse-grained service architecture for deployment independence. Use when independent deployment is needed but shared databases rule out microservices.

Generates a compressed project context map to avoid expensive Read/Grep calls. Use at session start or before implementing features in an unfamiliar codebase.

Establishes CPU/GPU baselines before resource-intensive operations. Use before builds, training runs, or any task that pins cores or GPUs for over a minute.

Generate diverse solution candidates with category-spanning ideation methods and rotation. Use when stuck on a design or fighting repetitive LLM output.

Generates Makefiles with testing, linting, formatting, and automation targets. Use when starting a project or standardizing build automation.

Transforms project briefs into testable specifications with user stories and acceptance criteria. Use after brainstorming, before planning.

Orchestrates the QUALITY pipeline stage for egregore work items, running code review, unbloat, and test updates. Use when running quality checks before a PR.

Runs multi-source research across GitHub, HN, Reddit, arXiv, and Semantic Scholar. Use when surveying a technical topic across multiple channels.

Initializes a stacked branch set from an ordered plan, one branch per slice with parent-child links. Use when a plan has 2+ sequentially dependent changes.

Pushes all branches in a stack and opens or updates one dependent PR per slice. Use after stack-create to publish the stack or after adding commits to a slice.

Applies TRIZ cross-domain analogical reasoning to find solutions from adjacent fields. Use when stuck on a problem and needing inventive perspectives.

Bumps versions, updates changelogs, and coordinates version changes across files for releases. Use when preparing a release or bumping the project version.

Applies pipes-and-filters for sequential data transformations. Use when data flows through discrete stages like ETL, streaming analytics, or CI/CD pipelines.

Applies data-grid architecture for high-traffic stateful workloads. Use when a single database cannot scale and in-memory partitioning is needed.

Traces execution paths through the code graph with criticality scoring and Mermaid charts. Use when understanding how a function propagates through the system.

Generates conventional commit messages from staged changes. Use when committing and needing a well-formatted message. Do not use for full PR prep; use pr-prep.

Provides sanitization guidelines for external content in skills and hooks. Use when loading GitHub Issues, PRs, WebFetch results, or any untrusted input.

Defines the contract for deferred-item capture across plugins. Use when building or validating a plugin's deferred-capture wrapper or adding source labels.

Converts external documents (PDF, DOCX, PPTX, XLSX, HTML) into editable markdown. Use when ingesting external files for rewriting or project integration.

Maps file structure and module organization of a codebase. Use before architecture reviews, refactoring planning, or migration scope estimation.

Audits the DSA problem bank for coverage gaps and proposes new YAML entries. Use when refreshing the problem bank during update-plugins runs.

Installs egregore watchdog daemon via launchd or systemd for autonomous relaunching. Use when setting up egregore on a new machine. Do not use on CI/CD runners.

Generates Mermaid and ASCII diagrams of palace structure, knowledge topology, and synapse connectivity. Use when inspecting or presenting a palace visually.

Presents adaptive codebase challenge questions with multiple-choice and trace exercises. Use when testing contributor knowledge of the codebase.

Builds or updates the code knowledge graph via tree-sitter AST and SQLite. Use when setting up the graph before search or blast-radius analysis.

Select hook scope (plugin, project, global) by audience. Use when authoring a hook.

Searches academic literature via arXiv, Semantic Scholar, and open-access PDFs. Use when building literature reviews or finding formal research on a topic.

Removes the egregore watchdog daemon and its associated files. Use when stopping automated session relaunching or cleaning up egregore infrastructure.

Searches GitHub for existing implementations, libraries, or patterns. Use when finding code examples or prior art on a topic during a research session.

Refines an active research session by drilling deeper into a subtopic. Use after tome:research to narrow results to a specific channel or angle.

Scans HN, Lobsters, Reddit, and tech blogs for community experience reports. Use when gathering practitioner opinions on a technology or approach.

Builds the gauntlet knowledge base from AST extraction and AI enrichment. Use when initializing or refreshing codebase knowledge for challenges.

Searches the code knowledge graph by function, class, or type using FTS5 full-text search. Use when locating code entities by name or qualified path.

Guides a new developer through five staged challenge sets covering architecture, domain, patterns, and hardening. Use when onboarding contributors.

Merges, dedupes, ranks, and formats research findings into a report. Use after research agents return results from multiple channels to produce a ranked report.

Adds developer-authored annotations to the gauntlet knowledge base. Use when capturing tribal knowledge or rationale not visible in code.

Generates a Mermaid class diagram showing types, inheritance, and composition. Use when visualizing class hierarchies or documenting a module public API.

Detects architectural clusters and coupling boundaries via community detection on the code graph. Use when identifying module groupings or refactoring targets.

Generates a Mermaid dependency graph showing import relationships between modules. Use when analyzing coupling, finding circular deps, or planning refactors.

Generates a Mermaid workflow diagram showing process steps, decisions, and state transitions. Use when documenting CI/CD pipelines or lifecycle processes.

Generates a Mermaid architecture diagram showing high-level component relationships. Use when visualizing how plugins or modules fit together.

Generates a Mermaid sequence diagram showing how data moves between components. Use when tracing request flows or documenting data transformation pipelines.

Provisions the oracle ML inference daemon with onnxruntime via uv. Use when setting up local ONNX model inference for skill quality evaluation.

Use when planning, running, or summarizing discovery calls to uncover pain, timeline, and authority.

Use when engaging prospects through LinkedIn, communities, and social channels to spark warm conversations and meetings.

Use when planning multi-channel editorial calendars, enforcing publishing cadences, and coordinating distribution workflows across GTM teams.

Use to score accounts, flag risks, and standardize remediation triggers.

Use when defining ABM tiers, scoring logic, and coverage rules.

Operating system for intake, approvals, QA, and training across brand stakeholders.

Messaging and storytelling template that keeps positioning consistent across audiences.

Tone, diction, and phrasebook system for consistent writing + localization.

Framework for recruiting, activating, and rewarding community champions.

Use when crafting tiered ABM messaging, offers, and creative variants.

Use when establishing tests, monitoring, and incident response for analytics models.

Use when designing filters, suppression logic, and personalization cohorts for campaigns or automations.

Use to structure collaborative success plans with milestones, KPIs, and governance.

Framework for defining, approving, and auditing GTM metrics and KPIs.

Narrative and artifact system for preparing SaaS board/investor updates.