nicknisi

Produce a rich, self-contained HTML explainer for a code change — deep background, core intuition with diagrams, a guided code walkthrough, and an interactive quiz. Use whenever the user asks to explain or deeply understand a diff, PR, branch, or commit — "explain this PR", "walk me through this change", "what does this diff actually do", "make an explainer for this branch" — or wants a shareable document that teaches someone else what changed and why. Output is an HTML file opened in the browser, not a chat reply.

Use when the user is weighing or pressure-testing an idea rather than committing to build it — 'should I do X', 'which of these approaches', 'is this worth doing', 'what am I missing', 'am I overthinking or over-engineering this'. A lightweight thinking partner that surfaces hidden assumptions and argues for the simplest version, in conversation — no files, no spec. Once the idea is settled and the user wants it turned into an actual plan or spec, that's planning work — hand off to the ideation skill if it's available. Not for writing code to a known spec, bug fixes, or refactors.

Read and drive other tmux panes when Claude runs inside tmux. Use whenever the user points at something running in another pane/split/window — their dev server, test watcher, build, logs, REPL, or another shell — e.g. "errors in my dev server", "read/tail my other pane", "is my server up and on what port", "run this in my other split", "restart the watcher". Also for driving interactive/long-running CLIs (Node REPL, vite/next dev, vitest, node inspect) and spawning isolated background tmux sessions.

Socratic tutor that drills the user until they deeply understand a change — the problem, the solution, the design decisions, the edge cases, and what it impacts. Use after completing or reviewing work (a diff, PR, or session) when the user wants to truly own it, not just skim it — or when the user says /socratic-tutor, "teach me what we just did", "quiz me on this", "walk me through this change", or "make sure I understand this". Restates-first, quizzes, and does not stop until the user demonstrates mastery.

Run an extremely strict maintainability review for abstraction quality, giant files, and spaghetti-condition growth. User-invocable only — does not auto-trigger. Use for a thermo-nuclear code quality review, thermonuclear review, deep code quality audit, or especially harsh maintainability review.

Phased maintainability migration that transforms messy, overgrown, or slop-prone repos into product-shaped codebases while preserving behavior. Covers file splitting, typed boundaries, test hardening, feature folders, API consolidation, and a final migration audit microsite. Use when the user asks to "rehab this codebase", "run a maintainability migration", "modernize structure", "clean up this messy repo and make it maintainable", or "productionize this prototype". Unlike codebase-sweep (parallel quick audit), this is a deep, staged refactor with migration planning and checkpoint commits. Do not use for security audits, observability, compliance, or SRE work.

Comprehensive, codebase-wide quality sweep that dispatches parallel subagents to find and fix structural issues. Covers deduplication, type consolidation, dead code removal, circular dependencies, weak types, defensive try/catch, deprecated paths, and AI slop. Primary support for JS/TS projects (knip, madge, TypeScript types); other languages get grep-based analysis. Use when the user asks to "deep clean the whole repo", "run a full codebase audit", "nuclear cleanup", "deslop everything", or "sweep the entire codebase for quality issues". Do NOT use for single-file fixes, branch-scoped diffs (use de-slopify instead), or targeted refactors.

Compact the current conversation into a handoff document for another agent to pick up. Use when the user says "hand this off", "wrap up", "save context", "continue later", "pass this to another session", "I need to stop here", "pick this up later", or when a session is ending with unfinished work. Also use when context is getting long and the user wants to start fresh without losing progress.

Orchestrate full execution of an ideation project — reads the contract, builds an execution manifest, and runs all phases on the deterministic Workflow engine (parallel for independent phases, sequential for dependent ones). Auto-continues on success, gates on failure. Use after ideation is complete and specs are approved.

Execute an implementation spec generated by ideation. Invokes Scout for codebase exploration, builds components with feedback loops, then runs a Verify-Review-Fix cycle with the Reviewer agent before committing.

One-pass ideation for well-understood work: the exact same evidence-gated interview as ideation, then ONE consolidated confirmation (scope tier + run mode), then contract and specs generated without per-artifact approval loops and executed immediately on an isolation branch. Use when the user says 'express ideation', 'one-shot this', 'interview me then just build it', or wants planning that flows straight into execution without reviewing the contract. For exploratory or unfamiliar territory, prefer the full ideation skill — per-artifact review gates earn their keep there.

Generate a /goal command that runs an ideation project to completion UNATTENDED by driving /ideation:autopilot. The /goal is a durability wrapper — it keeps autopilot going across hours/sessions and recovers from failures, while autopilot's Workflow engine does the dependency-ordered dispatch. Reads the contract, builds the /goal, copies it to the clipboard, and prints it. Use when the user says 'goal', 'run as goal', 'goal prompt', or wants to run the project long-haul/unattended rather than watching /ideation:autopilot interactively.

You MUST use this before building any new feature, planning a migration, designing a system, or turning a decided-on idea into a plan. Triggers on: feature requests, project ideas, brain dumps, 'help me plan,' 'spec this out,' 'interview me,' 'I want to build,' 'let's design,' or any unstructured idea you're ready to turn into code. Covers small single-spec projects through multi-phase initiatives. Runs a conversational interview, writes an interactive HTML contract, then generates implementation-ready Markdown specs. This is the planning-HOW stage: if the user is still deciding WHETHER to build — weighing options, pressure-testing a rough idea, 'should I…' — that's the lighter-weight brainstorming skill, and ideation takes over once they've committed to build. Skip ONLY for well-defined implementation tasks (writing code to a known spec, fixing bugs, refactoring, explaining code).

Mine a completed ideation project's implementation notes for generalizable spec-gap patterns and append them to a repo-level docs/ideation/learnings.md, so future interviews and specs learn from past gaps. Reads the project's implementation-notes-phase-*.html, contract.md, and git history; keeps only patterns that would change how future specs or interviews are written; dedupes against existing entries and retires entries the current codebase has invalidated. Use when the user says 'retro', 'run a retro', 'what did we learn', or after an ideation project completes.

Load a context primer for the current repo before starting work. Use when the user says "what was I doing here", "catch me up on this repo", "context primer", "what's the open thread", "where did I/we leave off" — and PROACTIVELY when a session opens on work that clearly continues something ("keep going on the refactor", "finish the migration") or when resuming a codebase after a break. Past sessions carry the open thread, prior decisions, and abandoned approaches that code and git history don't show.

Recall what was done on a specific project or topic from past AI coding sessions. Use when the user says "what did I do on [project]", "recall [topic]", "history of [project]", "when did I last work on [thing]" — but also when they reference prior work without asking for history explicitly: "didn't we already fix this", "what was that approach we tried", "why did we do it this way", "what happened to [file/feature]". Use PROACTIVELY before re-deriving a decision or re-solving a problem a past session likely settled — past conversations hold rationale and dead ends that never made it into git.

Generate a comprehensive summary of AI coding sessions from the past week. Use when the user says "weekly summary", "what did I do this week", "summarize my week", "weekly recap", "week in review", or asks for a summary of recent work across projects.

Show usage metrics and analytics for AI coding sessions. Use when the user asks "how much have I been coding", "session stats", "show me metrics", "tool usage", "which tool do I use most", "active hours", or wants analytics about their AI coding tool usage.

Generate a quick standup summary of yesterday and today's AI coding sessions. Use when the user says "standup", "what did I do yesterday", "daily summary", "what have I been working on", or needs a quick recap for a standup meeting.

Execute an implementation spec generated by ideation. Invokes scout agent for codebase exploration, builds components with feedback loops, then runs a verify-review-fix cycle with the reviewer agent before committing.

Transform raw brain dumps (dictated freestyle) into structured implementation artifacts. Use when user has messy ideas, scattered thoughts, or dictated stream-of-consciousness, or when they want to plan a feature, spec something out, or turn rough ideas into actionable specs. Produces contracts and implementation specs written to ./docs/ideation/{project-name}/.

How to launch and drive Diff Dad for runtime verification — daemon on a scratch port, config/test-connection API, and the single-PR server.