skills

Create interactive UI prototypes with a CDN-only stack built from z-proto, HTM UI, Tailwind CSS v4, Preact/htm, and preact-iso, including faithful send-to-Figma captures when requested. Use when asked to prototype, create mockup screens, explore an interactive UI flow, or validate product behavior before implementation.

Initialize, migrate, or refresh a repo's ai-memory wiring: the .ai-memory.toml routing marker (workspace/project), the recall/write routing snippet in CLAUDE.md/AGENTS.md, the ai-memory MCP server entry, and the global capture hooks. Includes the qmd→ai-memory migration for repos still on the old wiki/qmd stack, and a refresh flow that detects CLI↔server version skew and re-stages hooks to parity. Use when the user asks to set up ai-memory in a project (greenfield or brownfield), wire the MCP, enable auto-capture, migrate off qmd, diagnose with doctor, or upgrade/refresh an existing setup (local CLI + hooks) to the server's version.

Toggle "minions mode" — you become a coordinating agent that delegates all real work to background Codex minions (the codex:codex-rescue subagent) while you brief, verify, and own the git flow. Enforced by hooks that inject a coordinator directive on every prompt and deny direct Edit/Write outside coordination files. Use to turn the mode on/off/status, or to install/refresh its hooks. Superseeds the older "orchestrator" naming (which stays as a compatibility alias).

Catalog + orchestrator for a web application's usage (E2E) flows. Keeps the project's flow definitions and hands them, ONE at a time, to the `ux-persona` skill to validate usability in the browser. Use to "list the flows", "validate all flows as a user", "run the usability walkthrough", "create a new usage flow", or run flow walkthroughs with Webwright-style replayable evidence.

Embody a user persona and walk through ONE usage flow of a web application THROUGH THE UI (starting from the flow's entry point, never typing internal URLs), judging whether the journey is usable and recording actionable findings. Takes the flow as an argument. Use when you want to "test as a user", "check if it's usable", "walk flow X as a persona", "validate the usability of a screen/journey", or run a flow with Webwright-style replayable screenshots/log evidence.

Author and edit Excalidraw scene files (`.excalidraw`): the JSON element model (rectangle, text, arrow), two-way arrow binding, ids/z-order, coordinates & sizing, groups, and reading/updating an existing scene. Two paths — by hand for small scenes/edits, or programmatically via `scripts/` which builds scenes with Excalidraw's own `convertToExcalidrawElements`, renders a faithful preview with `exportToSvg`, and lints geometry. Use whenever you create or modify a `.excalidraw` file directly (not through the editor UI). Mermaid is a supported INPUT for standard diagrams, not the file format.

Check your work with a verification sub-agent that runs direct oracles first (build/test/typecheck/lint/run-the-app), re-reads the changed code, and returns a schema-validated PASS/FAIL verdict — not prose to grep. Spawns one verifier for small diffs, or parallel lenses (BARRIER) for larger or security/auth/data-boundary changes, then fixes issues and re-verifies under a SEEN ledger until it passes. Use when asked to "check work", "verify changes", "self-verify", "/work-check", "/check", "/verify", or "/self-verify".

LOOP-shaped discovery pattern: repeat rounds of parallel finders (bugs, edge cases, sites, opportunities, missing items) until K consecutive *qualifying* rounds produce nothing new. Each round is a parallel fan-out + a real dedup BARRIER against a persistent seen[]; an oracle gates the seed, every item, and final completeness. Use when the total size of the set is unknown: "find all X", "enumerate edge cases", "discover all places that do Y". Invoke via /work-exhaust.

After one or more discovery or analysis rounds, explicitly asks "What is still missing?" Modalities not swept, claims not verified, sources not read, edge cases not considered, downstream effects not traced, assumptions not checked. The output becomes the seed for the next round of work (more angles, more verification, more research). Use near the end of Research, Review, or Understand phases, or before declaring a task complete. Invoke via /work-gaps.

Generative multi-approach design or solution panel. Generates N independent candidate solutions from different angles (MVP-first, risk-first, user-first, performance-first, etc.), has parallel judges score them on multiple dimensions against re-read evidence, then synthesizes the winner by grafting the best ideas from the losers. Use for "which approach?", architecture decisions, design problems, "best way to implement X". Settles by direct oracle / throwaway prototype before convening the panel where possible. Invoke via /work-judge.

Adversarial verification ("try to refute") of a claim or a SET of claims/findings/root-causes/design-decisions using N independent sub-agent refuters per claim. Runs as a PIPELINE (each claim's refuter-group is independent — no barrier across claims) with perspective-diverse lenses as the DEFAULT for security/auth/multi-tenancy/data-integrity/correctness claims. Survival is EVIDENCE-WEIGHTED, not naive majority: only verdicts that re-read the cited source count; lazy/empty verdicts are abstentions. Strongly prefers direct deterministic oracles (commands, tests, git, type checks, exact grep) over agent voting. Use when the user says "adversarial verify", "refute this", "have verifiers attack", "perspective-diverse review", "run adversarial checks on these findings", "ultracode verify", or "kill this claim".

Run an extremely strict maintainability review of the current diff for abstraction quality, giant files, duplication, layering leaks, and spaghetti-condition growth. Measures with oracles before opining, applies diverse review lenses, and sweeps outside the diff for completeness. Effort tiers: low/medium → fewer lenses, highest-confidence findings only; high → all lenses + completeness sweep; ultra → fan lenses across files in parallel. Use for a deep code quality audit or an especially harsh maintainability review.

Autonomous quality meta-skill / "quality brain" (also invocable as /ultracode and /quality-orchestrator aliases). Proactively orchestrates a rigorous, multi-phase quality workflow on any medium/high complexity implementation, review, fix, research, design, audit, or work involving judgment, unknown scope, risk, multiple findings, or non-trivial trade-offs — without the user having to ask. It self-assesses complexity, prefers direct deterministic oracles first, chooses phases (Understand/Design/Review/Research/etc.), composes the right patterns (work-refute with lenses, work-judge, work-exhaust, work-sweep, work-gaps, work-tournament, work-check, work-review), applies all execution mechanics (structured output + retry, worktree isolation, null-handling, concurrency/budget caps, journaling/resume, no silent caps, log/phase via todos), and drives the workflow visibly. The agent is expected to decide on its own at checkpoints (after significant edits, before marking complex todos done, at phase boundaries, when f

Parallel blind search from multiple independent angles (by structure/files, by content/semantics, by git history/time, by entity/domain, by error paths, alternative-storage-paths, config/realm dimensions, etc.), then a BARRIER at the merge step that dedups against a persistent SEEN set and lists what no angle covered. Each searcher is kept ignorant of what the others found in the same round. Use when one search strategy is known to be incomplete: "find all X", security review, "where can this break?", data flow tracing. Invoke via /work-sweep.

Implement a task N ways in parallel and pick the best — by OUTCOME, not by pitch. Spawns N sub-agents in isolated git worktrees, each from a DISTINCT angle, gates every candidate through a per-candidate oracle (build + typecheck + test + lint), grades survivors from the ACTUAL diff (never the self-report), runs a completeness sweep on the winner, applies it to main, and re-verifies the oracle green before declaring a winner. Use when asked to "best of n", "try multiple approaches", "parallel implementations", "/work-tournament", or "/bon".

Guide TDD workflow and testing strategy. Use when implementing features with tests, writing new tests, or establishing test coverage. Triggers on "TDD", "write tests", "test coverage", "red-green-refactor".

Manually recall durable knowledge from an ai-memory instance via the MCP (semantic/hybrid search, recent pages, prose catch-up). Use when the user asks to search the memory, 'have we done/decided X', 'what's the state of Y', or 'catch me up' — and you want an explicit recall rather than waiting for the auto-handoff.

Manually write a durable page to an ai-memory instance via the MCP (memory_write_page) — for decisions, rules, gotchas, schemas/contracts, or operational constraints the user explicitly wants remembered. Use when the user says 'remember this', 'save this decision', or 'annotate X'. Not for routine notes (auto-capture handles those).

Capture a rendered local web page or app screen into the clipboard for pasting into Figma using the official html-to-design capture.js flow. Use when the user invokes /figma-capture, asks to copy the current browser page to Figma, asks for a dev-only Figma capture button, or asks whether figma_key/captureId is needed for Figma HTML capture.

Structures large initiatives into a decomposed backlog with roadmap, dependencies, and verification. Generates an overview file plus individual story files with tasks. Use when work requires several coordinated stories, has dependencies between deliveries, or needs a roadmap.

Structures new and vague problems into clear intake documents. Use when the problem is not yet mature enough for the backlog, when someone brings an idea or need without defined scope, or when you need to decide what the next artifact in the flow should be.

Consolidates objective metrics of a sprint. Use when you need quantitative data about deliveries, blockers, deviations, and velocity to feed retro, sprint review, or capacity decisions.

Onboarding guide for new team members in the agile flow with AI. Use when someone new joins the team and needs to understand how the planning, execution, and tracking flow works with AI agents.

Validates planning artifacts and reviews code for quality, consistency, and completeness. Use to lint planning documents (cross-references, dependencies, format) or to review changed code (security, coherence, scope, quality).

Conducts retrospective with learnings and improvement actions. Use when a cycle, sprint, or delivery has ended and the team needs to reflect on what worked and what needs to change. Also absorbs post-implementation reflection aspects.

Prepares sprint review and demo of deliveries for stakeholders. Use when the sprint has ended and it is necessary to present what was delivered, what changed in scope, what is pending, and what decisions are needed.

Maps multi-phase trajectories with dependencies into clear, sequenced roadmaps. Use when work has multiple phases that need sequencing, when decisions today affect future decisions, when stakeholders need to see the whole journey, or when external dependencies exist. Applicable regardless of total duration — a 4-week multi-phase initiative benefits as much as a quarterly roadmap.

Routes to the appropriate agile skill based on context. Use when you need guidance on which skill to use — whether for planning, ceremonies, or tracking.

Captures real usage feedback for agile skills and turns it into evidence-backed proposals to improve, merge, split, deprecate, or remove skills and templates. Use when a skill does not fit a real workflow, when templates need refinement, when skills overlap, or when the process library needs maintenance.

Plans sprint by selecting items from backlog, defining objective, capacity, and execution order. Use at the beginning of a work cycle to align what will be done.

Tracks delivery progress in three modes — checkpoint (daily), consolidation (period report), and closure (post-implementation). Use when you need to record progress, consolidate a period, or formally close a delivery.

Creates execution plan with tasks for a single story or a localized standalone change. Use when the work fits in one cycle — either a story already scoped by an epic, or a small/localized change that doesn't need decomposition.