dotfiles

Interact with GitHub using the `gh` CLI. Use `gh issue`, `gh pr`, `gh run`, and `gh api` for issues, PRs, CI runs, and advanced queries.

Spin up throwaway service/database stacks for tests, migrations, and ingest without touching the user's real dev stack or live data. Use when a task runs `docker compose`, database migrations, ingest jobs, or any destructive command that could hit a shared or live service. Triggers on "run the migrations", "ingest the data", "spin up the stack", "run the integration tests", or any plan step that starts containers or writes to a database.

Run the `pi` coding agent as a headless subagent (--mode json) inside a visible tmux pane so the user can watch it stream while the agent still captures and verifies its structured output. Use when asked to "run pi in a pane", "let me watch pi work", "run pi where I can see it", or to delegate to pi with a live view. Requires running inside tmux. For a fully headless run with no pane, use use-pi-subagent instead.

Invoke the `pi` coding agent as a non-interactive subagent from the shell — delegate a self-contained coding or analysis task to a fresh pi process and read its structured JSON output. Use when asked to "run pi", "use pi as a subagent", "delegate this to pi", or to orchestrate pi coder/reviewer agents (see prompt.md).

Keep the computer awake for a set duration or while a command runs, using `caffeinate` on macOS. Use when the user wants to prevent sleep during a long-running task, download, or presentation.

Writes a self-contained handoff document that briefs another agent or person to execute a scoped task without the originating context. Triggers when the user asks to "write a handoff", "hand this off", "brief another agent", "create a delegation doc", or prep work for a sub-agent / worktree agent to pick up. Emits a markdown file following a fixed template.

Produce a self-contained, styled HTML report answering a question about the codebase. Use when the user asks for a report, a written summary, or a shareable write-up of how part of the codebase works. Triggers on 'write a report', 'make me a report', 'generate an HTML report'. Researches the codebase (delegating to a subagent for broad topics), then writes a single styled HTML file that links back to the source with GitHub permalinks.

Access Google Workspace APIs (Drive, Docs, Calendar, Gmail, Sheets, Slides, Chat, People) via local helper scripts without MCP. Handles OAuth login and direct API calls.

Read this skill before making git commits

Create a Linear issue with consistent structure, inheriting context from related issues when possible

Structures and dispatches independent tasks for parallel execution across multiple Claude sessions or subagents. Use when a plan contains tasks that don't depend on each other and could be worked on simultaneously. Triggers on "do these in parallel", "work on multiple tasks at once", "split the work", or when an implementation plan has clearly independent components. Identify parallelizable work and provide ready-to-paste prompts for each parallel workstream.

Run `git commit` (or `--amend`) with the message editor opened in a new tmux pane so the user can hand-edit interactively. Uses git's own editor flow, so `commit.verbose=true` shows the diff as usual. Waits for the editor to close, then continues. Use when the user wants to write or tweak a commit message in vim/nvim. Requires the agent to be running inside a tmux session.

Executes an implementation plan in batches with human checkpoints between each batch. Use when a plan exists and should be worked through with periodic human review rather than full automation. Triggers on "execute this plan", "work through the plan", "implement step by step", or when the user wants to be involved at each checkpoint rather than letting it run fully autonomous. Prefer subagent-driven-development for full task-by-task review; use this when batch checkpoints are preferred.

Guides the process of completing a feature branch — verifying tests, choosing merge/PR/keep/discard, and cleaning up the worktree. Use when all tasks on a feature branch are done, or when the user says "I'm done", "ready to merge", "wrap this up", or "finish the branch". Always verify tests pass and get an explicit merge decision before cleanup.

Launch a project's local dev server and drive it in a visible (headed) playwright-cli browser so the user can watch and interact alongside the agent. Use when asked to preview the site/app locally, open the page in a real browser, give UI/design feedback, or interactively click through a running dev build.

Must read guide on creating/editing mermaid charts with valiation tools

Rebases the current PR branch onto its base (usually `origin/main`), resolves conflicts with intent-aware decisions, and offers a safe force-push afterwards. Use when the user says "rebase", "rebase on main", "update branch with latest", "sync with main", "fix rebase conflicts", or when a PR is behind its base. Never rebase `main`/`master` itself; never plain `--force`-push.

Guides how to process and respond to code review feedback — categorizing comments, making changes systematically, and responding to reviewers. Use when a pull request or code has received review comments, or when the user says "I got feedback on my PR", "reviewer left comments", "how do I respond to this review", or "addressing review feedback". Never dismiss feedback without engaging with it; never make changes without understanding why.

Search for content in the codebase using the `rg` (ripgrep) tool.

Implements a plan task-by-task using a two-stage review cycle — spec compliance first, then code quality. Use when an implementation plan is ready and the user wants to execute it with discipline. Triggers on "execute the plan", "implement this plan", "start working through the tasks", "let's build this", or when a writing-plans skill output is ready to be worked. Each task gets a fresh context and two-stage review before moving on.

Enforces RED-GREEN-REFACTOR test-driven development. Use when implementing features, fixing bugs, or writing any code. Triggers on phrases like "implement this", "add a feature", "write code for", "fix this bug", "TDD", "write tests first". Never write implementation code before a failing test exists — always enforce this order regardless of how the request is phrased.

Spawn and drive tmux sessions from the agent — background long-lived processes (dev servers, watchers) and interact with REPLs/TUIs (python, ipython, debuggers). Always use the dedicated `agent` socket so user sessions are untouched.

Creates and manages isolated git worktrees for feature development. Use when starting a new feature, working on a plan, or any time development work should be isolated from the main branch. Triggers on "start working on", "new feature", "create a branch", "implement the plan", or after a design/spec has been approved. Always set up a worktree before implementation begins.

Writes detailed implementation plans with bite-sized tasks, exact file paths, complete code, and TDD steps. Use when a design or spec has been approved and is ready to be turned into an implementation plan. Triggers on "write a plan for this", "create an implementation plan", "how do we build this", "plan out the implementation", or after brainstorming/design is complete. Always write plans before starting implementation — never skip to code.