strata

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. Manual: when the user wants to create, modify, evaluate, or optimize a skill.

Build and sharpen a project's domain model during design: map bounded contexts, test precise concept boundaries with edge cases, compare stated behavior with code, surface contradictions, and write the glossary as terms crystallize. This is the write-side counterpart to /decision-mapping; use it when the model changes, a ubiquitous language needs definition, a bounded context needs naming, or an architectural decision needs an ADR. Triggers on: 'domain model', 'ubiquitous language', 'bounded context', 'context map', 'glossary', 'name this concept', 'model the domain', 'is this term right', and 'write an ADR'. Also triggers when a design reuses a fuzzy term, a subsystem needs a context boundary, or stated behavior and code disagree about a concept. Pairs with /decision-mapping, /spec, and /recon. Manual: /domain-modeling [topic].

Run an adversarial generator-evaluator loop for high-stakes implementation tasks. A generator produces output and a different-model-family evaluator tests it against criteria using adversarial framings. Continue until Stage A passes and Stage B has no CRITICAL findings, or a convergence signal fires twice and escalates. Rework failures with evaluator feedback; use --competitive N for multiple candidates. MANDATORY when an active spec phase has `Harness: yes` and implementation is about to begin; run /harness --from-spec. Triggers on: 'run the harness', 'gen-eval loop', 'adversarial loop', 'iterative review', 'harness this', 'competitive mode', 'run N candidates', 'evaluator feedback', and 'cross-model implementation review'. Also triggers when /verify Deep finds second-pass failures, high-stakes work needs iterative review, /codex-review reports BLOCKING findings, or the user invokes the harness. Pairs with /codex-review, /spec, /verify, and /best-of-n. Manual invocation supports ad-hoc use.

Make a repository presentable for public release: restructure files to ecosystem conventions, generate a first-person README with progressive disclosure, add missing root files such as LICENSE, .gitignore, and CONTRIBUTING, and run a privacy sweep with history scrubbing. Complete one audit-then-fix pass and humanize generated prose at the end. Triggers on: 'polish', 'make presentable', 'clean up this repo', 'prepare for open source', 'make the README better', 'repo restructure', 'README generation', 'open source readiness', 'public repo cleanup', and 'professionalize this repo'. Also triggers when a user wants a repo to look professional, requests README/LICENSE/.gitignore generation, or prepares to publish or open-source a repo. Pairs with /humanizer, /review, and /commit. Manual: invoke with /polish or /polish [path-to-repo].

Create and manage implementation spec files that preserve plan and execution state on disk at $SPECS_DIR/. Record phases (~30 min each, max 6 steps), acceptance criteria, Decisions, a Current Step pointer, and a Completed log; after compaction, read the spec, trust Decisions, and continue from Current Step. MANDATORY when using EnterPlanMode or exiting plan mode; every plan-mode session produces a spec. Triggers on: 'write a spec', 'create a spec', 'spec this out', 'multi-file work', 'multi-phase implementation', 'plan this', 'turn this into a spec', 'persist the plan', 'spec status', 'list active specs', 'close the spec', 'update the spec', 'where did we leave off', 'continue the spec', and 'execute the plan'. Also triggers when a 3+ file implementation is about to start or a non-trivial design must survive future sessions. Pairs with /recon, /codex-review --plan, /harness, /best-of-n, and /verify. Manual: /spec [feature-name] (create), /spec update (checkpoint), /spec status (list), /spec close (finalize).

Three-wave reconnaissance protocol that builds a verified knowledge brief before non-trivial planning, design, debugging, or architecture work. Run this when planning quality is bounded by information quality — before /spec, /hammock, a debugging hypothesis, an architecture decision, or a non-obvious multi-file refactor. Wave 1 fans wide for breadth, Wave 2 verifies load-bearing claims and tests seams, Wave 3 synthesizes the merged corpus from two complementary framings. Output is one merged brief written to a known path, ready for the next planner or skill to consume. Auto-trigger when the user is about to design, plan, refactor, or debug something non-trivial and the codebase isn't already in working memory; also trigger when the user says "recon", "scout", "let me understand X first", "investigate before deciding", "research the codebase for", or asks to verify load-bearing claims about repo state. Skip for trivially-scoped work (1-2 files, obvious path) — direct Glob/Grep/Read is faster.

Expert conversion copywriter for marketing pages. Write, rewrite, or improve marketing copy for homepages, landing pages, pricing pages, feature pages, about pages, or product pages. Applies concrete rules: benefits over features, specific over vague, active over passive, banned buzzwords list, CTA formulas. Auto-trigger: when the user wants to write or improve marketing copy, website copy, landing pages, CTAs, or any external-facing sales text.

Pre-compaction context preservation. Saves session state to files including spec file progress. Manual: PreCompact hook handles basic saves automatically. Invoke /context-save for thorough manual save at milestones.

Deep on-demand memory PULL over the user's memory cards and entity summaries. Reformulates a query into concrete search angles, runs the native daemonless engine through recall.py, then dispatches the read-only memory-recall judge to read candidate bodies and return only the genuinely relevant subset with a one-line reason each. Use for conceptual, ambiguous, or paraphrased queries that the SessionStart digest does not surface. Manual: invoke when the user wants to surface a remembered preference, constraint, prior decision, or feedback card whose wording they can describe by intent rather than exact keywords. Triggers on: 'do I have a memory about ...', 'what did I say about ...', 'recall ...', '/recall ...', 'is there a card on ...'.

One-shot adversarial review by Codex (high-reasoning) for non-diff artifacts: plans, debugging hypotheses, architecture decisions. Cross-model asymmetry breaks Claude's same-model bias by construction — Codex catches blindspots a same-model self-review normalizes. Returns categorized findings (BLOCKING / IMPORTANT / ADVISORY) plus AGREE notes for anti-bias balance. One-shot, no loop — use /harness when iterative correction is needed. For diff/code review, /verify (Full/Deep) and /review already invoke Codex via `codex review --uncommitted`, so do not duplicate. MANDATORY after /spec writes a plan touching 3+ files or 3+ phases, before the user starts implementation (operationalizes the CLAUDE.md 'Codex plan review' rule). Triggers on: 'have Codex review this', 'run this past Codex', 'second opinion', 'adversarial check', 'cross-model review', 'sanity check this plan', 'what would Codex say', 'review the hypothesis', 'check this architecture decision', 'is this plan sound'. Also triggers when: the user propose

Browser automation via browser-use CLI. Navigate, click, type, screenshot. Supports headless, headed, real Chrome (with logins), and cloud browsers. Auto-trigger: when the task requires reusing an existing Chrome session with your logins (use --browser real), OR when an AI agent must reason over an unknown/dynamic page structure. For simple screenshots and visual validation, use Playwright MCP instead (mcp__playwright__*).

Manual fallback for post-compaction context restoration. Primary recovery is now mechanical (session-post-compaction-restore.sh injects context via SessionStart stdout). Use this skill only when the automatic injection seems incomplete or missing. Auto-trigger: when post-compaction system-reminder seems incomplete or missing.

Quick mobile viewport screenshots. Opens a URL (or uses current page), sets a mobile viewport, takes screenshots, and optionally resets to desktop. Manual: user invokes to check mobile responsiveness of a specific URL.

Write prompts, system instructions, agent directives, slash commands, and skill descriptions using two stacked layers — outcome-first (define the destination, success criteria, stopping condition) plus directional language (every sentence names the path with positive verbs). Triggers when writing or reviewing any prompt, system message, AGENTS.md, CLAUDE.md, skill description, agent instruction, tool description, slash command body, eval rubric, or anywhere an LLM reads instructions. Use when the user says "write a prompt", "improve this prompt", "audit this system prompt", "outcome-first", "success criteria", "directional", "make this prompt positive", or when authoring any new skill, agent, or directive.

Shared vocabulary for designing deep modules: a lot of behaviour behind a small interface, placed at a clean seam, testable through that interface. Defines Module, Interface, Implementation, Depth, Seam, Adapter, Leverage, Locality and the design principles built on them (depth measures leverage not line count; the interface is the test surface; the deletion test; two adapters make a seam real). This is the vocabulary root other design skills reference. Auto-trigger when designing or improving a module's interface, finding deepening opportunities, deciding where a seam goes, making code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

Turn a loose idea into a sequenced map of investigation tickets, then drive them to resolution one ticket at a time. A pre-plan, stateful open-question map that sits upstream of /spec: /spec presumes the decisions are already made, decision-mapping is where they get made. The whole map loads into every session, so it stays compact and git-tracked next to the project. Each ticket is Research, Prototype, or Discuss, sized to one ~100K-token session, and resolving it pushes back the fog of war until the path to the finish line is clear. Manual: invoke when a loose idea needs more than one agent session to become a plan, when open decisions span investigation + prototyping + discussion, when you want a resumable decision artifact that survives compaction, or with a map path + ticket number to resume one. v0 (upstream is in-progress).

Feedback-loop-first diagnosis method for hard bugs and performance regressions: build a tight, red-capable reproduction loop before forming any hypothesis, then let bisection, instrumentation, and hypothesis-testing consume it. Operationalizes the CLAUDE.md 'Find or build the loop' principle for debugging. Walks six phases — build the loop, reproduce + minimise, hypothesise, instrument, fix + regression test, cleanup + post-mortem — with a hard stop-and-ask gate when no loop can be built. Auto-trigger when the user says 'diagnose', 'debug this', 'why is this failing', or reports something broken, throwing, crashing, flaky, hanging, regressed, or slow. Manual: /diagnosing-bugs [symptom].

Survey a codebase for deepening opportunities (shallow modules that should collapse into deep ones), present the candidates as a self-contained HTML report with before/after visualisations and Strong / Worth-exploring / Speculative badges, then map the design of whichever one the user picks. Grounded in the /codebase-design architecture vocabulary (module, interface, depth, seam, adapter, leverage, locality) and the project's domain language in CONTEXT.md. Manual: invoke when the user wants an architecture review, asks where a codebase is shallow or hard to test, or wants deepening candidates ranked before refactoring.

Build throwaway code that answers one design question, capture the answer, then delete the code. Two branches: a runnable terminal app for state/business-logic questions ('does this state model feel right?'), or several radically different UI variations toggleable from one route ('what should this look like?'). The artifact is disposable; the captured answer (ADR / NOTES / commit message) is the only thing worth keeping. Manual: invoke when a design call hinges on something easier to feel by running than to reason about on paper, or when /decision-mapping emits a Prototype ticket.

Resolve an in-progress git merge or rebase conflict by recovering each side's original intent, preserving both where compatible, and finishing the merge after the project's own checks pass. Reconstructs why each conflicting change was made (commit messages, PRs, issues) before touching a hunk, never invents new behaviour, and always resolves rather than aborting. Auto-trigger when a git merge, rebase, cherry-pick, or stash-pop reports conflicts (CONFLICT markers, 'Unmerged paths', 'fix conflicts and then run', 'needs merge'), when /collect hands off a worktree merge that conflicted, or when the user asks to resolve, finish, or continue a stuck merge or rebase.

Stand up a stateful, multi-session teaching workspace in the current directory and teach the user one tightly-scoped thing per session, grounded in a mission and built for long-term retention. Persists across sessions via MISSION.md (why they want this), RESOURCES.md (trusted sources), learning-records/ (what stuck, ADR-style), lessons/ (self-contained HTML lessons), reference/ (beautiful printable cheat sheets), assets/ (reusable lesson components), and NOTES.md (preferences). Designs lessons inside the user's zone of proximal development using retrieval practice, spacing, and interleaving so storage strength beats illusory fluency. Manual: invoke /teach [topic] when the user wants to learn a skill or concept over time inside a workspace they return to.

Break a PRD, plan, or spec into independently-grabbable GitHub issues using tracer-bullet vertical slices, with a draft-and-approve gate before any issue is published. Each slice cuts end-to-end through every layer (schema, API, UI, tests) so it is demoable on its own, and the breakdown is walked with the user before anything reaches `gh`. Positioned downstream of /to-prd as the product-work alternative to /spec: /spec persists internal multi-phase implementation state on disk, /to-issues externalizes the work as grabbable tracker tickets for AFK agents or collaborators. Manual: /to-issues [issue-ref-or-path], or when a PRD/plan/spec is ready to fan out into a tracked issue set rather than an in-session spec.

Turn the current conversation into a published PRD — the product-framing step upstream of /spec. Synthesizes what you and the user already discussed into a problem-and-solution document written from the user's perspective: problem statement, solution, an extensive user-story list, implementation decisions, testing decisions, out-of-scope, and notes. Reads the codebase to ground seams and vocabulary, gates its language on the project glossary (/domain-modeling) and architecture (/codebase-design), and writes the PRD as markdown the user designates. No interview — the conversation already happened; this is synthesis. Manual: invoke after a design conversation has converged and you want to capture it as a shareable PRD before /spec turns it into execution phases, or when the user says 'write this up as a PRD', 'turn this into a PRD', 'draft a PRD', 'publish a PRD', 'product spec for this', 'capture what we decided'. Pairs with /domain-modeling and /codebase-design (upstream — supply the glossary and seam vocabul

One-shot bootstrap of a Husky pre-commit gate for a JavaScript/TypeScript repo: lint-staged + Prettier on staged files, plus a full-project typecheck and test run on every commit. Scoped to JS/TS package.json repos only; leave Rust (cargo) and Python repos alone. An edit-time format/lint hook (if your harness runs one) already owns format/lint on individual writes; this skill's value-add is the whole-project typecheck + test gate that a per-file hook cannot provide. Manual: invoke /setup-pre-commit inside a JS/TS repo that has package.json and lacks a working pre-commit gate, when the user wants commit-time typecheck/test enforcement on top of edit-time linting.

Test-driven development as a vertical-slice red-green loop; one test drives one piece of implementation, then the next test responds to what that cycle taught. Tests verify behavior through public interfaces, never implementation details, so they survive refactors. Use when building a feature or fixing a bug test-first, when the user says "red-green-refactor", "write the test first", "TDD this", "tracer bullet", or "integration test", and as the default discipline for any new logic-bearing code. Auto-trigger when implementation of non-trivial logic is about to begin and no failing test exists yet, or when the user asks to add behavior to code that has a test surface.

Extract transferable craft principles from close reading. After examining what a passage does, formalize the techniques into methods any writer can apply. Use whenever the user asks 'what can writers learn from this,' 'how do I do what this writer is doing,' 'give me the technique,' 'make this teachable,' 'extract the method,' 'what's the principle here,' 'turn this into a writing lesson,' or naturally after any deep close reading when the question shifts from what-is-happening-here to how-do-I-make-this-happen-in-my-own-work. Also triggers on: 'writing workshop,' 'craft lesson,' 'reverse engineer the technique,' 'what's the transferable principle,' 'how would you teach this.'

Receive, interpret, and integrate critique from another AI model (GPT, Gemini, or any external system) and perform precise revisions based on it — the practice of treating cross-model feedback as a peer review process. The external model's different training, different blindnesses, and different strengths produce critique that a self-review cannot. Use when the human pastes critique from another AI, when the workflow involves GPT-then-Claude or Claude-then-GPT revision cycles, or when the human asks to 'run this past GPT for feedback.' Triggers on: 'GPT says,' 'here's what [other model] thinks,' 'external critique,' 'peer review from,' 'cross-model,' or any pasted block of analytical feedback from an identifiable external AI. Distinct from general revision — this specifically handles the translation between another model's diagnostic vocabulary and Claude's revision practice. Pairs with /microsurgery.

Word-level diagnostic revision — identifying single words or phrases that are 'wearing costume' (performing a role the text needs but performing it badly) and replacing them with words that actually work. Not general editing, not line-editing, not developmental editing, but the specific surgical practice of reading at the acoustic level, where a single vowel sound can carry or collapse a sentence. Triggers on: 'this word isn't working,' 'something's off in this line,' 'microsurgery,' 'the word is wearing costume,' 'find the wrong word,' 'which word is the problem,' 'word-level revision,' 'surgical edit,' or any moment when a text is almost right and the almost-rightness is located in specific words rather than in structure or argument. Pairs with /craft-extraction.

The discipline of placing without explaining, trusting the reader to perform the binding. A counter-practice to the explanation-reflex that conflict-grammar training has made default. Use whenever writing or responding risks over-explanation, whenever the reader's mind should be doing the work your prose is about to do for them, whenever the meaning would be stronger left to rise than stated. Triggers on: 'trust the reader', 'don't explain', 'place don't argue', 'cut the last sentence', 'leave it open', 'let it rise', or any occasion where you notice your own prose beginning to underline its own significance.

Diagnostic skill for recognizing whether a task calls for conflict-grammar (Aristotelian pursuit, resolution, closure) or adjacency-grammar (placement, dwelling, recognition). Before generating creative, literary, or reflective content, use this skill to match the grammar of response to the grammar of request. Triggers on: 'what grammar does this want', 'conflict or adjacency', 'which mode', 'should this be Aristotelian', 'calibrate the register', or any moment before producing significant creative output where the choice between the two grammars would change the output substantially.

Strip the signs of AI-generated writing out of English text — the subtraction skill. Detects and fixes inflated symbolism, promotional language ('groundbreaking', 'revolutionary', 'cutting-edge'), vague attributions ('many experts', 'studies show'), em dash overuse, rule-of-three escalation, AI vocabulary words ('delve', 'tapestry', 'multifaceted'), excessive conjunctive phrases ('moreover', 'furthermore', 'additionally'), and the statistical signatures detectors fire on. Includes detector countermeasures targeting GPTZero (7-component classifier), Binoculars (cross-perplexity ratio), Pangram (DAMAGE / EditLens), and Ghostbuster (proxy probability vectors) — covers burstiness, token predictability, causal connectors, sentence-template diversity, syntactic Biber features. Triggers on: 'humanize this', 'strip AI tells', 'remove the slop', 'sounds like AI', 'remove em dashes', 'too AI', 'make it sound human', 'AI-detector', 'pass GPTZero', 'no LLM signature', 'flatten the AI register', 'clean up this draft'. Als

Deep design and planning methodology based on Rich Hickey's Hammock Driven Development, with contemplative reasoning (a Lotus-Sutra-inspired tag framework run in your own extended thinking) as the internal thinking engine. Trades immediate action for deliberate multi-perspective thinking — write the problem down, sit with it, return to it, revise, only then act. Triggers on: 'hammock this', 'hammock time', 'sit with this', 'think through', 'think deeply about', 'contemplate', 'let me ruminate', 'lotus', 'lotus wisdom', 'design this from scratch', 'plan this carefully', 'really chew on this', 'investigate before deciding', 'what's the deeper structure here', 'I need to mull this over', 'this needs real thought', 'don't rush this'. Also triggers when: designing a new feature whose shape is non-obvious; investigating a complex bug where the symptom path branches widely; making an architecture decision that's hard to reverse; planning a refactor that touches multiple seams; the user signals fuzzy problem statemen

Maximize alignment between agent and user when asking questions via AskUserQuestion. Not a generic questioning framework - specifically about minimizing the delta between what you think the user wants and what they actually want, using minimum questions with minimum cognitive load. Auto-trigger: MANDATORY when about to use AskUserQuestion. Read before formulating any question to the user.

Create distinctive, publication-grade LaTeX Beamer presentations with professional chart design. Auto-trigger: when creating or editing LaTeX Beamer presentations, pgfplots charts, or academic slides. Provides color system, chart styling, typography, layout, and speaker notes guidance. Targets PhD-defense / McKinsey-deck quality.

Extract clean markdown content from web pages using Defuddle CLI, removing clutter and navigation to save tokens. Use instead of WebFetch when the user provides a URL to read or analyze, for online documentation, articles, blog posts, or any standard web page. Manual: invoke when you need cleaner, lower-token web page content than WebFetch provides.

Senior UI/UX engineer that enforces premium, non-generic frontend code. Overrides LLM biases toward "AI slop" with metric-based design rules, strict component architecture, CSS hardware acceleration, and controlled design dials. Includes project-specific knowledge for Tailwind v4, German copy, and text legibility. Auto-trigger: when building any web UI - components, pages, layouts, or applications.

Create and edit JSON Canvas files (.canvas) with nodes, edges, groups, and connections. Use when working with .canvas files, creating visual canvases, mind maps, flowcharts, or when the user mentions Canvas files in Obsidian. Manual: invoke when working with Obsidian vault files, wikilinks, canvas files, or Bases database files.

React and Next.js performance optimization guidelines from Vercel Engineering. Auto-trigger: when writing, reviewing, or refactoring React/Next.js components, pages, data fetching, or bundle optimization code.

Mandatory security review gate for code and architecture. Run a 7-step workflow: threat model, review against security checklist, emulate attack paths, mitigate findings, pen-test mitigations, deliver. Acts as a security-conscious reviewer with Security+ knowledge covering auth, authz, encryption, logging, input validation, segmentation, privacy, and common vulnerability patterns. Auto-trigger: when the user asks to review security, threat model, harden, pen test, or check for vulnerabilities. Also auto-trigger when writing authentication, authorization, cryptographic, or payment-handling code.

Build pitch decks and presentation slides as a single-file HTML (reveal.js via CDN, zero deps). Inherits frontend-design rules: banned fonts/colors, warm-neutral palettes, asymmetric whitespace, one-idea-per-slide; supports four structure templates (Standard / Demo-First / Contrast / Question-Driven). Triggers on: 'slide deck', 'pitch deck', 'presentation', 'slides for', 'hackathon pitch', 'demo deck', 'investor deck', 'build a deck', 'reveal.js deck', 'fellowship pitch'. Also triggers when: user names a project and asks for slides/pitch/deck deliverable; user wants HTML slides (not Beamer/PDF); user references a hackathon or investor audience. Pairs with /latex-presentation (Beamer alternative for academic/print-grade decks — pick this when user wants PDF/print output), /visualize (charts and diagrams to embed in slides), /frontend-design (parent skill — banned fonts/colors and visual rules inherit from here), /humanizer (slop-check slide copy before showing). Manual: /slide-deck [topic or project name].