Pair Ratchet
Use when the user wants to optimize a whole hot path, module, or pipeline — not one isolated query — keeping every measured win and moving to the next bottleneck until none yields a measured win. Loops pair-optimize sessions back-to-back; each session's kept win becomes the next session's baseline (a ratchet that only tightens), stopping when the well is dry or a session cap is hit. Delegates eac…
Pair Optimize
Use when the user wants a measured speedup or cost reduction for something concrete and runnable — a DuckDB/SQL query, a hot Python path, an endpoint, a pipeline step — with a second agent (Claude ↔ Codex) challenging the numbers, rather than vibes-based tuning. Also use when invoked as the peer ("Resume the pair-optimize skill"). Hard rule — no optimization is kept unless it is measured faster/c…
Write Goal
Phase 2 of pair-goal. Turns .pairgoal/UNDERSTANDING.md into a /goal-ready completion condition — one measurable end state, a stated transcript-demonstrable check, the constraints that must hold, and a turn cap — written to .pairgoal/GOAL.md plus the literal /goal line for the user to run. Use after train-orchestrator, or standalone to craft a good /goal condition from a clear improvement target.
Clean Up
Phase 5 of pair-goal — the finishing move. Commits the kept improvement on a feature branch, opens a PR (body drawn from .pairgoal/SUMMARY.md), and tears down the pair-goal worktrees and state. Always confirms the branch name and PR body with the user before pushing. Use as the last phase of a pair-goal run, after summarize.
Define Goal
Phase 2 of long-haul. Turn .longhaul/SPEC.md into a /goal-ready completion condition — one measurable end state, a stated transcript-demonstrable check, the constraints that must hold, and a round cap — written to .longhaul/GOAL.md plus the literal /goal line for the user to run. If the end state isn't clear or measurable, iterate with the user one question at a time until it is. Use after sharpe…
Train Orchestrator
Phase 1 of pair-goal. Improvement-focused brainstorming — assumes the user wants something existing made better, and digs for what's deficient now, what "better" means concretely, and the measurable success signal. Produces .pairgoal/UNDERSTANDING.md. Use as the first phase of a pair-goal run, or standalone when you need to sharpen a vague "make X better" into a verifiable target before setting a…
Long Haul
Auto-chaining orchestrator for a solo long-horizon goal loop. Sharpen a spec (grill it if vague), forge a /goal completion condition, then haul toward it turn after turn in a git worktree — each turn deciding explore (a fresh approach off the base) vs exploit (refine the incumbent), keeping only measured wins, until the goal holds. Use when the user wants one agent driven relentlessly toward a ve…
Wrap Up
Phase 4 of long-haul — the finishing move. Fires once the /goal condition is met (the goal auto-clears) or the round cap trips. Reports goal-vs-achieved with the final check output, the explore/exploit path each round took, and the net kept diff; then commits the incumbent on a feature branch and opens a PR. Always confirms the branch and PR body with the user before pushing. Use as the last phas…
Review Markdown Plan
DEPRECATED — use the pair-* skill series (e.g. pair-consult / pair-optimize) instead. Review a premade markdown plan by section, using subagents to independently validate each section or step and then annotating the plan with concrete inline fixes. Use when a user provides a written plan, implementation plan, migration plan, rollout plan, or checklist in markdown and asks Codex to critique it, pr…
Haul Loop
Phase 3 of long-haul — the per-turn loop. Under an active /goal, each turn run exactly one round: decide explore (a fresh approach off the base commit) vs exploit (refine the incumbent), implement the attempt in a git worktree following the /implement contract, run the goal's stated check, and keep the attempt only if it beats the incumbent — a ratchet that never regresses. Writes R<N>.md, surfac…
Pair Consult
Bounded multi-round consultation (default 5 rounds, set with --number) between Claude Code and Codex on a single user question or small coding task — A proposes, B reviews, A responds, B re-reviews, A synthesizes and asks the user. Use when a single coding question warrants a tight structured back-and-forth ending in user confirmation, rather than a full spec→plan→code workflow.
Grill With Llm Wiki
Stress-tests a plan or idea by challenging it against an existing LLM-maintained wiki (entity / concept articles, index, log, raw sources). Read-only — never writes to the wiki.
Excalidraw Diagram
Create Excalidraw diagram JSON files that make visual arguments. Use when the user wants to visualize workflows, architectures, or concepts.
Analyze Git Style
Analyzes git commit and push history across ALL repositories on the machine, scores commit message quality, and generates a CLI report with statistics, lessons, and improvement suggestions. Supports --today and --week time filters.
Humanizer
|
Simple Llm Wiki
Use when building or maintaining a personal LLM-powered knowledge base. Provides Ingest, Query, and Lint operations over a raw/ + wiki/ directory pair.
Sharpen Spec
Phase 1 of long-haul. Turn the user's ask into a well-defined spec — a located deliverable, a transcript-demonstrable success signal, the toolbox of skills + MCP the haul may use, constraints, and out-of-scope. If the ask is vague, grill it first. Produces .longhaul/SPEC.md. Use as the first phase of a long-haul run, or standalone to harden a fuzzy ask into something buildable before setting a go…
Summarize
Phase 4 of pair-goal. Fires once the /goal condition is met (the goal auto-clears) or the round cap is hit. Reports goal-vs-achieved with the final check numbers, which racer won each round and why, the net diff that was kept, and what's still open. Writes .pairgoal/SUMMARY.md. Use after pair-iterate concludes a pair-goal run.
Pair Iterate
Phase 3 of pair-goal — the per-turn race. Under an active /goal, each turn the orchestrator commissions two independent implementers (a Claude on a chosen model + Codex on a chosen model), each in its own git worktree off the current base commit, then judges both against the goal's stated check and merges the winning diff into the main tree. Use as the iteration phase of a pair-goal run; before r…
Organize Skill Mcp
Scans all skill installations and MCP server configs across Claude Code, Claude Desktop, Cursor, Windsurf, Codex, and Gemini CLI at global and project scopes. Visualizes the current state, detects issues (duplicates, broken symlinks, security risks, inconsistencies), and suggests cleanup actions.
Find Overlapping Skills
Scan every installed skill across all sources, collapse double-installs, cluster the rest into overlap groups, show a terminal dashboard, then resolve each group with the user one at a time — disabling the non-keepers reversibly. Use when the user wants to find duplicate or overlapping skills, audit or trim an over-grown skill set, or asks which installed skills do the same job.
Get Feedback Markdown Plan
DEPRECATED — use the pair-* skill series (e.g. pair-consult / pair-optimize) instead. Evaluates inline feedback annotations on a markdown plan by verifying each critique against the codebase and context using subagents.
Pair Goal
Auto-chaining orchestrator for goal-driven improvement. Understand what the user wants improved, forge a /goal completion condition, then race a different-model Claude against Codex (each in its own git worktree) round by round until the goal is met, summarize, and open a PR. Use when the user wants something existing measurably improved with two independent agents racing under a verifiable goal…