skills

A grilling session that stress-tests a plan against the project's documented domain model — sharpens fuzzy terminology, challenges it against the existing glossary, cross-references it with the code, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallize. The domain-aware variant of grill-me — use this instead when the repo has (or should have) a CONTEXT.md glossary or docs/adr/ decision records. Triggers include "grill with docs", "stress-test this against our domain model", "does this match our language", "check this against our glossary", "grill this and update the docs", or any time a non-trivial plan needs to be reconciled with the project's documented decisions.

Compact the current conversation into a handoff document so a fresh agent can pick up the work without re-deriving context. Writes a self-contained brief to the OS temp directory — what's been done, what's left, key decisions, gotchas, and which skills to invoke next. Use when the user says "handoff", "write a handoff", "hand this off", "compact this for a new session", "summarize this for another agent", "I'm running low on context", or is about to start a fresh session on the same work. Takes an optional argument describing what the next session will focus on.

Auto-grill a plan, spec, or ticket by running Claude and Codex as interrogator/answerer pairs instead of interviewing the user. Two modes — relay (iterative back-and-forth between Claude and Codex) and parallel (two swapped streams merged into one spec). Produces a pre-chewed artifact where the user only reviews the result, not sits through the interview. Use this skill whenever the user says "cookoff", "pre-grill this", "have codex grill it", "dual grill", "grill this without me", "run grill-me with codex", "cross-examine this plan", or wants the ambiguity-resolution work done autonomously before they review. Also use when the user has a plan/spec/PRD that would normally go through max:grill-me but explicitly wants to skip being interviewed themselves. Supports `--to-tickets` to emit the grilled spec as Dahso Agent Tickets ready for `/go`, and `--to-tickets --go` to chain straight to `dahso:go` without a review pause.

Ship a Claude Code plugin update — detect the plugin, determine the version bump, update plugin.json and CHANGELOG, stage surgically, commit, push, and (for multi-branch repos) merge to the default branch via a worktree. Prints the /plugin update and /reload-plugins commands for the user to run in Claude Code. Use this skill whenever the user has finished editing a plugin's skills and wants to publish the changes, or says "release the plugin", "ship the skill update", "publish this", "bump and push", "push the new version", or any phrase about getting plugin changes live. Also use this preemptively whenever you're about to commit changes inside a `.claude-plugin/` or `plugins/*/` directory — the version-bump step is the most-forgotten part of the workflow and silently leaves changes unshipped.

Interview the user relentlessly about a plan, spec, or ticket until every branch of the decision tree is resolved. Produces a per-dimension ambiguity report (Goals / Acceptance / Boundaries / Alternatives / Assumptions) and an aggregate gate. Use this skill whenever the user is drafting a spec, proposing a design, debating an approach, or describing work to hand off — even if they don't say "grill me". Explicit triggers include "grill me", "stress-test this", "am I missing anything", "what are the risks", or any time a non-trivial plan is being finalized. Also invoked as a subroutine by max:write-prd Phase 5, max:tech-spec Phase 6, max:improve-codebase Phase 5, bugbook:flow Phase 2d, bugbook:prep Phase 3, and bugbook:ticket Phase 2d.

Test-driven development with red-green-refactor discipline and vertical-slice tracer bullets. Use this skill whenever the user is building or fixing code in testable layers — parsers, formatters, services, pure functions, data models, CLI commands — even if they don't explicitly say "TDD". Triggers include "add a feature to the parser", "fix a bug in the formatter", "implement this utility", "write tests for X", "test-driven", "red-green-refactor", or any time the user is about to write logic that has a clean public interface. Skip for SwiftUI views, animations, visual polish, and system-framework integrations (EventKit, Core Data) where smoke tests and computer-use verification are more honest — the skill body has a "when NOT to TDD" section explaining the boundary. Use max:verify-before-done for the non-testable cases.

Turn a PRD into a technical implementation spec. Bridges the "what and why" of a PRD and the "how" an agent needs to execute. Module decomposition with deep-module emphasis, sequencing by tracer-bullet principles, and a grill gate before exit. Use when the user says "tech-spec", "write a technical spec", "turn this PRD into a plan", or after /write-prd when the next question is "how do we actually build this?".

Prevent false "it works" claims. Before declaring anything done, fixed, or passing, run the verification that actually proves it. Three-level evidence rubric (Mechanical / Behavioral / Consensus) with red flag detection for phrases like "should work", "looks good", "probably passing". Use this skill whenever you or the user is about to claim something is complete, fixed, working, or passing — even if the user hasn't explicitly asked for verification. Triggers include "I fixed it", "it works now", "tests are green", "ready to merge", "deploy it", or any claim of success that lacks an observable signal. Also invoke when reviewing agent output before committing or when an agent is about to set a ticket to Review/Done status.

Turn a vague idea into a grounded PRD through user interview, codebase exploration, and Socratic drafting. Passes through the grill-me ambiguity gate before exit. Use when the user wants to write a PRD, spec out a feature, turn a meeting transcript into a plan, or says "write-prd", "write a PRD", "spec this out", "let's PRD this", "turn this into a spec". Also invoked by workflow orchestrators like bugbook:flow to produce the spec phase of a larger workflow.

Explore multiple radically different interface designs for a feature in parallel before committing to one. Uses parallel sub-agents to generate distinct approaches so you can compare tradeoffs rather than anchoring on the first idea. For UI/UX interface work specifically — not API interface design. Use when the user says "design-interface", "let's explore some designs for X", "what are the options for this screen", or before building any non-trivial UI.

Architectural review and improvement proposals. Reads the codebase for structural opportunities — shallow modules that should be deepened, leaky abstractions, misplaced complexity — and proposes specific changes with tradeoffs. Uses a four-persona pass (Contrarian, Simplifier, Architect, Hacker) to stress-test proposals before presenting. Not a refactoring bot; it produces proposals, not commits. Use when the user says "improve-codebase", "architectural review", "where is this codebase weak", or before starting a big refactor.