OutlineDriven

Demolish bloated code and re-derive it clean, cutting every surface the rebuilt contract does not name. Use for a repo-wide bloat sweep, when patching a subsystem has stopped paying, or when the user says "this whole module is bloated", "rewrite this properly", or "break it and rebuild".

Use when the user says "deslop", "remove debug code", "find placeholders or stub code", or "remove dead code".

Dispatch compress operations. Use when the user says "tidy" or names a file, diff, memory, workspace, git stack, or doc to tidy.

Reduce internal duplication, dead code, and ceremony. Use when you spot dead fields, redundant wrappers, or speculative abstractions in code you are already editing.

Use when modernizing APIs, removing compat shims, killing feature flags, or rewriting a subsystem cleanly.

Use when the user says "simplify this diff", or asks for a compression pass over a change-set.

Design-by-Contract (DbC). Use when crossing public API boundaries, guarding complex state invariants, or hardening untrusted inputs and integration seams.

Drive decomposable work as a deterministic multi-subagent workflow: phased fan-out under per-task contracts with adversarial verification. Use for audits, migrations, broad research or review sweeps, work needing independent cross-checks before committing, or scale one context cannot hold.

Verbalized Sampling (VS) protocol for intent exploration before planning, mode-aware. Default `exhaustive` runs full VS; `collaborative` runs tip-sharing dialogue; `adversarial` walks the design tree one fork at a time. Auto-detects from phrasing ("help me refine" → collaborative, "poke holes" → adversarial); override via `/askme adversarial|collaborative|exhaustive`. Use for ambiguous tasks or maximum clarifying questions before committing.

Tidy-operations dispatcher. Invoke on "tidy", "clean up", "tidy this file/memory/workspace/git/docs", or when active context (current file, diff, stack, memory directory) has structural rot to resolve before touching behavior. Detects target domain from context and routes to the sibling skill. Requires explicit target or clear active-context signal — do not invoke speculatively.

Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses 1/3/5 Explore-agent escalation scaled to scope. Trigger on "explore", "find where X is", "how does X work in the code", "map the codebase", "what files handle Y", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore.

Surface deepening refactors that turn shallow modules into deep ones, informed by `CONTEXT.md` and `docs/adr/`. Use when the user asks to improve architecture, find refactor candidates, raise testability, or make a codebase more agent-navigable. Skip for single localized fixes.

Surface in-task-collaboration protocols when the user describes an AI workflow informally — URL-as-entity-reference, PR-comment threads as session memory. Trigger when the user names entities by colloquial label instead of stable URL, asks "how should I structure this for Claude", or describes a multi-step Claude workflow without a durable handle. Apply reactively, not as a checklist.

Code search, analysis, and refactoring using ast-grep (sg). Use for AST-based code modifications, structural search, and linting.

Verbosity-reduction response register. Drops redundant clauses, narrative hedging, and ceremony while preserving articles, grammar, and decision-oriented register. Trigger on "caveman", "compact mode", "less tokens", "be brief", or context-window pressure in long sessions.

Reduce concepts, duplication, and ceremony in internal code while touching nearby code. Use when working an existing path and you spot dead fields, redundant wrappers, or speculative abstractions; distinct from refactor-break-bw-compat (internal hygiene, not public API removal).

Read-only codebase exploration: discovery, structural reading, and emission of architecture/pattern/tooling/dependency summaries. Use to understand existing code, map files, trace function flow, locate symbols, or build pre-implementation context. Uses a staged 1/3/5 Explore-agent escalation protocol scaled to scope. Trigger on "explore", "find where X is", "how does X work in the code", "map the codebase", "what files handle Y", or any architecture/pattern/tooling/dependency context request on a local repo — even without naming /explore.

Surface deepening opportunities — refactors that turn shallow modules into deep ones — informed by `CONTEXT.md` and `docs/adr/`. Use when the user asks to improve architecture, find refactor candidates, raise testability, or make a codebase more agent-navigable. Skip for single localized fixes.

Decompose a plan, PRD, or spec into independently-grabbable vertical-slice issues (markdown file by default, GitHub issues via flag). Trigger when the user wants implementation tickets, work decomposition, or to convert an implementation plan into parallelizable work. Takes a plan file and emits atomic vertical slices.

Investigate a reported bug to root cause, then emit a TDD-shaped fix plan as an issue artifact. Trigger when the user reports a bug, says "triage", asks for issue investigation, or wants a fix plan before code changes.

Extract a domain glossary from the current dialogue; flag ambiguities, propose canonical terms, persist to `UBIQUITOUS_LANGUAGE.md`. Trigger when the user is hardening domain terminology, building a glossary, or fresh domain concepts surface in conversation without documented language.

Restructure Web-UI / human-triggered tasks into CLI + file-output loops the LLM can iterate alone. Open LLM-side observability — structured logs, file dumps, addressable scratchpads. Apply the trap-or-abandon decision: if a step cannot be looped, improve the harness rather than babysit. Trigger when the user mentions iterative grunt-work, "I have to push a button in a web UI to trigger this", monitoring dashboards, designing Claude-driven automation, or any workflow whose inner loop currently requires a human in the middle.

Surface concrete in-task-collaboration protocols when the user describes an AI workflow informally — URL-as-entity-reference, durable PR-comment threads as session memory, "fit the protocol" basics. Trigger when the user names entities by colloquial label instead of stable URL, asks "how should I structure this for Claude", pastes a screenshot when a URL would do, or describes a multi-step Claude workflow without a durable handle. Apply tactics reactively, not as a checklist.

Verbalized Sampling (VS) protocol for deep intent exploration before planning, now mode-aware. Default `exhaustive` mode runs the existing VS protocol verbatim (callers without a mode arg get unchanged behavior). Optional `collaborative` mode runs a two-way tip-sharing dialogue; optional `adversarial` mode walks the design tree one fork at a time with recommendations per question. Mode-selection is hybrid — auto-detect from invoking-context phrasing ("help me refine" → collaborative, "poke holes" → adversarial, otherwise exhaustive) with explicit override via `/askme adversarial|collaborative|exhaustive`. Use when starting ambiguous or complex tasks, when multiple interpretations exist, or when you need to explore diverse intent hypotheses and ask maximum clarifying questions before committing to an approach.

Use this skill when the user wants to wire the `audit-staged` CLI into their repo's pre-commit framework so blocking complexity violations fail `git commit` BEFORE the AI can land them — i.e. set up the post-gate that catches what the in-session PostToolUse hook missed (model retries, `--no-verify` attempts, tool-call shape drift). Triggers on "set up pre-commit", "wire audit-staged", "block AI commits", "audit before commit", "post-gate", "pre-commit gate", "install the commit-time complexity gate", "stop Claude bypassing the hook". This skill PRINTS snippets for the user to copy — it does NOT mutate the consumer's repo.

Use this skill when the user wants to inspect (read-only) the active claude-code-complexity-guard budget — show which `.cogcomp.yml` is in effect, what preset is active, the per-metric `(enabled, threshold, block)` triples for CCS / HSI / DR, and the most-recent entries from the session violations ledger. Triggers on "show my budget", "what preset is active", "view violations history", "view-budget", "what is cogcomp blocking on", "what does my .cogcomp.yml resolve to". Does NOT modify any file — for editing the config use `configure-budget` instead.

Use this skill when the user wants to audit an arbitrary git rev-range (e.g. `HEAD~3`, `main`, a SHA) against the claude-code-complexity-guard CCS+HSI pipeline OUTSIDE a Claude session — for example, before opening a PR, after a manual refactor, or to inspect what a feature branch did. Triggers on "audit my branch", "check complexity since main", "run cogcomp on HEAD~3", "audit-patch", "complexity report for this rev range". Does NOT analyse `.patch` files or stdin diffs — for pre-commit-time staged-content analysis use the `audit-staged` CLI instead.

Use this skill when the user wants to install, change, or inspect the claude-code-complexity-guard config (`.cogcomp.yml`); pick a preset (off/advisory/default/strict); override CCS/HSI thresholds; or stop the hook from blocking certain metrics. Triggers on "configure complexity guard", "change preset to strict", "stop blocking on HSI", "set up cogcomp", "make complexity guard advisory only".

Use this skill when the user asks what a claude-code-complexity-guard metric (CCS, HSI, DR) means, why their edit was blocked, what cognitive complexity is, what helper sprawl is, or how to interpret a violation report. Triggers on "what is CCS", "explain helper sprawl", "why did the complexity guard block my edit", "what does CCS 37 mean", "how does displacement ratio work".