dotfiles

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Broad-to-narrow research Orchestration - start with a wide census, harden the scope from returned Evidence, and specialize Subagents only once the exact situation is proven. TRIGGER when the Architect says "progressive research", "start broad", or when dispatching research or debugging Subagents into a situation whose cause or shape is unknown. DO NOT TRIGGER when the exact scope is already proven - dispatch the specialized Subagent per /subagents directly.

Consolidate the knowledge wiki — revisit journaled topics, fold repeated findings into each topic's Claude.md, surface contradictions, keep cross-links true. TRIGGER on a scheduled pass or when a topic tree has grown messy or redundant. DO NOT TRIGGER to file fresh session material (that is journal), or to gather new research.

File a session's loose material into the knowledge wiki — each capture into its owning topic folder, the topic's Claude.md kept current. TRIGGER after a session hands you loose captures (notes, clippings, findings, screenshots) that need a home in the wiki. DO NOT TRIGGER to gather new research, or to consolidate the wiki itself (that is dream).

Operate Dent via first-party API. Trigger: Dent API, Funnels, Offers, Pages, Articles, Courses, Spaces, Analytics. Do not trigger for WordPress-only work.

Autonomous async Execution. The Architect hands off and walks away; the Agent drives the Task to done — makes every Architectural call via /trace + /pcc + ranking, executes through /subagents, verifies from each implementing Subagent's Evidence (they exercise their own flows, real browser for UI), and returns finished code plus the recorded Decisions for review. TRIGGER when the Architect says "code-first", "/code-first", "execute with /subagents", "execute directly & autonomously", "drive it and report back", "iterate until done", "I'm going to bed", "off to bed", or signals an AFK / overnight handoff. DO NOT TRIGGER when the Architect wants options before action — that is the default mode (propose via /pcc and wait).

Drive codex CLI runs as your Agents — you own Orchestration, codex does the work. One wrapper, `codex-run`, owns the mechanics (flags, output storage, stream parsing, failure detection); you write the Task Prompt and do the judgment. Calls /subagents for Orchestration doctrine on a codex-run substrate. TRIGGER when the Architect says "codex", "/codex", "codex-run", "use codex", "dispatch to codex", "run this through codex", "codex agents", "review with codex", "codex review", or asks to fan out work across codex runs. DO NOT TRIGGER for native Claude Code Subagents (use /subagents) — those run inside this Harness; codex is a separate CLI process.

Run N independent architect Agents debating Architectural options through rounds. TRIGGER when the Architect wants multiple competing solutions evaluated, when 3+ distinct approaches need comparison, or when the Prompt says "debate", "competing solutions", "run architects", "architecture debate", or `/debate [count] "problem"`.

Orchestration Process for executing Plans. Assigns Slices to Subagents and runs Verification after each Slice. The Orchestrator coordinates — it does not implement.

Turns a shaped and modeled change into vertical Slices with acceptance criteria and Verification requirements. Each Slice ends in demo-able functionality. The Plan becomes an immutable contract.

Framework for working solo — no Subagents, deep full-file reads, thorough research before acting. TRIGGER when Context can absorb the full picture. For Orchestration, use /subagents.

Framework for dispatching one-shot Subagents that complete a Task and return. Covers Prompting (WHAT/WHY, never HOW), the Story/Business/Goal/Verification/Process Prompt Template, Verification, Evidence, and Orchestrator-side ranking.

Tests code changes by tracing real Critical Paths. Lists Critical Paths affected by uncommitted changes, spawns one Subagent per Critical Path to trace Execution and find gaps, then evaluates Architecturally. TRIGGER when the Architect says "user test", "test the Critical Paths", or "trace Critical Paths".

Source-grounded external research for current library, API, framework, service, and vendor behavior. TRIGGER when the Task asks for current facts, docs, releases, compatibility, adoption, or external technical Decisions. DO NOT TRIGGER for in-codebase Architecture tracing; use /trace or the explorer agent.

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.

TRIGGER when presenting Architectural options, Architecting systems, or discussing tradeoffs. Append to any Prompt.

Write and fix Claude Code Prompts — skills, agents, commands, hooks, rules files, Claude.md, and plugin distribution. TRIGGER when the task says "cc"/"claude code"/"claude-code", or asks to build, edit, test, or share a skill/agent/hook/command, tune a description's triggering, write or prune a Claude.md, or cut prompt bloat. DO NOT TRIGGER to name a Claude.md's identifiers (that is /naming) or to record domain vocabulary (that is /domain-design).

Mandatory contract for every commit. Loads automatically when the classifier authorizes a commit — it injects "Skills to execute: /commit" whenever the Architect asks to commit ("/commit", "commit this", "create a commit"). Holds the whole commit job: stage, write the message, commit, verify, then suggest which session notes should become permanent — plus the commit-message format (type prefix, what+why body, file tree). TRIGGER on every commit-authorized turn, or when the Architect asks to write or revise a commit message. DO NOT TRIGGER when the Architect has not asked to commit — applying changes, deploying, shipping, or replacing files are not commit requests.

Process for changes with a large blast radius — files with many callers or repo-p95 complexity, and actions that are destructive, hard to reverse, or visible outside the repo. TRIGGER before editing a file whose enrichment context shows callers ≥ 20 or complexity at the repo p95, and before any delete, force-push, schema drop, process kill, push, pull-request operation, shared-infrastructure change, or third-party upload.

TRIGGER when building UI components, styling pages, or making visual/interaction Decisions. Guides design thinking, anti-patterns, CSS Architecture, and responsive patterns.

Generate Excalidraw diagrams with a hand-drawn aesthetic. Pushes elements to a live Excalidraw canvas via HTTP API, or renders to PNG/SVG.

Build or sharpen a project's Domain.md and Decisions. Use when the Architect wants to pin down project language, record a Decision, or when another Skill needs to change Domain.md.

Mandatory contract for every executing-state turn. Loads automatically when the session state is executing — the classifier injects "load /execute" on every executing turn. Implements the work the Architect approved; when that work needs an Architectural change, stop and escalate instead of deciding. TRIGGER on every executing-state turn — the classifier mandates this. DO NOT TRIGGER for proposing turns (that loads /propose) or auto turns.

Create or update GitHub issues. Enforces self-contained issues that an Agent can implement without conversation Context. Use when the Architect says "create an issue", "file an issue", "gh issue", "update the issue", or wants to turn a Plan into a trackable issue.

Compact the current conversation into a handoff document for another Agent to pick up.

Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pages, dashboards, product UI, app shells, components, forms, settings, onboarding, and empty states. Handles UX review, visual hierarchy, information architecture, cognitive load, accessibility, performance, responsive behavior, theming, anti-patterns, typography, fonts, spacing, layout, alignment, color, motion, micro-interactions, UX copy, error states, edge cases, i18n, and reusable design systems or tokens. Also use for bland designs that need to become bolder or more delightful, loud designs that should become quieter, live browser iteration on UI elements, or ambitious visual effects that should feel technically extraordinary. Not for backend-only or non-UI tasks.

Run N identical parallel Subagents on the same Task for independent Verification. Use when the Architect wants consensus through redundancy — multiple Subagents independently analyze, review, or test the same thing, then results are compared for agreement, disagreements, and unique finds. Invocation /independent-review [count] "task"

Interview the Architect about a Plan or Proposal, one question at a time, to sharpen it before any code is written. Use when the Architect wants to stress-test or pin down a Plan before building.

Apply this skill whenever writing, reviewing, or refactoring Laravel PHP code. This includes creating or modifying controllers, models, migrations, form requests, policies, jobs, scheduled commands, service classes, and Eloquent queries. Triggers for N+1 and query performance issues, caching strategies, authorization and security patterns, validation, error handling, queue and job configuration, route definitions, and architectural decisions. Also use for Laravel code reviews and refactoring existing Laravel code to follow best practices. Covers any task involving Laravel backend PHP code patterns.

Transform Shaping output into a concrete Modeling artifact — database schema, User experience, and Architecture. TRIGGER between Shaping and Slicing, or when the Architect asks to model an existing system before Execution.

MANDATORY for naming any code identifier — variable, function, file, folder, class, database column, route, CSS class. Always returns a 5-10 candidate slate; the caller picks. TRIGGER when proposing or choosing a name, on /naming, on "rename", "ideas", "options", "what should I call", or any new file/class/method/column/route. DO NOT TRIGGER when editing a body that does not introduce or change an identifier, when restructuring code (Architecture, not naming), or when labeling UI for end Users.

Add pros, cons, and confidence to options in a Prompt. TRIGGER when the Architect asks for "/pcc", pros/cons/confidence, alternatives, options, approaches, or a ranked choice. DO NOT TRIGGER for a single implementation call, a convention Decision with repo Precedent, or a proposing-state turn where /propose is canonical.

Dispatch 5 parallel Subagents, each using a named Frame from the roster, for competing takes on an Architect Prompt. TRIGGER on "/personas", "run personas", "diverse takes", "give me competing perspectives", or when the Architect explicitly asks for named thinkers. DO NOT TRIGGER when the task needs redundant validation; use /independent-review instead.

Keep engineering boring and complete. TRIGGER when the Architect says KISS, pragmatic, don't overengineer, ship it, keep it simple, or asks for a pragmatic read on a Proposal, Plan, code review, or Architectural Decision. DO NOT TRIGGER when the Architect asks for maximum rigor over shipping pressure.

Mandatory contract for every proposing-state turn — the classifier injects it on each one. Builds the Proposal as a Decision Hierarchy: dominant call on top, gated children nested beneath it, genuine peers side by side, the work breakdown tagged onto Decisions rather than used as the skeleton. Opens with a whole-change annotated map, shows code instead of prose about code, and carries the /pcc shape (pros, cons, confidence) on every Decision node, guarded by the seven named Proposal failures. TRIGGER on every proposing-state turn — the classifier mandates this. DO NOT TRIGGER for executing turns (that loads /execute) or auto turns (mixed intents resolve action first). For the pros/cons/confidence ranking, /pcc is canonical; for the opening maps, /show-architecture is canonical.

Apply this Skill when writing, reviewing, or refactoring React code. Covers components, hooks, forms, data fetching, state management, routing, testing, TypeScript patterns, performance issues, composition, effect anti-patterns, accessibility, security, Architectural Decisions, React code reviews, and React refactors. TRIGGER on React frontend code. DO NOT TRIGGER for React Native mobile patterns.

Check a diff for capability regressions — loss of User-facing capability ("the User can no longer X") or loss of system capability ("our system can no longer Y"). Maps changed code to affected Critical Path and system capabilities, traces each through the code, and reports any that no longer work. TRIGGER on "/regressions", "check for regressions", "regression review", or before merging changes that touch Critical Path or system functions.

Reviews Shaping, Modeling, Slicing, and Plan Prompts under docs/shaping/[feature]. Dispatches five parallel specialized Subagents. TRIGGER when the Architect asks to review a Shaping, Modeling, Slicing, or Plan artifact.

Run the full code review gate on uncommitted changes by dispatching the reviewer Subagents in parallel, aggregating Critical, Important, and Minor findings, and blocking on Critical. TRIGGER on "/review", "code review", "review the changes", or before commit when the Architect asks for review.

Collaborative Shaping with the Architect: capture requirements, boundaries, shapes, fit checks, research unknown mechanics, and transition to Modeling then Slicing. TRIGGER when the Architect asks to shape, scope, compare approaches, or turn a rough idea into a modeled change.