skills

Iterate a UI/UX surface with a human — at the highest fidelity the target can honestly afford — and climb from a quick sketch up to a runnable prototype, all in one loop. It is medium- and stack-agnostic: the surface can be a screen (web / iOS / Android / desktop), a terminal UI, a spatial/VR scene, or a voice/audio flow, and the skill discovers the medium and stack at runtime (no per-platform code baked in). Use whenever the user wants to sketch, mock, wireframe, lay out, or prototype an interface or flow before/while building it: "sketch this screen", "mock up the X flow", "wireframe it", "show me the UI", "prototype this", "design the onboarding", "what should this look like", "let me see it running", "draft the voice flow", "lay out the VR scene". It runs a flow-map → render → self-critique → show → "type accept to lock" loop (the loop only ends on the literal word `accept`), climbs a fidelity ladder (text sketch → static visual → live preview → real-target run) only as far as the available tooling truly

Backward root-cause debugging: start from an observed defect and work to a PROVEN cause — never a guessed one. Use whenever something is broken and you need to know WHY before fixing: "why is this failing / broken", "debug this", "find the root cause", "this test is flaky / passes alone fails in the suite", "it crashes / errors / returns the wrong thing", "this regressed", "track down this bug", "what's causing X", a stacktrace, a failing CI run, a heisenbug, a perf regression, a prod incident from logs. It is the inverse of the build skills: the cause is UNKNOWN and the work is abductive elimination. It refuses to name a cause until the cause reproduces on demand, vanishes under an isolated control, and returns when un-controlled — killing hypotheses only by evidence that forbids them, never by plausibility. It stops at "cause proven + minimal fix proposed + handoff" and does NOT build the fix (that's autopilot's or your job). Stack-agnostic via runtime discovery (no per-stack hardcode); on a bounded-exhaust

Stress-test a spec or design doc BEFORE writing code by mentally executing it end-to-end — acting simultaneously as every component (data stores, caches, services, clients, external systems, transports), tracking explicit state diffs after every step, and running golden, edge, and adversarial scenarios until findings settle to LOW severity. Use this skill whenever the user has a spec / design doc / RFC / PRD and wants to validate it before building: "simulate this spec", "stress-test this design", "act as every component", "walk through every flow", "pretend you are the whole system", "find the holes / races / edge cases in this design", "is this spec internally consistent", "check for ambiguities / contradictions / missing rules before we implement". It runs a spec-analyzer → parallel scenario-simulators → findings-aggregator loop autonomously (no questions mid-run), one file per scenario, and produces a deduped, severity-ranked FINDINGS.md. Best for any non-trivial design with state, concurrency, auth, mone

Turn a fuzzy product idea into a precise, written feature spec / PRD BEFORE any code — by interviewing the user with plain-language PRODUCT questions only and deriving every technical decision automatically from the existing codebase (never asking the user a tech question). The output is a single SPEC.md with a hard wall: narrative product behaviour on top (reads like a PM wrote it), a derived technical appendix sealed at the bottom (reads like an engineering handoff). Use this whenever the user wants to spec a feature, write a PRD, formalize requirements, design a flow, document how a behaviour should work, or turn a vague ask into a contract before implementation: "spec this", "write a spec for X", "design the X flow", "PRD for X", "how should this feature work", "let's spec out X", "formalize requirements for Y". Runs a codebase-context agent (reads the repo) + a product-interviewer loop (open-ended questions until coverage converges) + a spec-writer agent. Best for any non-trivial feature where the produc

Universal autonomous feature/project builder: turns roughly one prompt into a whole working feature or project — maximum code, minimum ceremony — without shipping confidently-wrong garbage. Use this skill whenever the user wants something built end-to-end autonomously from a prompt or a spec/design doc: "build the whole X", "implement this entire feature", "scaffold and finish this project", "ship this from the doc", "do the whole thing", or when they say autopilot / build it all / one-shot it. Also use when a feature is described by a doc/issue/PR and the user wants it driven to done in one pass. It runs a premise-gate (refuses to build the wrong/redundant thing), a shared classification bus (so high-blast decisions can't be silently defaulted), skeleton-first scaffolding, an acceptance+invariants oracle, a bounded convergence loop, a human-judgment feedback gate for aesthetic/irreversible slices, and salience-ranked disclosure. Best for substantial multi-file builds, not trivial one-line edits.