machine

File a machine self-diagnostic report as a tagged GitHub issue. When a tool, daemon, hook, skill, or agent hangs, errors, returns garbage, or behaves wrong, open a `machine-report`-labeled issue on the machine plugin repo so every plugin user's reports funnel to the maintainer. Requires `gh` logged in. Write-side only — it logs, it does not fix. Trigger: "/report", "report a problem", "this tool is broken", "file a machine report", "log this hang/error/hiccup".

Consume the machine self-diagnostic backlog. Lists the open `machine-report` GitHub issues on the machine repo, ranks them by severity then age, fixes the single highest-priority one at its root cause, verifies green, then closes that issue. The act side of /report (which only writes). Machine-repo-only skill — not shipped to other installs. Trigger: "/resolve", "resolve a report", "triage the reports", "fix the top report", "work the reports backlog".

Second-AI review via the Codex CLI at the drill's single review point — the consolidated review of the finished diff, alongside the persona panel, before a landing is proposed. Advisory only: it returns notes and concerns for the driver and user to weigh, it never gates, blocks, merges, or edits. Skips cleanly when codex is not installed. Trigger via "/codex-review", "codex review", "second opinion from codex", or invoked by the drill skill.

The drill — the orchestrator's default driver mode. Runs grill-first: the drill and the user refine a request one question at a time until the user calls it a valid plan. From there the job runs autonomously — a plan subagent writes a markdown brief, a miner implements it on a git-fs branch inside the orchestrator's worktree, and the gate iterates until the build is green — with one consolidated advisory review (personas + codex) at the end. The drill surfaces only to land the work into main, plus on any blocker it cannot resolve. The live roster lives in the hub (claims + board), not on disk. Trigger via "/drill", "drill mode", "orchestrator mode", "background this", "spawn an agent for this", "drive this".

Promote crystallized brainstorm findings into board tickets. After a brainstorm (drill grill) settles one or more well-scoped features, this turns each into a card on the current cwd's board so the drill's plan step can iterate per ticket. The bridge between brainstorm and plan — it creates tickets, it does not plan or implement. Trigger: "/promote", "promote these", "promote to tickets", "make tickets", "turn findings into cards".

Run the single ongoing chat that resolves the open plan and implementation questions parallel agents raise. Plan/implement agents post questions to mesh and wait; the questioneer aggregates them into one prioritized queue, presents each to you for a decision, and writes the answer back so the waiting agent proceeds. It routes decisions — it does not plan, implement, or dispatch. Trigger: "/questioneer", "questioneer", "answer the questions", "resolve open questions", "what are the agents blocked on".

Use when the user says "board", "kanban board", or "drill board" — explains the local board kanban workflow, board-per-cwd identity, the stage-to-column mapping, labels/checklists/due-dates, and the read-update-consult discipline that mirrors the drill ledger onto a card per task, idea, or major step.

Mine the addon graph for this repo — survey the `mine/` kit (the graph of unregistered agents, skills, and hooks) and the current repo, match the best-fit tools, slot them in (copy + register in plugin.json / hooks.json), wire any prerequisites, and record the decision in kern so each session compounds. Run it a few times and the machine flows like butter. Trigger: "/mine", "mine the graph", "mine this repo", "slot the right tools", "what should we slot".

Oil the machine — re-index /.machine to specialize the portable machine to THIS codebase, then fire /mine to equip it with best-fit tools. Install and update are handled by the Claude Code plugin system (`/plugin`); this skill owns the per-repo project layer. Run after installing the machine plugin in a new repo, or whenever the project changes shape. Trigger: "/oil", "oil the machine", "re-index", "update the machine", "init the machine", "re-index /.machine".

Canonical Claude Code authoring kit covering Skills, sub-agents, plugins, slash commands, hooks, memory, settings, sandboxing, headless mode, and advanced agent patterns. Use when creating Claude Code extensions or configuring Claude Code features.

Rates each code file 1-10 across quality categories, rolls those ratings up into a folder tree so the parts of the app needing the most work surface, then improves worst→best. Uses compute (bash/analysis tools) to measure objective categories when it sharpens a rating. Accepts an optional target (path, module, or concern) to scope the sweep. Manual invocation only. Triggers on `/improve`, "improve code", "code review", "refactor", "optimize".

Author an external, install-anywhere Claude Code plugin that bundles an MCP server. Produces the full layout (.claude-plugin/plugin.json, .mcp.json, marketplace.json), wires the portable path variables ${CLAUDE_PLUGIN_ROOT}, ${CLAUDE_PROJECT_DIR}, and ${CLAUDE_PLUGIN_DATA} so the plugin runs on any machine with no absolute host paths, validates with `claude plugin validate`, and ships a one-line `/plugin install` flow. Use when asked to build, package, or distribute an MCP server as a Claude Code plugin. Trigger: "/mcp-plugin", "build an mcp plugin", "package my mcp server", "make a claude plugin", "distribute mcp", "marketplace plugin".

Ultra-compressed comm mode. ~75% token cut. Levels: lite, full (default), ultra. Trigger: "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", `/caveman`. Auto-active when token efficiency requested.

Cheatsheet lookup via cht.sh — the tmux + cht.sh + fzf tool. Ships a `cht` script with an interactive fzf picker (topic, then query) and a direct mode (`cht python reverse a list`, `cht tar extract`). Use when the user wants a quick syntax reminder, a command flag, an idiom, or a one-liner for a language or CLI tool. Trigger: "/cheat", "cheatsheet for X", "how do I X in <lang>", "cht.sh <topic>", "remind me the flags for <command>".

Fast pre-commit quality gate. Runs format check, lint, tests, and build in one pass and reports a pass/fail table. Toolchain-agnostic: detects the project's stack (or reads /.machine/project.md for the exact commands). Use before any commit, or whenever you want a quick "is the tree green?" check. Trigger: "/gate", "quality gate", "pre-commit check", "is it green", "run the checks".

Foundational principles for working in the machine: delegation to specialist agents, a language-agnostic quality gate, progressive disclosure, and modular skill structure. Use when creating agents/skills or deciding how to route work.

Code quality discipline for the machine: the five-dimension quality gate, proactive review habits, and the verification checklist that must pass before work is called done. Use for code review and quality-gate checks.

Capture a recurring repo task as a tiny project-local helper skill, and register its trigger tags so it fires reliably next time. Use when workflow friction recurs, when the helper-suggest hook nudges, or when the user asks to "make a helper" / "remember how we do X here". Helpers live in /.machine/skills/ (project-local, not the portable machine).

Rates each code file 1-10 across quality categories, rolls those ratings up into a folder tree so the parts of the app needing the most work surface, then improves worst→best. Uses compute (bash/analysis tools) to measure objective categories when it sharpens a rating. Accepts an optional target (path, module, or concern) to scope the sweep. Manual invocation only. Triggers on `/improve`, "improve code", "code review", "refactor", "optimize".

Capture durable lessons from the current session — corrections, gotchas, decisions, term definitions — into kern and the project glossary. Use after a user correction, a surprising failure, or at the end of non-trivial work.

Use when executing a spec or implementation plan and you want it finished as fast as possible by fanning the work across concurrent subagents instead of one task at a time. Triggers on "/parallel", "run this plan in parallel", "parallelize this execution", "do all these tasks at once".

Performance gate for gfx/shader work. Capture baseline, change, capture after, report delta. Use before any non-trivial rendering change.

Git workflow patterns, branch strategies, conventional commits, and PR templates reference for git operations. Agent-extending skill that amplifies manager-git expertise with production-grade git workflow patterns. NOT for: code implementation, testing, architecture design, documentation content.

OWASP Top 10 security checklist, authentication patterns, input validation, and HTTP security headers reference. Agent-extending skill that amplifies expert-security and expert-backend expertise with production-grade security patterns. NOT for: frontend UI, DevOps deployment, performance optimization, testing strategy.

Test pyramid strategy, coverage targets, test patterns, and quality metrics reference. Agent-extending skill that amplifies expert-testing and manager-tdd expertise with production-grade testing patterns. NOT for: production code implementation, architecture design, DevOps, security audits.

Sub-loader for domain specialists (agent infra, terminal, harness, perf, security, speed). Each entry captures the WHY and decision tree only — not implementation details. Trigger via `/specialists` or whenever a decision in one of these domains is on the table.

AST-based structural code search, security scanning, and refactoring using ast-grep (sg CLI) with pattern matching and code transformation across 40+ languages. Use for structural search or codemod operations.

Testing workflow for the machine: characterization tests for legacy code, specification tests for greenfield, and the test-quality checklist. Use when writing tests or measuring coverage.

Structured step-by-step deep analysis via the --deepthink flag, performed with Claude's native extended reasoning. Use for multi-step analysis or architecture decisions.

Architect-mode for non-trivial features, refactors, bug fixes. Bundles KISS/DRY/YAGNI, phased planning (orient → align → glossary → PRD → TDD → design+delegate), adversarial self-review, incremental push. Use when starting any non-trivial change, codebase drifts, or "AI did wrong thing"/"code keeps getting worse" symptoms. Skip one-line fixes, throwaway spikes, exploratory reads.

Run the project's persona review panel in parallel against the last completed feature or fix. The panel is defined by /.machine/personas/ — each reviewer critiques from their own lens, then a synthesis pass identifies the top cross-cutting concerns and a ship verdict.

Source cleanup pass — drive code toward zero duplication, minimum file count, single responsibility per file. One atomic cleanup per commit, project gate green between steps. Use for "clean this up", dead-code sweeps, and dedupe/consolidate passes.