dotfiles

Create one immutable, single-agent technical implementation plan from a fixed spec diff, limited to behavior still missing at the fixed head. Use when a feature, fix, migration, or refactor has approved spec changes and needs a sequential implementation plan before execution is divided or orchestrated.

Divide an explicit immutable implementation plan into context-sized TDD slices and operate a recoverable Herdr execution ledger through independent test-quality and final reviews. Use when a create-plan artifact is ready for isolated implementation, verification, integration, remediation, or interrupted execution recovery inside Herdr.

Bootstrap a specs/ folder with a language-agnostic specification suite for defining business rules, logic, and requirements. Conducts a grill-style interview to discover systems, bounded contexts, and terminology, then generates SPEC-OF-SPECS, README, ubiquitous language, design language, skeleton specs, and a progress tracker. Use when starting a new project, onboarding AI agents, creating a specification suite from scratch, or initializing specs/ for any project. Supports greenfield (generate directly) and brownfield (generate PLAN.md for agent-driven spec extraction from code).

Curate durable agent improvements from a human retrospective, current session, recent history, git activity, skills, docs, specs, and plans. Use when the user runs /curator, asks what should be learned from a session, wants compounding engineering recommendations, asks to steer recommendations with a retrospective, or asks whether to add, update, remove, rename, refactor, or consolidate skills or docs.

Interview the user relentlessly about a plan or design until shared understanding resolves every consequential branch, using project terminology and evidence. Use when stress-testing a plan, probing a domain model, resolving design decisions, or when the user says "grill me."

Launch and reliably coordinate Claude Code in Herdr by composing the base Herdr transport skill, handling readiness, explicit prompt submission, concurrent completion/blocking observation, and evidence-driven steering. Use when a caller selects Claude Code as a Herdr worker or reviewer.

Control herdr from inside it. Manage workspaces and tabs, split panes, spawn agents, read output, and wait for state changes — all via CLI commands that talk to the running herdr instance over a local unix socket. Use when running inside herdr (HERDR_ENV=1).

Audit skills in shared/skills/ for cross-agent frontmatter compatibility, flagging missing fields and offering to fix them. Use when skills have been added via npx or manually and need to be checked for compatibility across Claude Code, Codex, Pi, and Copilot CLI.

Create, update, audit, and validate Google DESIGN.md files for AI coding agents from existing UI, CSS, assets, screenshots, or design direction. Use when the user asks for DESIGN.md, design.md, an agent-readable design spec, design tokens, visual design contracts, or wants UI agents to follow an existing product style.

Automate browser interactions, scripted capture, and Playwright test workflows. Use when the task specifically calls for Playwright, deterministic browser automation, Playwright recordings, or working inside an existing Playwright test setup.

Convert a recording into reviewable evidence such as trimmed clips, contact sheets, and focused crops. Use when the input is a browser demo, gameplay clip, Playwright WebM, screen recording, or local app video that needs frame-sampled review artifacts.

Design deep modules and their interfaces using shared architecture vocabulary. Use when designing or improving an interface, choosing a seam, comparing module shapes, improving testability, or when another skill needs deep-module guidance.

Generate and maintain an AGENTS.md codebase map that prevents hill climbing by surfacing module boundaries, dependency rules, anti-patterns, and coding principles. Use when creating an AGENTS.md for a new project or updating an existing one as the codebase evolves.

Creates interactive, codebase-accurate HTML explainers for any concept in a software project. Asks the engineer about experience level and specialty to tailor analogies, depth, and code density. Includes a mandatory reviewer pass that independently discovers source files to verify factual claims. Use when the user wants to understand how a system or feature works across code boundaries, create onboarding docs, build interactive learning materials, or explain a complex flow to a teammate.

Acts as an engineering manager to help you build fluency in a codebase's language and ecosystem. Use when you want to learn a new language/framework by doing real work on a real codebase, prepare for interviews, or build hands-on fluency through structured TDD tasks.

Find deepening opportunities in a codebase and always present a visual HTML review with before/after diagrams and candidate comparison. Use when improving architecture, consolidating shallow modules, reducing coupling, or making a codebase more testable and AI-navigable.

Build a durable, mission-grounded teaching workspace with researched resources, reusable HTML lessons, retrieval practice, and learning records. Use when the user wants to learn a topic or skill over multiple sessions, create a personal course, or continue structured teaching from an existing workspace.

Audit tests for vague assertions, improve coverage, and produce a structured report. Use when auditing tests for vague assertions, improving coverage, or validating test quality.

Analyze recent code changes against the spec suite, detect coverage gaps, violations, checklist drift, and missing design rationale, then sync specs using available delegation tools or a manual fallback. Use when specs need syncing after code changes, when the user says 'update specs' or 'sync specs', when specs are stale, or when rationale is missing and future agents would have to infer invariants from code.

Design, create, or revise cross-agent skills for predictable invocation and execution with progressive disclosure and checkable completion criteria. Use when writing a new skill, editing an existing skill, splitting skill workflows, or auditing skill clarity and sprawl.

Test-driven development through vertical red-green-refactor tracer bullets at agreed seams. Use when implementing behavior or regression fixes test-first, when the user requests TDD or integration tests, or after diagnosis identifies a bug to lock down.

Resolve in-progress Git merge, rebase, cherry-pick, or revert conflicts by tracing both sides to their intent before editing hunks. Use when Git reports unmerged paths or a user asks to resolve conflicts.

Conduct durable, source-backed technical investigations using primary sources and preserve cited findings for later work. Use when a question needs sustained research, official documentation or source-code evidence, competing claims reconciled, or a reusable research artifact—not for routine factual web searches.

Create a redacted, timestamped Markdown handoff so another agent can continue the current work without replaying the conversation. Use when pausing work, switching sessions or agents, compacting context, or explicitly asking for a handoff.

Diagnose hard bugs and performance regressions with a tight red-capable feedback loop, minimal reproduction, falsifiable hypotheses, and targeted instrumentation. Use when debugging broken, failing, throwing, flaky, incorrect, or unexpectedly slow behavior.

Review a diff independently along Standards and Spec axes, preserving the distinction between repository conformance and requirement fidelity. Use when reviewing a branch, pull request, worktree, work in progress, or changes since a fixed point.

Build a throwaway prototype to flesh out a design before committing to it. Routes between two branches — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route. Use when the user wants to prototype, sanity-check a data model or state machine, mock up a UI, explore design options, or says "prototype this", "let me play with it", "try a few designs".

Extract a DDD-style ubiquitous language glossary from the current conversation, specs, plans, or brownfield domain language, flagging ambiguities and proposing canonical terms. Writes the repository's canonical glossary. Use when user wants to define domain terms, build a glossary, harden terminology, create or update a ubiquitous language, refine spec-suite vocabulary, extract bounded-context terms from brownfield systems, or mentions "domain model" or "DDD".