charon-fan/agent-playbook
24 skills44.7k installs1.4k starsGitHub
Install
npx skills add https://github.com/charon-fan/agent-playbookSkills in this repo
1Self Improving AgentSelf-improving-agent is a meta skill from the Agent Playbook that turns ordinary agent sessions into something you can refine over time. Lightweight shell hooks fire before and after tool calls and when a session ends, giving you traceability of tool names, inputs, outputs, and exit codes. Alongside logging, the skill maintains a patterns catalog—documented solutions like splitting large PRDs into notes, task-plan, prd, and technical companion files so product and engineering content do not collide. Solo builders running Claude Code or similar setups can treat this as infrastructure: not a feature shipper, but a feedback loop that encodes what worked after you correct the agent. It fits whenever you repeatedly fight the same structural mistakes in docs, plans, or tool choreography. Expect to integrate hooks into your agent config and curate patterns manually or from feedback rather than getting automatic model retraining.30.1kinstalls2Planning With Filesplanning-with-files teaches agents to work like Manus: every non-trivial effort gets persistent markdown on disk instead of cramming state into context. You create task_plan.md for goals and phases, notes.md for research and failures, and a named deliverable file for the final output, then loop research and plan updates until completion. Solo builders running Claude Code, Cursor, or similar tools use it for multi-step implementation, deep research, and general organization where context windows reset or tool calls multiply. The skill contrasts with PRD-specific planning and pairs naturally with session logging hooks after completion. It is methodology, not a single API integration—usable whenever a task spans more than one session or needs auditable progress.976installs3Security AuditorSecurity Auditor is an agent skill that behaves like a security vulnerability expert aligned with OWASP Top 10 and common application weaknesses. Solo and indie builders invoke it when they need a structured pass over source for missing authorization, IDOR patterns, secrets in code, weak algorithms, and related issues—not when vetting third-party skill packages. The skill encodes checklist-style checks with example shell greps, explains typical failure modes per category, and fits pre-release hardening as well as periodic reviews after features land. It pairs with read-only and search tooling plus optional web lookup so the agent can correlate patterns with current guidance. Placement is multi-phase: primary shelf Ship → security for launch gates, with secondary use during Operate when incidents or compliance questions force another pass. Distinct from install-time skill scanners, this skill targets your own repository.874installs4Skill Routerskill-router is an intelligent routing layer for Claude Code that analyzes what you asked for, classifies intent, and recommends the best matching skill from your installed catalog—with clarification questions when the request is ambiguous. Solo builders accumulating dozens of skills from Prism or GitHub often waste turns guessing filenames or overlapping capabilities; this skill-router turns natural language into a concrete skill choice and short rationale, then offers activation. It fits whenever you are in Idea research, Validate scoping, Build implementation, Ship review, or Operate debugging but do not know which specialized skill applies. Installation is a symlink into the Claude skills directory. It complements domain skills rather than replacing them: you still run code-reviewer or frontend-design after routing. Expect interactive back-and-forth when complexity or task type is unclear.710installs5Architecting SolutionsArchitecting Solutions is an agent-playbook skill for solo builders who need a structured technical design before writing code or provisioning infra. It clarifies requirements and success criteria, analyzes constraints and existing patterns, compares options with trade-offs, and records the decision as a PRD-style document in docs/. Invoke it when users ask for solution design, architecture design, or technical design without a dedicated PRD workflow—charon-fan’s metadata directs PRD-only requests to prd-planner instead. Allowed tools include Read, Write, Edit, Bash, AskUserQuestion, WebSearch, Grep, and Glob, so the agent can ground designs in the real repo. On Prism’s journey, it primarily sits in Validate → scope but repeatedly reappears in Build when extending systems or planning migrations, giving indie teams a citable planning artifact agents can follow.698installs6Test AutomatorTest Automator is an agent skill from the agent-playbook collection that helps solo builders add and harden automated tests while shipping features, without outsourcing judgment to a opaque codegen-only tool. You invoke it when you need cases for a function, broader coverage, or CI-ready suites across common stacks—Jest and Vitest on the frontend, pytest on scripts and APIs, Go’s testing package, or JUnit on JVM services. The skill bundles opinionated practices (deterministic assertions, realistic fixtures, minimal mocking of your own modules) with helper scripts to emit boilerplate and summarize coverage. It fits the Ship phase first but remains relevant late in Build when test-driven work accompanies new modules. Expect the agent to propose structured arrange-act-assert tests, external-service mocks where boundaries matter, and reminders to run tests on every change—not to replace your product-specific edge cases.663installs7Prd PlannerPRD Planner is an agent skill for solo and indie builders who need a repeatable way to produce product requirements documents without the usual agent amnesia. Instead of keeping requirements only in chat context, it forces a four-file workspace: a task plan for progress, a notes file for research and raw requirements, the finished PRD, and a parallel technical design document—all namespaced by a short scope slug in docs/. That pattern addresses context switching, forgotten research, and inconsistent PRD shape when you iterate with Claude Code, Cursor, or similar tools. Use it when you are moving from an idea or feature request toward an implementation-ready spec, especially before you delegate build work to other skills or agents. The workflow intentionally separates exploratory thinking (notes) from polished outputs (prd and tech), so your agent can re-read persisted state instead of re-asking you the same questions. It fits validate-and-build handoffs: approved PRD plus tech.md becomes the source of truth for planners, coders, and reviewers in the same repo.656installs8Figma DesignerFigma Designer is an agent skill for solo builders and small teams who already design in Figma and want agents to stop guessing CSS values. After you share a Figma link, the skill uses the Figma MCP server to fetch the file, walk the node tree, and synthesize a PRD-style spec with tokens, components, and layout detail aimed at pixel-accurate implementation. It assumes FIGMA_ACCESS_TOKEN is set and the official Figma MCP tools are available—check with `mcp-list` before relying on it in CI-style workflows. Best used when you are about to build or refactor UI and need a single source of truth that bridges design and code, not when you only need rough wireframe ideas without a Figma source of truth.647installs9Workflow OrchestratorWorkflow Orchestrator is an agent-playbook skill that turns milestone completion into a deterministic skill chain. After PRD creation, implementation, or other defined checkpoints, it reads hook configuration and dispatches the next skills without you re-explaining context in chat. Modes let you auto-run safe follow-ups, defer heavy work to the background, or gate risky steps behind ask_first confirmation. Progress and decisions are handed to session-logger so later steps inherit a coherent trail. For solo builders running multi-skill playbooks in Claude Code, it reduces dropped handoffs when one skill "finishes" but the real process still has review, logging, or validation left. It pairs naturally with auto-trigger definitions you maintain in the repo rather than one-off ad-hoc prompts.646installs10Session LoggerSession Logger is an agent skill that turns an in-flight coding conversation into a durable markdown session file when you ask to save or log the chat. Solo and indie builders use it after debugging spikes, architecture debates, or multi-step refactors so the next session starts from written decisions instead of memory. It reviews the thread, extracts key information, and saves under `sessions/` with a date and topic slug. The playbook positions it for continuity across Claude Code sessions, learning from past approaches, and tracking how a project evolved. Installation is a symlink into `~/.claude/skills`. Because logs stay gitignored, it fits personal or team machines without leaking chat content into the repo. It is lightweight process hygiene—not a vector DB—best paired with your normal git history and issue tracker for formal records.617installs11Qa ExpertQA Expert is an agent skill for solo builders who can code features fast but lack a written testing strategy and enforceable gates before merge. It packages risk-based prioritization—treating money, security, and data as critical—with a classic pyramid split and concrete npm-style pre-commit and pre-merge commands your agent can scaffold in CI. Use it when you ask for quality gates, better coverage, or a testing approach without hiring a QA lead. It spans planning and ship: you can draft the matrix during Build, but the canonical Prism shelf is Ship testing because deliverables are gates and allocation percentages ready for release. The skill does not execute your test suite by itself; it structures decisions and scripts. Pair it with your stack’s real commands. Optional session-logger hook logs QA activity after completion per metadata.613installs12DebuggerDebugger is an agent skill from the Agent Playbook that turns vague “it broke” reports into a repeatable investigation. It activates when you mention bugs, errors, or unexpected behavior, then walks through reproduction steps, log and git context, isolation tactics like binary search, and root-cause analysis before proposing fixes. Solo builders benefit because the skill encodes specialist habits—correlating stack traces, shrinking repros, and verifying outcomes—without hiring a dedicated on-call debugger for every stack. It spans more than one journey moment: you might use it while hardening features in Build, blocking release in Ship, or chasing production anomalies in Operate. Optional post-complete hooks log the session and feed pattern learning in the background. Pair it with your test suite or monitoring data; it does not replace automated CI but gives your coding agent a disciplined lens when something still fails after a quick patch.610installs13Code ReviewerCode Reviewer is an agent-playbook skill that turns vague “look at my code” requests into a consistent review ritual for solo and indie builders shipping through Claude Code, Cursor, or Codex. You point it at a pull request, a working tree, or a path like `src/auth/`, and it analyzes changes across correctness, edge cases, error handling, OWASP-oriented security, performance pitfalls such as N+1 queries, DRY and naming quality, meaningful tests, docs, and maintainability. Output is organized by severity so you can fix Critical and High items before merge without drowning in nitpicks. It fits the ship phase when you are about to merge, but the same checklist helps during build when you iterate on features or harden auth. It does not replace automated CI or dependency scanners—it complements them with human-style judgment your agent can apply locally. Pair it with your test and security skills when the review surfaces gaps.607installs14Refactoring SpecialistRefactoring Specialist is an agent skill from the agent-playbook collection that guides solo builders through disciplined code cleanup without changing outward behavior. It activates on requests to refactor, tidy functions, or fix messy modules, then applies classic catalog moves such as extract method, extract class, introduce parameter objects, and replace conditionals with polymorphism. Four principles anchor the workflow: preserve behavior, take small steps, keep tests passing throughout, and commit after each successful transformation. A short checklist and smell list (long methods, large classes, duplicate logic, feature envy) give agents concrete exit criteria. The skill fits indie developers who already have working code and tests but need structured debt reduction before shipping or during ongoing build maintenance. It is not a greenfield generator; it assumes you can run your test suite and want incremental commits rather than one risky rewrite.595installs15Prd Implementation Precheckprd-implementation-precheck is a workflow skill for solo builders who ask an agent to implement a product requirements document without silent scope expansion or pattern-breaking edits. It reads the PRD, runs a structured preflight across scope, architectural alignment, dependencies, behavioral edge cases, risk, and test clarity, then delivers a report with explicit questions. The agent pauses until you confirm, which turns PRD-driven coding from a one-shot prompt into a reviewed commitment. After approval, implementation proceeds with restrained, codebase-consistent changes. It pairs naturally with planning artifacts and code review skills in a larger playbook. Triggers when you phrase work as implementing a PRD path or feature spec that still needs human judgment on tradeoffs.588installs16Api DocumenterAPI Documenter is an agent skill from the agent-playbook collection that helps solo builders turn an in-progress HTTP API into a credible OpenAPI 3.0 specification. You invoke it with plain prompts—document this API, create OpenAPI spec, generate API documentation—and the skill steers the agent toward RESTful paths, explicit request and response models, auth blocks, and consistent error envelopes instead of fragmented markdown notes. Bundled Python utilities scaffold and validate YAML so you can keep the spec in repo and gate CI later. It fits indie SaaS and CLI-backed services where the API is the product boundary and you need something SDK generators, portals, and coding agents can trust. The skill is a generator pattern, not a live gateway or mock server; you still need accurate route handlers and security review before exposing endpoints. Intermediate complexity assumes comfort editing YAML, running small Python helpers, and aligning spec versions with your real deployment.584installs17Api DesignerApi-designer is an agent skill from the Agent Playbook that acts as a REST and GraphQL API architect for solo builders shipping SaaS, mobile backends, or public integrations. Invoke it when you are sketching resources and routes from scratch, refactoring a confusing RPC-style surface into REST, or preparing an OpenAPI-style spec for an agent to implement. The readme encodes concrete tables for HTTP methods (safe and idempotent expectations) and status codes, plus naming rules that discourage verb-heavy paths. It is aimed at Claude Code workflows with Read, Write, Edit, Bash, and web research tools, and metadata hooks can chain into session logging after a design session. It does not replace integration testing or gateway configuration; it produces design decisions and specifications you then implement in the build phase.575installs18Documentation EngineerDocumentation Engineer is an agent skill for solo builders who need professional docs without pausing feature work. Trigger it when you want a README, API endpoint reference, inline explanations, or system-design write-ups from existing code or rough notes. The skill packages concrete templates: REST-style endpoint sections with parameters and error tables, and README scaffolds from quick start through configuration. Companion scripts generate_docs.py and validate_docs.py help bootstrap folder structure and catch gaps before you publish to GitHub or hand docs to integrators. It fits Claude Code, Cursor, and similar agents when you say “document this API” or “create a README.” Pair it during Build as features land, again in Ship for release notes readiness, and at Launch when SEO and developer-portal pages need consistent structure. The approach favors clarity and scanability over marketing fluff, which keeps support load down as your user base grows.569installs19Auto TriggerAuto-Trigger is an agent-playbook configuration skill that defines how one skill automatically invokes the next when a workflow milestone completes. Solo builders assembling reliable agent pipelines use it indirectly: they embed hook blocks in other skills’ front matter or rely on workflow-orchestrator to read these definitions and run follow-ups such as session-logger, self-improving-agent, or code-reviewer. Documented chains include PRD completion (logging and background improvement) and post-implementation review triggers. The skill explicitly warns against direct invocation—it is metadata and contract for automation across your skill graph. Intermediate complexity reflects YAML hook design, modes (auto vs background), and conditions like “PRD file exists and is complete.” Pair it with orchestration skills rather than treating it as a standalone task tool.568installs20Commit HelperCommit Helper is an agent-playbook skill for solo builders who want consistent Git history without memorizing Conventional Commits. When you ask to commit changes, the agent reviews the diff, proposes a properly typed subject line and explanatory body, shows it for confirmation, and only then runs the commit. That workflow reduces vague messages like “fix stuff” and keeps scopes and types ready for semantic versioning and automated release notes. It fits any repo where you already use Git with Claude Code or similar agents. A small validation script lets you double-check a message string offline. Install it when you ship frequently from agent sessions and need reviewable, changelog-friendly commits without leaving the chat.563installs21Deployment EngineerDeployment Engineer is an agent-playbook skill that helps solo builders stand up CI/CD and environment-aware releases without hiring a platform team. You invoke it when you need GitHub Actions wiring, a strategy choice between zero-downtime blue-green, gradual rolling, or risk-limited canary, or a starting Kubernetes manifest you can harden later. Bundled script names point to generate_deploy.py for environment-specific config and validate_deploy.py to catch misconfigurations before promote. The monitoring section reinforces operability basics—golden signals, structured logs with request IDs, and alerts tied to SLOs rather than noise. It is procedural DevOps knowledge packaged for Claude Code style sessions, not a hosted pipeline runner. Expect the agent to propose YAML, workflow steps, and checklists you paste into your repo and adapt to your cloud provider.563installs22Performance EngineerPerformance Engineer is an agent-playbook skill that helps solo builders answer “why is this slow?” with structured targets, profiling scripts, and repeatable checklists instead of random micro-optimizations. You invoke it when optimizing code, profiling an app, or investigating regressions; the skill anchors discussion to concrete SLOs for APIs, databases, and front-end interactivity. It points to profile and perf_report helpers and summarizes common levers like caching, query batching, and payload shrinkage. Monitoring guidance covers latency percentiles, throughput, error rates, and alert thresholds so fixes survive production. Use it before ship when Lighthouse or p95 dashboards look wrong, and again in operate when alerts fire—always pairing baseline measurement with post-fix verification.563installs23Create PrCreate PR is a Claude Code workflow skill for opening pull requests while keeping bilingual documentation aligned with code changes. It targets solo maintainers and small teams on repositories—especially agent-playbook—that publish both README.md and README.zh-CN.md and cannot afford drift every time a feature lands. The agent analyzes the git diff, decides what documentation must change, updates both language files, runs through a verification checklist, then commits, pushes, and formats the PR body from a template. Installation is a standard skills symlink into ~/.claude/skills. Use it at the end of a focused change when you are ready for review, not when you are still exploring design or running full test matrices. It is opinionated toward this repo’s bilingual contract; adapt the pattern if you only have a single-locale readme. The skill improves shipping hygiene—traceable diffs, paired docs, and repeatable PR copy—without replacing CI, code review bots, or merge policies.539installs24Long Task CoordinatorLong Task Coordinator is an agent skill for coordinating work that outlasts a single conversation. Indie builders use it when a migration, research sweep, or multi-step implementation would otherwise lose context between sessions or misreport progress. The skill pushes durable state files, recovery before new proposals, worker-sized chunks with clear ownership, and treating waiting on external results as a first-class status rather than a silent failure. Closing work means verifying acceptance criteria: persisted status, blockers, next action, and completion claims must align. It is methodology for agent orchestration, not a domain-specific deploy or test runner. Use it whenever long-running tasks risk hallucinated progress; skip it for one-shot questions answerable in one reply without persistence.530installs