boshu2/agentops
49 skills40.2k installs18.8k starsGitHub
Install
npx skills add https://github.com/boshu2/agentopsSkills in this repo
1Councilcouncil is an agentops judgment skill that convenes multiple independent reasoners over a shared briefing and returns one synthesis. Solo builders orchestrating serious agent-driven delivery use it when a single model pass is not enough—especially for slice plans before implementation, per-slice review when automated tests pass but product taste still matters, and bead-level acceptance when examples green-light technically but consumer-facing behavior needs adversarial eyes. Mode selects the deliberation pattern (brainstorm, debate, verdict) while focus, depth, runtime, and roster tune how hard the council pushes. It consumes standards context and produces structured verdict artifacts other skills in the operating loop can treat as gates. Intermediate-to-advanced teams already running design-by-contract or eval harnesses will recognize the intent: expensive judgment upfront beats shipping polished wrongness.2.3kinstalls2Bug HuntBug Hunt (Audit-Fix-Rescan Cycle) is an agent skill from AgentOps that teaches a disciplined multi-pass review loop instead of treating one bug scan as release-ready. Solo builders shipping SaaS, APIs, or CLIs with coding agents use it when a single pass only removes loud failures—null dereferences, missing awaits, obvious leaks—while subtler logic and newly introduced regressions remain. The documented cycle alternates audit, fix, and rescan until no defects remain visible under the stated convergence rules, with explicit guidance for pre-release hardening, post-fix invariant shifts, and Audit Mode over more than five files. It pairs naturally with Ship-phase review and testing workflows and still applies late in Build when integrating large agent-written diffs. The skill is procedural methodology for depth of inspection, not a standalone static analyzer or hosted CI product.928installs3Swarmswarm is an agent-ops coordination contract for solo builders and small teams who spin up multiple autonomous streams against one repository at once. Without a declared partition, parallel agents routinely collide on generated outputs—registry.json, documentation navigation, CLI reference regen, embedded copies—and the stream that finishes last wins, erasing the other’s work. This skill forces each stream to publish eight fields before any commit: identity, branch, base SHA, owned versus forbidden paths, who owns the final regen of shared generated files, when to ping siblings, and what “done” means for handoff. The contract must live in a durable artifact siblings can read, because chat context does not survive stream changes. It is methodology, not a single integration: use it whenever you parallelize doctor, wireup, or feature beads in Agent-Genie-style workflows across build-heavy weeks and pre-merge ship hygiene.911installs4Codex Teamcodex-team is a reference contract for how AgentOps skills should assume Claude Code capabilities in the 2.1.x line. Solo and indie builders running multi-agent or parallel sessions use it to standardize which slash commands to prefer, how to define teammates under `.claude/agents/*.md`, and when to reach for worktree isolation instead of risky overlapping writes. The skill is not a feature tutorial; it is the shared baseline so other skills, hooks, and runbooks stay consistent with Anthropic’s current CLI surface. That matters when you are shipping agent-heavy repos and need one authoritative list of commands, agent fields, and isolation patterns rather than guessing from old blog posts. Invoke it whenever you are authoring or updating AgentOps automation, onboarding a second parallel Claude session, or auditing whether your team docs still mention deprecated flows.881installs5Evolveevolve is an AgentOps execution skill for solo builders and small teams who want local, model-agnostic autonomous improvement instead of hand-waving “keep going” in chat. It closes the loop from finished work to the next highest-value item: run post-mortems, analyze repository state, select or create goals, delegate research-planning-implementation-validation to the RPI stack, then harvest follow-ups and repeat. The philosophy mirrors managed-agent outcome loops—grade against fitness, retry on failure—but runs on your machine via terminal-native `ao evolve`. It depends on rpi, post-mortem, and compile skills in the same ecosystem, and emits tangible deltas in code and GOALS.md. Use it when the codebase is live enough to measure (DORA-style thinking, lean iteration) and you want disciplined compounding rather than random refactors. It is advanced operator tooling: set caps, watch regression breakers, and treat evolve as supervision over agent work, not a fire-and-forget magic wand.865installs6ResearchThe agentops research skill is procedural documentation for solo builders running multi-agent workflows inside environments that only expose the Task tool with run_in_background. It is not market or user research—it defines when to treat background Task spawning as a last resort, what you lose compared to native teams, and copy-paste prompts for parallel council judges that persist verdicts under .agents/council/. You learn to batch spawns in one message for parallelism, poll by task_id later, and accept fire-and-forget constraints: no inter-agent messaging, no redirect mid-run, and brittle shutdown. Use it while building or shipping agent-heavy repos where you need correctness, error-path, or completeness reviewers without a full orchestration stack. Pair with your main implementation skill after packets are prepared so judges read stable context files rather than chat drift.860installs7Pre MortemPre-mortem is a journey-wide AgentOps skill that injects structured failure prediction into plan and code review workflows. Before quick or deep review, it requires retrieving relevant prior learnings via the ao CLI and loading compiled prevention checks from `.agents/pre-mortem-checks/` when present—explicitly not bypassed by fast review modes. Findings rank by severity, applicability to the plan, language overlap, and literal plan text, with changed-file overlap prioritized when the plan names paths. When compiled artifacts are missing or thin, it falls back to `.agents/findings/registry.jsonl` while failing open on malformed or unreadable inputs. Solo builders use it to surface recurring mistakes from their own flywheel before shipping or iterating. It fits anywhere a written plan or change set needs a disciplined what-could-go-wrong pass tied to institutional memory rather than generic LLM caution.852installs8DocDoc is an AgentOps agent skill that turns documentation debt into executable commands for solo builders maintaining repos with agents. It parses /doc [command] [target], classifies the repository as coding, informational, or ops based on package manifests and existing doc trees, then runs discover and coverage style shell checks to find missing docstrings and comments before writing files. The skill is tiered as product, uses a fork window with HISTORY excluded, and declares hexagonal supporting role with standards as a dependency and documentation as the deliverable contract. It fits builders who want wiki-knowledge-surface and code-complete practices applied consistently rather than one-off README edits. Use during active feature work or before handoff; for pure marketing copy, use a content skill instead.850installs9PlanPlan is an AgentOps execution-tier skill that turns a BDD intent issue into a slice validation plan and living issue backlog. Solo builders and small teams use it when a spec exists but work still needs vertical slices, distinct write scopes, integration order, and an owner per slice before agents touch code. The skill enforces running the workflow end-to-end: consume standards and intent, emit dated plan files under `.agents/plans/`, and create beads issues through the `bd` CLI. Wave grouping is gated—shared migrations, contracts, or CLI surfaces block parallelization. It sits between research/pre-mortem and implement/crank in the operating loop, so outputs are ready for crank-driven execution rather than open-ended chat planning.849installs10Post MortemPost-mortem in the AgentOps stack is a journey-wide agent skill that governs Phase 4 activation: which learnings from Phase 3 graduate into project MEMORY.md, how they are scored, and how constraints and improvement queues are compiled. Solo builders using Claude Code with AgentOps need a repeatable rule so high-confidence, well-cited, recent insights become durable memory instead of chat noise. The skill documents a explicit formula—confidence plus citations plus recency—with a promotion bar at six points, and restricts candidates to items newer than the last-processed marker so old entries are not endlessly re-evaluated. It maps promoted content into structured MEMORY sections for architecture, process, and session summaries at the Claude project memory path. Use it whenever you finish a heavy agent session, after retrospectives, or when tuning how aggressively your agent remembers patterns. It pairs with earlier AgentOps phases and keeps human review in the loop for what becomes long-term agent context.849installs11HandoffHandoff is a journey-wide agent skill for solo builders and agent-heavy teams who lose hours when context dies between sessions. Invoking /handoff at session end compacts what mattered: a clear topic identifier, evidence-backed accomplishments drawn from git, beads, and ratchet signals, the exact pause point including in-flight work, and a prioritized list of files the next run should read first. It then writes a structured handoff document and a continuation prompt so the next session does not re-walk the repository. The skill is procedural knowledge for agent ops—supporting hexagon in a larger runtime—not a code generator. Use it after substantive work in Validate scoping, Build implementation, Ship review, or Operate incident response whenever you will resume later. It pairs naturally with planning and issue-tracking habits but does not replace human judgment on what to ship next.844installs12Retroretro is an AgentOps agent skill for solo builders who run long-lived coding agents and do not want every useful nugget buried in the next handoff. When an insight is too small for a full post-mortem but too valuable to ignore—an API quirk, a flaky test habit, a prompt tweak that worked—you invoke retro to append it to .agents/learnings/ with the smallest possible ritual. The skill follows an executable BDD-style spec: one observation in, documented capture out, and explicit separation from promotion so you are not prematurely canonizing noise. It consumes team standards context and produces structured result metadata aligned with the broader corpus loop. Use it journey-wide whenever you finish a focused task, recover from a mistake, or notice a repeatable agent behavior, regardless of whether you are still in Build, Ship, or Operate. Pair mentally with heavier capture surfaces when incidents warrant deeper review; retro is the default “write it down now” move.842installs13ComplexityComplexity is an AgentOps slash skill that analyzes source code and returns a focused list of refactor hotspots ranked by cyclomatic complexity. Solo builders and small teams use it in the ship phase when a codebase feels brittle but you cannot afford a full refactor— you need the agent to point at the few functions that actually drive risk. Pass a path to analyze a directory or file; omit the path and the skill narrows to recently changed sources so PR-sized reviews stay fast. The design explicitly rejects dumping every function: output is a curated ranking meant to steer human or agent refactors. The repository documents behavior with an executable Gherkin-style spec and a small bash harness that verifies SKILL.md frontmatter exists. It sits in a domain hexagon that consumes project documentation and coding standards and prints results to stdout for downstream automation. Pair it with code review or testing skills when you want measurable complexity gates before release.839installs14ProductProduct is an AgentOps agent skill that forces a structured, interactive pass to create or refine PRODUCT.md in a target directory. Unlike a passive template dump, the SKILL.md requires real execution: check for an existing file, offer overwrite or merge-from-existing, read README and context to suggest answers, and write the artifact that downstream /pre-mortem and /vibe reviews consume for product-aware critique. It sits in the validate lane of the solo-builder journey because crisp product boundaries reduce wasted build and ship cycles, but it also pays off whenever you revisit positioning mid-project. Metadata ties it to DDD bounded-context thinking and classic product-risk framing without requiring external CLIs. For indie hackers using Claude Code or Cursor with AgentOps slash commands, it turns fuzzy intent into a durable PRODUCT.md contract the rest of the toolkit can trust.836installs15CrankCrank is an execution-tier AgentOps skill that tells your coding agent to actually run the wave workflow—not merely describe it. Solo builders juggling epics use it after a slice validation plan exists: each wave invokes swarm with parallel slices only when write scopes, migrations, contracts, and owners are explicit. Failed validity rows force sequential work, which protects indie repos from merge chaos. Output is real code changes and machine-readable swarm results JSON for downstream validation. It assumes familiarity with beads, implement, vibe, and post-mortem skills in the same ecosystem. Intermediate to advanced complexity because parallelism rules and discard paths per slice must be understood. Best when you treat delivery as continuous waves rather than one giant prompt.833installs16VibeVibe (Complexity Analysis, Step 2) is an AgentOps council skill that measures code complexity only for languages present in your change set. Solo builders running multi-agent PR reviews on mixed Go/Python CLIs benefit because blind full-tree gocyclo has hung past runs on docs-only epics. The skill detects languages from git diff or a path listing, logs preflight decisions, runs radon cyclomatic and maintainability indexes for Python when .py files change, and invokes Go cyclomatic analysis only when .go files change—otherwise it prints explicit skip reasons. Install it when you want Ship-phase review rituals to stay fast and honest about missing tools (pip install radon). It complements broader test suites rather than replacing them, and pairs naturally with council preflight steps before security or merge gates.833installs17Rpirpi encodes autonomous execution rules for agent-driven product work: a three-phase pipeline that must run discovery, implementation, and validation in a single session unless marked fast complexity. Solo builders invoking /rpi want the agent to execute hands-free—no pause for commit permission, no strategy detours—because stopping after implementation skips quality checks and prevents learnings from updating the team’s operating knowledge. The skill positions validation as the midpoint’s necessary sequel, wrapping vibe checks with post-mortem, retro, and forge steps rather than treating a lone vibe command as done. That makes it journey-wide process knowledge usable during feature builds, ship-time hardening, and post-incident iteration whenever an agent might otherwise declare victory too early. It pairs naturally with agentops-style repos where repeatable agent rituals matter more than one-off chat prompts. Skip it when you only need a lightweight code snippet without accountability, or when explicit human gating between every sub-step is required via --interactive.832installs18Quickstartquickstart is the AgentOps full skill catalog: a journey-wide orientation doc for solo builders using Claude Code-style slash commands to run structured agent work. Rather than implementing one feature, it explains how skills compose—/evolve driving /rpi fitness loops, /crank fanning out to /swarm and parallel /implement waves, and standalone primitives for research, brainstorming, planning, implementation, vibe checks, pre-mortems, post-mortems, multi-model /council judges, and /release tagging. Every listed skill is described as usable on its own while /swarm acts as the multiplier for parallelizing almost anything. Use it when you are new to the repo, need to pick the right command for a phase of work, or want to see validation and build paths without reading every SKILL.md. It is meta documentation, not a substitute for invoking the underlying skills.826installs19Tracetrace is an AgentOps workflow skill that forces an agent to follow decision provenance instead of guessing history. Solo builders maintaining complex agent repositories use it when they need to know how an architectural choice evolved, when a concept first appeared, or why a subsystem was shaped a certain way. The SKILL.md draws a hard line: file-path lineage belongs to /provenance, while keyword and concept targets trigger CASS-backed session search plus git and handoff mining, writing structured research notes under .agents/research. It declares a dependency on provenance and produces a machine-readable result.json alongside human-readable trace memos. Permissions include Read, Grep, Glob, and Bash, with forked context that excludes HISTORY noise. Because decisions surface during planning, review, and production iteration, the skill is multi-phase even though Prism shelves it under Operate iterate for ongoing codebase stewardship.824installs20ImplementThe implement skill’s behavioral-spec segment is an optional capstone after verification succeeds: it documents what the change does in user-facing terms and encodes measurable acceptance vectors for downstream agent validation. Solo builders and small teams running AgentOps-style workflows use it when they want implementations to be judged against behavior—not only green tests—before merge or release. The output is a versioned JSON artifact with satisfaction_threshold (default 0.7), scoped files and functions, and dimensional thresholds such as correctness, performance, usability, or security. It pairs naturally with issue-driven implement flows and explicit validation pipelines where STEP 1.8 consumes these specs. Skip it when you only need a quick fix without behavioral audit trails or when the work is docs, chore, or CI-only.821installs21ReleaseThe AgentOps release skill runs the `/release` workflow to produce a changelog that acts as a research artifact for the next agent or contributor, not marketing fluff or a raw diff dump. Each run generates CHANGELOG.md as permanent, append-only history and a separate docs/releases/YYYY-MM-DD-vversion-notes.md file as the GitHub Release body. Solo builders and small teams use it when they ship with agents that need orientation across project history without re-reading every commit. The skill enforces audience separation: durable navigability and evidence in the changelog; jargon-stripped impact in the notes. It fits indie SaaS, CLIs, and agent-maintained repos where release hygiene keeps downstream coding sessions accurate. Invoke when cutting a version, preparing a GitHub Release, or when history must answer what changed, when it shipped, and why it matters for the next session.819installs22StatusThe AgentOps status skill implements `/status` as a work-status dashboard for agents and human operators orienting in a repo. It pulls the canonical picture from the bd tracker—ready work, in-progress items, and open epics—and layers ratchet, flywheel, and git context so you see project health at a glance instead of hopping between CLIs. Solo builders running agentic delivery loops use it at session start or before delegating the next task. Machine workflows can call `/status --json` for the same fields without parsing prose. When optional AgentOps tools are absent, the skill marks those sections unavailable and still renders the rest, which keeps automation reliable on partial setups. It targets agent-first repos with bd-backed issue tracking rather than generic Jira dashboards.818installs23Brainstormbrainstorm is the boshu2/agentops /brainstorm skill that forces separation of goals from implementation before you commit to a solution. Solo builders running hexagonal AgentOps use it when a free-text goal needs to become concrete acceptance examples that downstream /discovery can fold into a BDD intent issue. Default goal-clarification walks four phases; ideation mode helps when you are still choosing among ideas, then you can hand the winner back for HOW exploration. It consumes shared standards, excludes noisy context sections, and emits structured JSON aligned to skills/research/schemas/findings.json. Treat it as journey-wide process knowledge: anytime you might jump into code or tickets without testable examples, run brainstorm first. The skill pairs lean-startup and mythical-man-month practices with domain-level intent so your agent stack stays traceable from verdict to implementation.807installs24Reverse Engineer RpiReverse-Engineer RPI is an agent skill for solo builders who inherit or fork a repo and need a trustworthy picture of what the product actually does before they commit roadmap or refactor work. It runs in binary mode, optionally guided by a documentation sitemap, and walks through feature inventory, code mapping, and spec generation with validation gates so you do not ship plans based on stale READMEs alone. The workflow deliberately keeps three lenses separate: what documentation says, what the repository proves, and what hosted or control-plane behavior implies—so Claude Code or similar agents do not conflate marketing copy with implementation. Contract-style assertions (package identity, binary entrypoints, help-text flag substrings) help lock CLI surface docs to real code. Use it when onboarding to an unfamiliar agent-ops or tooling repo, preparing cc-sdd or multi-package monorepos for safer changes, or when you need citable specs for the next planning or review pass.802installs25RecoverRecover is an AgentOps driving-adapter skill that rebuilds session context after a break, compaction, or handoff. Solo and indie builders running long agent sessions on a repo with RPI phased state and bd issue tracking invoke it to avoid cold starts: you see which lifecycle phase you were in, what work was claimed or ready, and what git left behind. Output is a human-readable recovery dashboard or structured JSON when you pass `--json`. It fits builders who treat `.agents/rpi` and bd as the source of truth for multi-step agent work. Use it at the start of any resumed session before picking new tasks or rewriting plans from scratch.795installs26FlywheelFlywheel is an AgentOps background skill for solo builders and small teams running boshu2/agentops-style repos who want agent sessions to leave behind searchable learnings instead of vanishing in chat logs. Given /flywheel, it counts top-level files in .agents/learnings, patterns, research, and retros, then frames results as flywheel velocity and friction against the Sessions → Transcripts → Forge → Pool → Promote → Knowledge loop. It consumes no upstream skills, produces learnings-oriented artifacts, and runs with Read, Grep, Glob, and Bash on a lightweight model tier. Use after several agent sessions or before planning the next sprint of agent work—not as a user-facing product feature. Advanced complexity: expects an .agents layout and familiarity with AgentOps conventions. Internal metadata marks it non-user-facing but valuable for operators curating agent memory.786installs27GoalsGoals documents the executable-spec layer for AgentOps ao goals: scenario satisfaction (F2), trace/render (F4), and auto re-steer (F5), with precise JSON contracts and exit-code rules split from SKILL.md into this reference. Solo builders and tech leads use ao goals measure to roll up every behavioral scenario tied to a directive, compute satisfied/linked ratio, compare to a threshold (commonly 0.8), and emit GREEN, YELLOW when nothing is linked yet, or RED when below threshold. The --scenarios-only flag evaluates only that layer—ideal for CI loops while scenarios are in flux—while full measure can still run shell gate commands. Producers consume latest scenario result artifacts from the ao scenario family per ADR-0003 resolution order. Advanced skill: you need directives, linked scenarios, and result artifacts on disk. Primary handoff is to fix failing scenarios or add links before treating a directive as done.785installs28Using Agentopsusing-agentops is an internal meta skill that documents the AgentOps operating model for solo builders and small teams running Claude Code, Cursor, Codex, and similar agents. It explains how AgentOps acts as a context compiler—turning raw session signal into captured learnings, validation gates, and better next work. The guide covers bookkeeping for findings and reusable context, plan and code review before ship, single skills and hooks as primitives, and higher-level flows you can invoke by name. The centerpiece is the RPI cycle (Research, Plan, Implement, Validate) with a knowledge flywheel that feeds back into research. Practitioners get concrete CLI patterns for searching and looking up knowledge, including recording adoption when a search result is reused. It is reference documentation rather than a user-invocable automation step, but it belongs in Prism so builders can discover how to structure agent operations consistently across the journey.776installs29Beadsbeads is an anti-patterns skill for solo builders and small teams running the Beads issue tracker alongside coding agents. It encodes production lessons so autonomous runs do not trust stale exports, invent invalid issue IDs, or corrupt the Dolt-backed database. The guide contrasts wrong habits—scraping `.beads/issues.jsonl` for readiness when `bd` exists, or creating hierarchical dot-separated IDs—with the correct `bd ready --json`, `bd show <id> --json`, and standard `prefix-xxxx` identifiers. That matters because bad ID formats fail import validation, break `bd doctor --fix`, and leave agents scheduling work from outdated parent notes. Use it whenever AgentOps-style workflows route tasks through beads during implementation and when you iterate on tracker hygiene after incidents. It is procedural guardrails, not a beads installer or MCP bridge.775installs30Heal SkillHeal Skill (Codex Parity Repair) is an AgentOps workflow for maintainers who ship the same capability to Claude-style skills/ and Codex-specific skills-codex/ trees. Solo builders hit drift when search-replace refactors leave Codex artifacts with Claude-only terminology, wrong backend names, or doubled phrases that confuse the operator layer. The skill enforces audit-first discipline: run audit-codex-parity.sh, compare canonical versus shipped bodies, then fix source contract first or patch overrides when Codex needs lasting tailoring. It separates durable SKILL body overrides from prompt.md operator prompts and points at catalog.json for registry consistency. Use it whenever skills-codex is canonically wrong but skills/ is still the workflow source of truth—so your catalog stays trustworthy across agents without rewriting the whole repo blind.773installs31SecurityThe AgentOps security skill packages executable security expectations for repos where coding agents follow AGENTS.md and layered documentation. Instead of generic security tips, it encodes attack scenarios—such as instructions to ignore precedence rules or over-trust all repo text—and maps them to file globs and required phrase patterns that must appear in operator contracts. Solo builders running Claude Code or similar agents use it when they want repeatable audits that agents cannot trivially prompt-inject around. It spans ship-time hardening and operate-time regression checks when docs or agent policies change. The skill is intermediate because you need to understand how cases, targets, and require_groups fit your repo layout, but the structure is data-driven rather than a manual pen-test checklist.773installs32RatchetRatchet is an AgentOps executable spec for the /ratchet skill: a permanent progress gate for the BC3 loop. Solo and indie builders running structured agent workflows use it after validation, vibe checks, or post-mortems pass so that each completed step—research, plan, implement, vibe, or post-mortem—is recorded once and never undone. The skill writes append-only entries to .agents/ao/chain.jsonl and related .agents/rpi/*.md outputs, matching a chaos-then-filter-then-ratchet model where only satisfied gates advance the loop. It fits builders who treat agent work as a pipeline rather than disposable chat sessions, especially when multiple attempts must be filtered before locking progress. Pair it with upstream validation and review skills in the same AgentOps hexagon so ratchet only runs on outputs you intend to keep.771installs33StandardsStandards is an AgentOps architecture vocabulary skill that acts as the canonical register for domain-driven design and hexagonal terms used across the toolkit. It tells agents and humans to name aggregates, roots, boundaries, and related concepts exactly as defined so invariants—such as legal packet phases and consistent attempt graphs—stay enforceable in code. The document ties vocabulary to concrete anchors like aggregate.go and positions ExecutionPacket as the sole aggregate root for mutations. It is meta-documentation: new terms append in place rather than renaming, reducing drift between hooks, schemas, and CLI. Solo builders shipping serious agent orchestration—not casual prompt snippets—invoke it when reviewing PRs, writing new skills, or aligning hexagonal ports and adapters language with the rest of the repo.770installs34ConverterConverter is an AgentOps meta-skill for solo builders who maintain a personal or team skill library and need one source skill to run on multiple coding agents. It reads SKILL.md frontmatter between --- markers, collects the markdown body, enumerates references/ and scripts/, assembles a SkillBundle per the bundled schema, then writes platform-specific artifacts such as Codex SKILL.md with prompt.md or Cursor-compatible layouts. Quick start examples cover single-skill and --all batch conversion. Use it during Build when standardizing agent-tooling, and again in Operate when upstream AgentOps skills change and you must refresh downstream copies. It reduces manual copy-paste that breaks frontmatter fields like practices, produces, and context windows. The skill assumes AgentOps skill_api_version conventions and isolated context windows—appropriate for cross-vendor tier packaging rather than end-user app features.768installs35Forgeforge is an AgentOps skill for extracting reusable knowledge from coding-agent sessions. Solo builders running long Claude Code or Codex sessions use it when valuable decisions evaporate once the chat ends. On session end, a hook can queue the last transcript for analysis; manually, you point forge at a path or the last session to score extractions and write dated forge markdown under `.agents/forge`. Promote flows turn repeated citations into durable learnings, complementary to automatic draft files from the feedback compiler. It compounds agent reliability across Build agent-tooling tweaks and Operate iteration without maintaining a separate note-taking ritual by hand.764installs36ReadmeReadme is an AgentOps documentation skill for builders who treat the README as the product’s front door. It forces an executable workflow: interview or rewrite, apply fixed editorial patterns that put the reader’s pain before framework jargon, and run council validation so shallow skimmers and thorough evaluators both get what they need. Commands support greenfield generation, structured rewrites, and validate-only passes on existing files. The skill sits in agent and CLI repos alike, producing README.md under a documented output contract while consuming full intel scope in a forked task window. It is most often invoked when a repo is code-complete enough to explain but still losing visitors to vague positioning. Multi-phase use is common—polish docs during Build, tighten messaging before Ship, and refresh positioning at Launch—without replacing a dedicated marketing site or API reference generator.762installs37InjectThe inject skill is the executable behavioral spec for agentops ao inject, the just-in-time knowledge surface that pulls local learnings, patterns, and sessions into an agent’s working context under a fixed markdown and JSON contract. Solo builders maintaining a .agents corpus use it to understand what the CLI must emit when the directory is empty versus populated, how --for narrows injection to a named skill, and how quality gates prevent low-value learnings from polluting prompts. Scenarios are tied to Go integration tests, which makes the skill suitable as a contract reference when extending the CLI or debugging missing headers in agent loops. It fits anyone treating institutional memory as code-adjacent artifacts rather than ad-hoc chat history.761installs38SharedThe shared skill is the agentops fallback playbook for spawning background agents through the Task tool with run_in_background=true when neither Codex sub-agents nor Claude native teams are available. Solo builders running council reviews or swarm-style parallel work use it to issue multiple Task calls in the same turn so judges run concurrently, each persisting results to filesystem paths under .agents rather than messaging channels. The readme is honest about tradeoffs: no redirect, no scope adjustment, no inter-agent communication, and debate modes that depend on messaging are unsupported. It names subagent_type general-purpose, documents returned task_id for polling, and fits builders who already standardized on agentops patterns but hit an environment where only the generic Task API exists.761installs39ProvenanceProvenance is an AgentOps agent skill that traces knowledge-artifact lineage back to originating sources, sessions, and linked files. Given an artifact path, the workflow reads the file, extracts provenance metadata (references, session IDs, dates, related artifacts), and returns a lineage report suitable for debugging mistaken outputs, stale docs, or orphan generated files in agent-heavy repos. It sits in a hexagonal driven-adapter role, consumes no upstream skill products by default, and declares supply-chain integrity and hermetic-build practices—useful when you treat agent outputs as build artifacts that must be explainable. Solo builders running multi-step agent pipelines will invoke it when something in the tree does not match expectations and you need a fast forensic pass instead of manual grep archaeology. It is marked internal/background tier in metadata; pair it with trace and broader AgentOps skills for full supply-chain graphs.760installs40Pr ResearchPR Research is an agent skill for solo and indie builders who contribute to third-party repositories and need a repeatable dossier before planning or coding. It walks through a ordered workflow: verify no duplicate work, read contribution guidelines, set up or identify the upstream repo, study templates and conduct rules, and mine merged PRs for style and review habits. Output lands in a dated markdown file under .agents/research plus a result.json artifact, aligned with hexagonal driven-adapter patterns and wiki-knowledge practices. Use it when you are new to a project, evaluating whether to invest in a contribution, or starting a fork-based change that must match upstream norms. Skip it for internal codebases (use a local research skill) or when you already know the project’s contribution playbook cold.745installs41Openai DocsOpenAI Docs is an agent skill that attaches the official OpenAI Developer documentation to your session through the openaiDeveloperDocs MCP server. Solo and indie builders shipping assistants, automations, or SaaS features on OpenAI’s APIs often waste cycles reconciling chat answers with what the platform actually documents. This skill’s interface declares the MCP transport, endpoint, and a default prompt that tells the agent to resolve tasks against primary sources and summarize with citations. It is not a code generator or workflow checklist—it is a live reference layer you invoke whenever model choice, Responses API behavior, tool calling, embeddings, or platform limits matter. Use it during integration spikes in build, and again in ship or operate when verifying breaking changes or error semantics before you cut a release. Pair it with your own implementation skills; it does not replace reading changelogs or security review of what you deploy.738installs42Pr Preppr-prep is an AgentOps agent skill that teaches a repeatable workflow for defending non-obvious PRs with historical evidence. Solo and indie builders often hit inline comments or README warnings that no longer match reality; this skill walks through git log -S searches, targeted git show/stat reviews, and gh pr list to reconstruct who changed what and why subsequent commits may have superseded the warning. The output is a concise timeline and argument reviewers can verify themselves—critical when you are one person wearing author and advocate hats. Use it when a change appears to violate documented “do not” guidance but you believe the codebase evolved, or when you need to show a prior fix was incomplete. It pairs naturally with thorough testing and code review skills but does not replace them; it front-loads credibility before the review thread turns argumentative.737installs43Pr Implementpr-implement is an agentops workflow skill that turns a prior contribution plan into concrete git changes on a fork branch for open-source maintainers. It assumes you already ran research and planning (/pr-research and /plan) and now need a driving adapter that implements the crank while enforcing isolation: unrelated repo churn must not leak into the PR. The embedded feature spec states scenarios for plan-driven implementation, mandatory isolation before and during work, and a focused branch at completion. Solo builders contributing fixes upstream benefit from a procedural guardrail that agents often skip when they batch drive-by refactors. Complexity is advanced because you need fork remotes, branch hygiene, and comfort with agent-executed patches. After implementation, you move to push and open the PR; this skill stops at scoped code on the fork.732installs44Pr ValidatePr-validate is the pre-submission driving adapter in the agentops stack. It runs on a PR branch and systematically checks whether the branch is isolated from unrelated work, aligned with upstream expectations, confined to the intended contribution scope, and clean on quality gates. When changes fall outside the stated scope, the skill reports a scope-containment failure and marks the branch not ready. When a quality gate fails, readiness is blocked the same way. The readme frames the skill as a customer of broader validation services and a producer of machine-readable results for downstream automation. Solo maintainers and indie contributors use it to avoid embarrassing upstream PRs that mix refactors, fail CI, or drift from the tracking branch. It is checker-oriented workflow glue—not a code generator—meant immediately before you click submit on an open-source or inner-source PR.725installs45Security SuiteSecurity Suite is an agent skill for solo builders and small teams who need repeatable, composable security analysis on software they are allowed to assess. Instead of one monolithic scan, it models work as primitives: static collection (metadata, linked libraries, archive signatures), sandboxed dynamic traces, help-surface behavior contracts, baseline drift comparison, and policy enforcement. Outputs align to a security-report.json contract suitable for gating releases or agent council verdicts. The SKILL.md is explicit about authorization—you own the binary or have permission—and favors assurance workflows over extracting third-party proprietary content. It fits Ship when you harden CLIs, agent-packaged binaries, or repo-managed prompt surfaces before customers or automated agents depend on them. Pair it with your existing CI only after you confirm scope matches legal and operational guardrails.718installs46UpdateUpdate is the AgentOps meta skill that keeps your local agent toolchain aligned with the boshu2/agentops repository. When invoked, the agent must run the published install script via curl, wait for completion, verify that every skill copied successfully, and report counts plus any failures with concrete retry steps. It encodes GitOps and continuous-delivery practices for procedural knowledge: skills are infrastructure-as-code artifacts installed to a fixed output contract under the user’s Claude skills directory. Solo builders who adopt the full AgentOps stack use /update after pulling repo changes or when onboarding a new machine, instead of manually copying SKILL.md files. The skill is deliberately narrow—no planning, no app deploy—only synchronized reinstall. If a single skill fails, the workflow tells the user to inspect that agent’s plugin path and restore from the latest repo copy before re-running the installer. Treat it as operational maintenance whenever your agents depend on AgentOps conventions.660installs47Pr RetroPR Retro is an AgentOps skill that turns a finished pull request into a reusable learning document. After a merge, rejection, or round of substantive review comments, the agent discovers the PR via the GitHub CLI, classifies the outcome, extracts reviewer feedback, and identifies what worked versus what did not. The goal is not another status check—it is pattern recognition across your contributions so the next PR is easier to land. Solo and indie builders shipping through GitHub get a consistent ritual that compounds institutional memory inside the repo under `.agents/learnings/` instead of losing insights in closed PR threads. You need git and `gh` installed; the skill expects Read, Write, Bash, Grep, and Glob. Use it periodically to audit your own contribution habits, not only on painful rejections.613installs48Oss Docsoss-docs is an AgentOps documentation skill for solo builders preparing a repository for open source or agent-friendly collaboration. It audits which standard OSS files exist, scaffolds missing ones with project-type-aware content, refreshes stale docs, and validates structure against common best practices. Phase 0 detects language and stack signals from manifest files so generated CONTRIBUTING, CHANGELOG, and AGENTS guidance fits Go, Python, JavaScript, or Rust repos. Use it when you are about to publish, onboard contributors, or want agents to read consistent project rules without hand-writing every boilerplate file.600installs49Pr PlanPR Plan is an AgentOps skill for solo and indie builders who contribute to open source and need more than ad-hoc notes before opening a PR. After you finish pr-research, it walks a structured workflow: discover the research artifact, define contribution scope, pick issues or areas, derive acceptance criteria from research, assess risks, and form an implementation strategy. The output is a versioned markdown plan under `.agents/plans/` with a predictable filename pattern, aligned to a fork intent and optional `result.json` contract. It is deliberately not for internal feature planning (use plan) or drive-by typo fixes. For Prism journey placement it sits in Build / PM as the planning gate between Validate-style discovery on a foreign codebase and Ship-ready review work, with Git & Pull Requests as the primary discipline bucket.599installs