camacho/ai-skills
42 skills17.1k installs42 starsGitHub
Install
npx skills add https://github.com/camacho/ai-skillsSkills in this repo
1Archivearchive is a camacho ai-skills workflow for formally closing agent-driven project plans. The skill locates the most recent non-archived plan in $WORKTREE/ai-workspace/plans/, reads planned scope, gathers what worked and what did not from the user or git log context, fills an Outcomes & Learnings section, and renames the file to .done.md. Developers reach for archive when a worktree initiative finishes and the plan should persist as a completed record rather than an active todo. The skill errors if the plan is already archived, preventing duplicate closure, and resolves WORKTREE from the session CWD or git rev-parse --show-toplevel.710installs2Bailbail is a skill from camacho/ai-skills that implements a reflect-first bail-out protocol for stuck branches and experiments. It detects the current step—from issue-only capture through worktree isolation to plan-on-branch stages—then reflects lessons, updates the GitHub Issue, closes open PRs, and cleans worktrees using absolute paths with git -C. Developers reach for bail when an experiment fails or stalls and they need structured teardown instead of leaving orphan branches, open PRs, and lost rationale. The skill sequences reflection before destructive cleanup so institutional knowledge lands in issues before branches disappear.684installs3Capturecapture is a lightweight triage skill that parses free-text descriptions into GitHub issues with appropriate labels using the gh CLI. The skill classifies input by keywords: bug terms like error, crash, and regression receive triage and bug labels, while feature terms like add, new, and enhance receive triage and enhancement labels, defaulting to enhancement when unclear. Developers reach for capture when capturing ideas mid-debug, filing bugs from agent sessions, or avoiding context loss before formal planning. If GitHub issue creation is unavailable, capture falls back to a local scratchpad record while preserving the parsed title and body structure.669installs4Plan Reviewplan-review is a phase-gate skill from camacho/ai-skills that implements the PLAN checkpoint in an agentic development workflow. It locates the latest non-done plan file under ai-workspace/plans/, deterministically assembles a review panel from plan scope, and dispatches reviewer agents in parallel to collect APPROVE or reject verdicts. Build cannot proceed until every reviewer—including the non-excludable technical-editor agent—returns APPROVE. Flags --include and --exclude let teams force-add or drop reviewers except technical-editor. Developers reach for plan-review when multi-agent plans need structured sign-off before code changes land, replacing informal plan chats with a blocking quality gate tied to concrete plan markdown files.658installs5Orientorient is a camacho/ai-skills phase-gate skill that must complete before the Isolate checkpoint in an EXPLORE workflow. Step one runs gh issue view with JSON fields for title, body, labels, and assignees when an issue number is provided; without gh or GH_TOKEN, the skill falls back to manual task description. Step two auto-detects task type from labels or keywords and maps each type to a branch prefix via a built-in lookup table. Developers reach for orient when starting GitHub-tracked work and needing a structured brief with correct branch naming before writing code.646installs6Reflectreflect is a phase-gate skill from camacho/ai-skills that developers run after merging a branch or finishing a task to prevent premature completion declarations. The workflow starts by stamping a reflect timestamp into ai-workspace/.last-reflect-ts, then reviews recent git history with git log --oneline -10 and session edits. If a completed plan exists in ai-workspace/plans/ with Outcomes and Learnings filled in, reflect treats that document as the primary source of truth. The skill consolidates corrections and insights into project memory layers, closes linked issues, and enforces Step 8 of the COMMIT checkpoint before the agent declares work done. Developers reach for reflect when agent sessions need structured retrospectives instead of ad-hoc summaries. Escalation to the user happens only at explicit escalation points, keeping routine reflection autonomous while preserving auditability of what changed and why.628installs7Statusstatus is a camacho/ai-skills agent skill that builds a concise project status report without modifying the repository. It collects git state in parallel—recent oneline commits, sorted branches, and worktree info—alongside open issues, active plans, memory state, and scratchpad contents. Developers invoke status when they ask "what's going on", "where are we", or want a faster alternative to full /catchup reconstruction. The skill is intentionally read-only: it snapshots current project health so engineers can orient before picking the next task.604installs8Build Skillbuild-skill is an agent skill from camacho/ai-skills that produces one deliberate SKILL.md draft for capable senior engineers with no local context. The workflow favors invariants, decision boundaries, evidence, and stop rules over shell choreography or ceremony, using failure analysis and review rather than generating multiple competing versions. Args should name the skill, describe what it does, and note modes, commands, or repo context that change design; underspecified requests trigger one clarifying question. Developers reach for build-skill when bootstrapping a new agent capability, rewriting a vague skill, or replacing tournament-style multi-draft generation with a reviewed single version.601installs9Autonomousautonomous is a Claude Code skill that wraps Bash helpers around camacho/ai-skills session-state utilities so developers can flip between autonomous execution and copilot-strict checkpoints without restarting a session. The skill sources scripts/lib/session-state.sh and exposes atomic_write, get_mode, set_mode, is_copilot, and is_copilot_strict helpers through mode.sh wrappers. Developers reach for autonomous when an agent should run multi-step shell and filesystem work end-to-end, then tighten checkpoints before risky edits or production changes. The persisted mode survives within the session directory and can expire when stale, keeping autonomy settings predictable across long Claude Code runs.593installs10Catchupcatchup is a strictly read-only context reconstruction skill for AI coding sessions. After /clear, /compact, session resume, or switching into an existing git worktree, catchup runs parallel git commands—log, status, and worktree list—and reads `.branch-context.md` YAML frontmatter when present. Parsed fields include workflow_step, validate_round, review_round, and plan chunk approval counters so agents understand validation and review progress. Developers invoke catchup when branch context is unknown or stale and they need a concise briefing before editing code. The skill never creates branches, edits files, or runs write commands.581installs11Wrapwrap is a session-ending agent skill that closes development cycles cleanly by invoking the reflect skill, pruning merged git worktrees, and surfacing warnings for unmerged branches before the developer runs /clear. The reflect step handles MEMORY.md updates, Basic Memory vault writes, GitHub issues, plan finalization, and .last-reflect-ts tracking—wrap delegates to reflect rather than inlining that logic. After reflect completes, wrap lists worktrees under the repository root and removes entries in .worktrees/ that are already merged, while flagging branches that still need attention. Developers reach for wrap when finishing a task, saying goodbye, transitioning contexts, or preparing a fresh agent session without leaving stale worktrees behind.578installs12Assemble Panelassemble-panel is a Claude Code orchestration skill from camacho/ai-skills that centralizes reviewer selection and loop governance for code review workflows. Callers pass a plan file path or git diff as scope plus optional include/exclude overrides; the skill returns structured panel and policy data without dispatching agents or modifying files. It is invoked indirectly by /review, /plan-review, and code-reviewer skills rather than end users. Developers reach for assemble-panel when multi-reviewer reviews must stay consistent across sessions and callers need a single source of truth for who reviews what and under which gate rules.569installs13Session Start Hooksession-start-hook is a camacho/ai-skills skill for authoring Claude Code SessionStart hooks that prepare repositories before agent sessions begin. Hooks receive JSON on stdin with session_id, source, transcript_path, permission_mode, hook_event_name, and cwd, then install dependencies so tests and linters work across Claude Code CLI, web, and API surfaces. Developers use session-start-hook when new or resumed sessions should not waste time on missing packages or broken lint commands. It targets repository bootstrap automation tied to Claude Code hook events rather than generic CI pipelines.569installs14CopilotCopilot is a user-invocable skill from camacho/ai-skills that sets mode=copilot through a shared mode controller currently owned by the autonomous skill. In copilot mode, the human drives decisions while Claude assists, relaxing worktree enforcement and allowing commits on the main branch. The skill is an alias over the shared controller with explicit values autonomous and copilot, and is documented as Claude Code enforcement only since Codex and Cursor default to autonomous unless a future adapter uses the controller. Developers invoke Copilot when they want paired programming with an agent that does not autonomously enforce isolated worktrees or block main-branch commits.565installs15Validatevalidate is a camacho/ai-skills agent skill that runs the full pre-merge validation suite with a single pnpm validate command chaining typecheck, lint, format, test, and optional build steps. When any step fails, the agent reports the exact error output instead of summarizing failures. Developers reach for validate immediately before merge or release when a monorepo already defines a validate script in package.json. The skill is intentionally minimal—one shell command and clear failure reporting—making it ideal for agent-driven CI parity on local machines. It assumes the project toolchain is configured via pnpm scripts rather than invoking individual tools manually. Skip when the repository lacks pnpm or a validate npm script hook.565installs16Policy Algebrapolicy-algebra is a governance skill from camacho/ai-skills that freezes invariants as Starlark blocks injectable into downstream agent work. It supports two input modes: deep interview from thin intent strings or shallow confirmation from rich plan inputs. The skill produces fenced Starlark blocks and exposes --verify for canonicalized drift detection against candidates. Developers invoke /policy-algebra on a target to generate rules or /policy-algebra <target> --write <path> to persist blocks. Use policy-algebra when agent skills, plans, or rule files need enforceable, drift-checkable governance—not general policy discussion.551installs17Publish Skillpublish-skill is a Claude Code workflow skill from camacho/ai-skills that automates releasing local agent skills to a shared ai-skills repository. It detects new or modified skills under `.agents/skills/` by comparing git hashes against the target registry, creates a rollback snapshot, runs a review step, publishes changes to ai-skills, reinstalls locally, and cherry-picks lockfile updates to the TARGET project. The skill replaces the older `/elevate-skill` command and resolves the ai-skills path from `$AI_SKILLS_REPO`, `~/projects/camacho/ai-skills`, or a user prompt, aborting if the registry working tree is dirty. Developers reach for publish-skill after editing a skill locally when they say "publish skill", "update skill", "push skill changes", or invoke `/publish-skill`.399installs18Reviewreview is a unified camacho/ai-skills agent skill that auto-detects whether to review a plan or code, assembles the right reviewer panel, and runs a bounded review-fix loop with severity gating. Plan mode triggers when a non-done plan exists in ai-workspace/plans/ without commits beyond main; code mode triggers on git diff main...HEAD output. Default round cap is 3 with thorough at 5 and quick at 1, hard-capped at 5 rounds. Conditional reviewers add architect-reviewer, security-auditor, codex-specialist, or design-reviewer based on signals in the diff. Code mode fixes P0–P3 findings with a terminal P3 sweep that skips re-dispatch when only nits remain, recording deferred items via gh issue create or .branch-context.md. Developers reach for review when a plan or implementation needs structured feedback—not for greenfield coding without reviewable artifacts.393installs19Isolateisolate is a Claude Code skill from camacho/ai-skills that sets up an isolated git worktree before task work begins. The skill detects the parent branch via reflog, branches from the current remote main with freshness verification, and runs project setup so agents never start on stale code. Developers invoke isolate when starting feature or fix work that needs branch isolation—typically after /orient supplies a branch name like feat/auth or fix/login-crash. The workflow announces setup explicitly and accepts an optional base ref override when stacking on a branch other than main. isolate keeps parallel agent runs and developer sessions from polluting the active working tree.391installs20Tasktask is a version 1.0.0 universal task dispatcher from camacho/ai-skills that starts, routes, and executes development work through a Steps 0-9 workflow. Invoked via /task with a description, issue number, or fresh start, it selects the right surface before work begins: Claude Code for architecture planning and feature implementation with hooks and subagents, VS Code Claude extension for quick single-file fixes, Codex CLI for DevOps and terminal tasks, and Codex Cloud for background refactors that produce pull requests. The skill breaks plans into granular agent-executable tasks with acceptance cues so Claude Code can pick up, track, and complete work incrementally across the delivery cycle. Developers reach for task as the entry point for any development activity rather than jumping directly into implementation without routing context. It produces routed task plans and tracked execution steps rather than replacing issue trackers or CI pipelines. Because it spans planning through implementation and review routing, it covers multiple delivery phases in one invocation surface.391installs21Shipship is an agent skill from camacho/ai-skills that integrates a feature branch onto main after review and tests pass. The skill requires work on a non-main branch, a completed /review step or explicit user approval, a known worktree path, and zero pending tasks in TaskList or .branch-context.md checklists. Developers reach for ship when implementation is done and CI is either healthy for PR auto-merge or down for a controlled local merge. The workflow announces integration, chooses between PR and local paths, and keeps rollback awareness so production-bound changes land on main safely.388installs22Buildbuild is a Camacho ai-skills workflow that turns an approved `ai-workspace/plans/<name>.md` plan—or a one-sentence hotfix scope—into implemented code, configs, and project artifacts. The skill announces execution, loads ordered task batches (parallel steps grouped, dependent steps sequenced), dispatches subagents per task, validates results, and reports completion. Prerequisites include plan approval from `/review` (Step 4) or a minimal hotfix scope, and work in a linked git worktree rather than the primary branch. Developers reach for build when design is done and they want TDD-guided execution without manually shepherding every subtask.386installs23To PrdThe to-prd skill from camacho/ai-skills transforms accumulated ideation, positioning, and planning context into a Product Requirements Document with clear scope, user stories, constraints, and acceptance criteria. It is the validation bridge that gives engineering and agents a single authoritative spec before build work starts.379installs24To Issuesto-issues is a planning skill in camacho/ai-skills that converts plans, specs, or PRDs into GitHub issues teammates or AFK agents can grab without hidden dependencies. Each issue is a tracer-bullet vertical slice cutting through schema, API, UI, and tests end-to-end—not a horizontal layer ticket. Slices are tagged HITL when human decisions are required or AFK when agents can implement and merge autonomously. The workflow gathers context (including fetched issue bodies via gh), optionally explores the codebase for domain vocabulary, drafts slices with blocker relationships, quizzes the user on granularity and dependencies, then publishes issues in dependency order with acceptance criteria and Blocked-by links. Issue bodies avoid stale file paths unless encoding prototype decisions. Developers reach for to-issues when converting a PRD, feature plan, or parent issue into a parallelizable issue backlog ready for agent execution.376installs25Triagetriage is a camacho/ai-skills workflow for moving issue tracker tickets through a structured state machine with two category roles (bug and enhancement) and five state roles: needs-triage, needs-info, ready-for-agent, ready-for-human, and wontfix. Every triage comment must start with a disclaimer that it was generated by AI during triage. For ready-for-agent issues, triage posts structured agent briefs with context, scope, acceptance criteria, relevant file entry points, and constraints; for bugs it attempts reproduction before grilling reporters with /grill-me when installed. Rejected enhancements get documented in .out-of-scope/*.md files to prevent re-litigation. Developers reach for triage when maintaining an open-source or product backlog, preparing issues for autonomous agents, or batch-reviewing incoming bug and feature reports.373installs26Brainstormingbrainstorming is a camacho/ai-skills agent skill that must run before creative work such as new features, components, functionality, or behavior changes. It turns rough ideas into approved designs through collaborative questioning: the agent reads project context, asks one question at a time to refine intent, then presents a design for explicit user approval. A hard gate forbids invoking implementation skills, writing code, scaffolding projects, or any build action until sign-off. Developers and tech leads reach for brainstorming when AI agents otherwise jump straight to patches without aligned requirements, or when a feature needs clarified scope, UX, and acceptance criteria. The skill spans ideation into validate-ready specs, making it a multi-phase workflow anchor rather than a single shipping task, and pairs naturally with implementation skills that should only fire after design approval.372installs27Test Driven Developmenttest-driven-development is a rigorous TDD skill from camacho/ai-skills that mandates writing a failing test, watching it fail for the right reason, implementing minimal passing code, and refactoring only while green. Its Iron Law—no production code without a failing test first—applies to new features, bug fixes, refactors, and behavior changes, with narrow exceptions for throwaway prototypes, generated code, and configuration files. The skill documents the full red-green-refactor cycle with TypeScript examples, rationalization callouts, verification checklists, and debugging integration that requires a failing regression test before any bug fix ships. Developers reach for test-driven-development when agents skip tests, write code before assertions, or need systematic proof that tests actually catch missing behavior rather than passing immediately.370installs28Requesting Code Reviewrequesting-code-review is a Claude Code skill from camacho/ai-skills that dispatches a code-reviewer agent with precisely crafted evaluation context instead of dumping full session history. It mandates review after subagent-driven tasks, major feature completion, and before merge to main so defects surface early. The skill packages diffs, test evidence, and focused questions so reviewers judge the work product—not the author's reasoning trail—preserving author context for continued coding. Developers reach for requesting-code-review when they want structured pre-merge gates in agent-assisted workflows.357installs29Local Mergelocal-merge is an agent skill from camacho/ai-skills that lands a source branch onto a target branch—default `main`—through a disposable shallow clone, then updates the PRIMARY worktree only if it is already on the target branch. The `/local-merge` workflow avoids mutating active worktrees directly during `/ship`, `/reflect`, or autonomous-mode integration, surfacing merge conflicts early before push. Required input is BRANCH; optional TARGET defaults to main and PRIMARY defaults to the primary worktree path. Developers reach for local-merge when integrating feature branches locally while preserving worktree isolation in multi-worktree repositories. The skill keeps skill stacks integration-ready without waiting on remote merge jobs, making it ideal for agent-driven landing workflows that must not corrupt in-progress worktree state.351installs30Inheritinherit is a camacho/ai-skills agent skill for pulling changes from a parent branch—typically main—into the current branch using merge, never rebase. The mental model is "I am the child; I want what my parent has," and the skill can cascade updates bottom-up through a stack of dependent branches. inherit detects the parent from reflog or falls back to main, stops on conflicts instead of auto-resolving, and uses git -C with absolute paths for Claude Code worktree compatibility. Triggers include pull from main, sync from base, update the stack, and /inherit. The skill pairs with /isolate for forking from a parent and /ship for pushing to target branches, offering a disciplined alternative to rebase workflows in shared checkouts and CI environments.346installs31Positionposition is an AI agent skill from camacho/ai-skills that bootstraps a coding session into a persistent teammate role instead of a blank context. Invoked as /position <name>, it loads a position profile from ai-workspace/team/<name>.md, optionally loads sibling state directories containing PLAYBOOK and DECISIONS files, and executes the profile-defined session-start bootstrap sequence. Developers reach for position when multi-agent workflows require each session to assume a consistent role identity—such as TPM or other defined positions—before substantive coding begins. The skill generalizes bespoke per-role commands like /tpm into one generic loader pattern, keeping role contracts as reviewable markdown in the ai-workspace tree. Position is not a product-marketing positioning tool despite catalog noise; the readme defines it strictly as teammate session bootstrap for agent pipelines.323installs32Distilldistill is a Claude Code skill from camacho/ai-skills that orchestrates a three-stage pipeline on AGENTS.md and rules/ directories when agent instruction files grow past readable size. Stage one /imperatives extracts structured imperatives into JSONL artifacts. Stage two /policy-algebra composes them with policy algebra into Starlark. Stage three /visualize renders decision trees as Mermaid diagrams. Artifacts land in ai-workspace/research with date-stamped outputs, and each stage can run independently via /distill --stage flags. The forced pause between extraction and composition lets developers review what rules actually exist before restructuring policies. Developers reach for distill before major agent-governance refactors, when onboarding new agent runtimes, or when rules need trimming, deduplication, and visual documentation of decision logic.300installs33Imperativesimperatives is an agent-governance skill in camacho/ai-skills that teaches Claude to write and apply imperative directives—must-run steps, forbidden actions, and ordered workflows—that persist across coding sessions and repositories. Instead of soft suggestions, imperatives frames rules as non-negotiable commands agents must follow before editing files, running shell commands, or opening pull requests. Platform and developer-experience teams reach for imperatives when standardizing Claude Code behavior for monorepos, regulated environments, or shared agent playbooks. The skill complements CLAUDE.md and hook systems by making execution order and guardrails explicit enough for automated enforcement.296installs34Visualizevisualize is a Camacho AI skill for turning unstructured agent reasoning, tabular datasets, and architecture notes into charts, diagrams, and visual artifacts both humans and coding agents can inspect. It fits build-phase work when an implementation needs a shared picture of logic flow, data shape, or component relationships before or while code is written. Developers reach for visualize when text-only explanations are slowing review, when stakeholders need quick visuals from agent output, or when system design sketches must be generated from partial specs. The skill emphasizes reviewable visual deliverables rather than production rendering pipelines or BI dashboards.296installs35BlueprintHelps teams and coding agents create clear blueprints—scope documents, architecture outlines, and phased plans—before implementation starts, reducing rework by aligning stakeholders on goals, constraints, dependencies, and the order of delivery.239installs36Coffee BreakIntroduces a coffee-break workflow for AI coding agents that schedules intentional pauses during extended tasks so context stays fresh, errors are caught earlier, and final deliverables remain coherent.184installs37Review Loopreview-loop from camacho/ai-skills orchestrates an implement-review-fix cycle for Claude Code: an implementer applies changes, a reviewer inspects the diff against standards, issues are fixed, and the loop repeats until no blocking problems remain—ideal before merge or release.182installs38Silly SausageThis skill activates when the user says 'silly sausage' or expresses playful exasperation at a mistake the agent made. It prints a dancing-hotdog ASCII art and a random quip, then either stops mid-task to name and fix the error (correction mode) or riffs lightly if idle (fun mode). A developer effectively uses it as a lighthearted signal to make the agent stop, admit a specific mistake, and course-correct. It matters because it turns frustration into a clear, non-defensive recovery step.45installs39Audit PermissionsThis skill analyzes Claude Code permission audit logs and recommends allow-list changes to reduce permission prompts. It runs a TypeScript analyzer, presents a report, and offers to merge only safe patterns into permissions.allow while never modifying permissions.deny. It also flags security warnings and suppresses recommendations that carry danger-level flags. A developer uses it when reviewing how often they get prompted and optimizing the allow-list. It matters because it tightens permission configuration without silently approving risky commands.42installs40Sync DotfilesThis skill syncs user-level AI configuration directories such as ~/.claude/ and ~/.codex/ with a dotfiles/ directory. It maps user intent to sync.sh subcommands like diff, status, pull (home wins), push (repo wins), and skills-push, and auto-discovers the ai-env repo where dotfiles live. A developer uses it when configs drift, after sessions that change permissions or hooks, or when setting up a new machine. It matters because it keeps agent configuration version-controlled and consistent across machines.39installs41Apply TemplateThis skill applies the ai-env agentic development environment template to the current repository. It reads a manifest that classifies each file as copy_if_absent, smart_merge, or skip, then copies new files and performs intent-preserving merges on existing ones like AGENTS.md, tsconfig.json, and .claude/settings.json. A developer uses it to bootstrap or update a repo's agent tooling and conventions while keeping existing customizations. It matters because it adds template scaffolding without overwriting project-specific configuration.37installs42Name ProjectThis skill runs an interactive naming session for a project, app, package, tool, or repo. It presents names in rounds, tracks the user's preferences across a persisted taste profile, and refines suggestions based on which names get selected. The rounds move from divergent brainstorming to convergence and a locked name, using project context scanned from README, package.json, and docs. A developer uses it when they need a name and want the suggestions to get sharper as the session proceeds. It matters because it turns naming into a guided, learning loop instead of a blank-page problem.37installs