camacho/ai-skills
17 skills9.4k installs17 starsGitHub
Install
npx skills add https://github.com/camacho/ai-skillsSkills in this repo
1Bailbail is a workflow agent skill for Camacho-style git automation when you need to stop work on a branch without losing context. Solo builders using GitHub Issues, worktrees, and multi-step delivery flows invoke it to detect how far execution progressed—from capture through an open PR—prompt for a bail reason if missing, write learnings into .branch-context.md, mirror insights to MEMORY.md via a disposable clone, and then close PRs and remove branches cleanly. The skill insists on reflection before destructive cleanup so the next attempt or issue update carries explicit lessons. It is multi-phase because bail can happen during isolation, design, build, verify, or ship, but Prism shelves it under Ship review as the usual failure point. Pair it with your issue-capture and ship skills in the same repo stack.669installs2Archivearchive is a lightweight workflow skill for solo builders using Camacho-style ai-workspace plans who want every planning cycle to end with captured learnings instead of orphaned markdown. It locates the active plan in the current worktree, prompts or infers what worked and what did not, writes a consistent Outcomes & Learnings block, renames the file to .done.md, and commits the documentation change so history stays traceable. The steps assume a conventional ai-workspace/plans layout and guard against double-archiving. It complements agent-driven implementation skills by closing the loop after shipping a slice of work or abandoning a spike, and it tolerates skipped user input without blocking the rename. Use it whenever a plan’s execution phase is finished and you want institutional memory in-repo rather than chat logs alone.665installs3Plan Reviewplan-review is an agent workflow skill for solo builders using structured AI workspaces: it implements the PLAN checkpoint that must pass before any Build work proceeds. After you write a plan under ai-workspace/plans/, the skill locates the newest active markdown plan, parses scope (files to modify, body size), and calls assemble-panel—or applies its scope and keyword maps inline on Codex/Cursor—to choose reviewers. It then dispatches every selected agent in parallel against the plan file and aggregates verdicts; all must APPROVE or you stay gated. Overrides let you force-include specialists or exclude agents except the mandatory technical-editor. This fits indie teams who want deterministic review panels instead of ad-hoc “please review my plan” chat. It pairs naturally with plan-writing skills upstream and implementation skills only after unanimous approval. Complexity is intermediate because you need git-topped ai-workspace layout and compatible agent tooling.642installs4CaptureCapture is a lightweight agent workflow that converts a spoken or typed idea, bug, or feature request into a structured GitHub Issue. Solo and indie builders use it to avoid losing context in chat logs when they spot regressions mid-build or jot enhancements during planning. The skill parses keywords to choose bug versus enhancement labels alongside triage, runs the GitHub CLI when available, and surfaces the issue URL immediately. When gh or GitHub is unavailable, it degrades gracefully to MCP tools or a local scratchpad entry so nothing is dropped on offline sessions. It fits anyone already using GitHub for a single-repo product who wants agent-native intake without opening the issues UI.638installs5Orientorient is an agent skill that runs at the EXPLORE checkpoint of a disciplined dev workflow: it loads GitHub issue context when possible, classifies the task as bugfix, feature, chore, or docs, proposes the matching branch prefix, scans local ADRs for relevance or contradiction, and folds in any saved branch context from an interrupted session. Solo builders using Claude Code or similar agents install it to avoid jumping straight into edits without a shared brief—especially when gh is available for title, body, labels, and assignees. If GitHub CLI is missing in a remote session, the skill degrades gracefully to a manual task description rather than blocking. The output is orientation material for the next isolation step, not shipped code. It pairs naturally with repos that keep architectural decisions under ai-workspace/decisions and want explicit callouts when work might violate an existing ADR.630installs6Reflectreflect is a journey-wide agent skill that enforces a structured COMMIT checkpoint after you merge a branch or finish a task. Instead of declaring work done in chat, the agent marks a reflect timestamp, reviews recent git history (preferring filled plan outcomes in ai-workspace/plans/), scans commits for issue-closing keywords, and classifies learnings into project MEMORY.md versus a cross-project Basic Memory vault. Escalation to the user happens only at explicit points; open issues referenced in commits produce warnings without blocking. Solo builders using Claude Code with ai-workspace conventions benefit because tacit fixes from a session become durable memory and tracked issue state. The skill fits any product shape where you use git and optionally GitHub Issues. It complements planning skills by closing the loop on what actually shipped versus what was intended.598installs7StatusStatus is an agent skill that turns scattered project signals into one concise dashboard for solo and indie builders who juggle multiple branches, GitHub issues, and ai-workspace artifacts. When you ask what is going on, where we are, or want a status report without the heavier catchup reconstruction, the skill gathers git history and working tree state, optional GitHub issue activity, active plan files under ai-workspace/plans, and memory or scratchpad health in parallel where possible. It is aimed at Claude Code-style workflows that already keep plans and MEMORY.md in-repo. You get attribution-ready sections and clear gaps when the CLI cannot reach GitHub, so you can orient in minutes during build, ship, or operate without changing any files.582installs8AutonomousThe autonomous skill packages shell scripts that own how an AI coding session’s autonomy level is stored and switched. Solo builders running camacho-style agent stacks use it to flip between autonomous runs (agent proceeds with less interruption) and copilot mode (tighter human-in-the-loop guardrails) without reimplementing session state in every hook. `set-mode.sh` accepts only `autonomous` or `copilot`, sources shared `mode.sh` helpers, and refuses copilot in remote Claude Code sessions. When no session directory exists, autonomous can still be selected while copilot setup fails closed—matching real hook behavior during cold starts. Compatible with Claude Code hook and alias patterns; treat it as procedural infrastructure, not a one-off coding task. Review repo hooks that call these scripts before enabling autonomous on destructive or production-touching workflows.574installs9Build SkillBuild Skill is a meta workflow for solo builders who package procedural knowledge into agent-ready SKILL.md files. It replaces noisy multi-draft tournaments with one strong version built through failure analysis, review against invariants, and refinement that does not re-bloat ceremony. Before drafting, it classifies scope (user vs project), target path, and whether the skill encodes governance and decision algebra versus step-by-step shell choreography. Copy is aimed at a senior engineer with no local context: clear stop rules, smallest process that preserves quality, and descriptions that help discovery without summarizing the entire ritual. Use it whenever you are creating a new skill, rewriting a bloated skill, or aligning with repo conventions after a failed agent run exposed gaps. The skill fits the Prism journey anywhere you depend on reusable agent capabilities—from planning and debugging rituals to integrations—because better skills compound every later phase. Deliverable is a workflow-conformant SKILL.md at the correct path, ready for catalog ingestion and day-to-day invocation.572installs10CatchupCatchup is a journey-wide agent skill for solo builders who lose thread mid-project when Claude Code, Cursor, or similar agents compact or reset context. It runs a fixed, read-only reconstruction pass: recent commits, repo status, worktrees, branch workflow YAML, workspace memory, handoff notes, and the newest non-done plan file, plus optional MCP and GitHub CLI signals when configured. You invoke it after compaction or when landing in an existing worktree so the agent can brief you in a consistent format before you decide the next move. It does not substitute for planning or implementation skills—it prevents duplicated work and wrong assumptions when the conversation no longer matches the repo. Ideal for indie teams using branch-context files and `ai-workspace/` conventions; skip when you are already in the same uninterrupted session with full context in the chat.557installs11WrapWrap is an agent skill for closing a development session after a cycle of work. It first invokes reflect (MEMORY.md, Basic Memory vault, GitHub issues, plan finalization, .last-reflect-ts) and waits for completion. Then it audits git worktrees from the repo root, removes merged branches under .worktrees/, preserves unmerged work with explicit warnings, and handles .branch-context.md only when reflect confirmed consolidation. Solo builders use it when saying goodbye to a session, switching tasks, or preparing for /clear so agents do not leave orphan worktrees or unreflected branch notes behind. It assumes a git-based workflow with optional camacho-style reflect in the same skill ecosystem.556installs12Session Start HookSession-start-hook teaches solo builders how to create Claude Code SessionStart hooks so a fresh session is not blocked by missing node_modules, wrong PYTHONPATH, or other environment gaps. The skill walks through hook input on stdin, optional async execution with a timeout for long installs, and persisting exports via CLAUDE_ENV_FILE so the agent loop inherits the right paths. It targets anyone onboarding a repository to Claude Code—CLI, web, or API—and who wants repeatable test and linter runs without repeating setup prompts every time. You get concrete bash patterns, set -euo pipefail discipline, and notes on remote versus local behavior using CLAUDE_CODE_REMOTE. This is narrow, high-leverage agent-tooling: one hook file can save hours of “install deps first” friction across a solo shipping cadence.550installs13ValidateValidate is a thin agent skill that standardizes how you run a full project health check from the repository root. Solo and indie builders wire a `pnpm validate` script that chains TypeScript checking, linting, formatting, unit tests, and sometimes production build, then invoke this skill so the agent always uses the same command and interprets failures consistently. It fits teams shipping SaaS, CLIs, or APIs where skipping any layer before merge creates regressions. The skill does not define the scripts themselves—it delegates to your package.json and expects you to maintain those steps. After a failed run, the agent should quote the failing step and raw stderr or stdout rather than summarizing away actionable lines. Use it in CI parity locally, before PRs, and when an agent finishes a large refactor and needs a single authoritative green check.549installs14Assemble PanelAssemble Panel is a meta workflow skill for solo and indie builders who run agent-assisted review loops instead of one-off chat critiques. It is invoked by orchestrators such as `/review`, `/plan-review`, and `code-reviewer`—not by end users directly—when something needs a review panel assembled, retained across rounds, or converged under explicit limits. You pass a scope (plan file path or git diff) and optional include/exclude overrides; the skill returns an ordered reviewer panel plus frozen policy fields the caller uses to dispatch real reviewers. That separation keeps governance consistent across Claude Code, Cursor, and Codex setups where the Skill tool may be unavailable and the policy algebra must be applied inline. Use it when you want repeatable multi-reviewer coverage without every caller reimplementing keyword and file-type routing, round caps, or default fallbacks.548installs15CopilotCopilot is a user-invocable Claude Code skill that flips the repo into copilot mode: you steer, the assistant follows with lighter guardrails than full autonomous mode. It runs the shared set-mode.sh script owned by the autonomous skill, sets mode=copilot, and confirms relaxed worktree and main-branch rules plus a 4-hour sliding TTL capped at 12 hours. The intended workflow is menu-style pairing—you can ask the agent to follow your lead step by step instead of batching changes in an isolated worktree. When a plan or task finishes, the skill expects you to return to autonomous mode. Solo builders use it when they want faster iteration on main, tighter human review, or exploratory edits without fighting worktree enforcement. It does not replace installing the ai-env template scripts; missing set-mode.sh is an explicit stop condition.546installs16Policy AlgebraPolicy-algebra turns thin intent or existing plan documents into frozen, drift-checkable Starlark governance blocks that solo builders can embed in SKILL.md files, implementation plans, and agent rule packs. In DEEP mode it frames a structured interview via /grill-me to extract scope, invariants, variable holes, and combinator needs; in SHALLOW mode it reads a file path and confirms rich inputs with less interrogation. The output is a canonical block callers paste into downstream work, plus a verify path that compares a candidate against the frozen artifact so policy does not silently erode across iterations. It is built for indie teams who want machine-checkable guardrails instead of prose-only “rules” that agents ignore. Use it when you are formalizing agent governance, not when you only want to discuss policies in chat without a frozen artifact.524installs17DistillDistill is an orchestration skill for solo builders whose AGENTS.md and rules/ folders have grown unreadable. It chains three sub-skills into one workflow: imperative extraction into JSONL, policy composition into Starlark, and diagram rendering for the resulting rule graph. You can run the full /distill command or isolate a stage when you already have intermediate files. The workflow saves research artifacts under ai-workspace/research and pauses for review before composition, which reduces accidental over-trimming of safety or style rules. It fits builders who treat agent instructions as versioned product surface area—not one-off prompts—and want structured analysis instead of manual grep-and-delete edits across many markdown rule files.1installs