convez.ai
SkillSegurançaAvançado
bm629

Agent Skills — Segurança e Eficiência para Agentes de IA

bm629/agent-skills

Skills multitarefa para agentes: segurança, tokens e autoria com qualidade

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção de skills (competências) especializadas para agentes de código IA (Claude Code, Cursor, GitHub Copilot, Gemini CLI) com foco em segurança, otimização de tokens e autoria de conteúdo estruturado. Inclui sanitização defensiva de conteúdo externo, otimização diagnóstica de uso de tokens, criação autodidática de skills, integração com APIs Atlassian e GitHub, e fluxos de revisão/autoria de documentos técnicos (PRDs, specs, design reviews).

Instalação

$npx convez-ai bm629/agent-skills

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
7
Forks
1
Acompanhando
0
Saúde
57%
Último commit
há 2 semanas
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Proteger agentes contra conteúdo externo malformado ou malicioso (WebFetch/WebSearch)
  • Diagnosticar e reduzir consumo de tokens em múltiplas camadas (prompt, histórico, resultados)
  • Automatizar operações em Jira, Confluence e GitHub via API com autenticação por-chamada
  • Criar e revisar documentos técnicos (PRDs, specs, RFCs) com verificação contra codebase
  • Orquestrar fluxos de autoria estruturada e descoberta de documentação necessária

Veredito

Repositório maduro e bem documentado de skills de produção para agentes. Equilibra defesa (sanitização, design-review adversarial) com otimização (tokens) e integração (Atlassian/GitHub). Exige interpretação técnica profunda das skills individuais, mas oferece padrões comprovados para quem constrói sistemas com agentes IA em escala.

README

A tradução para o português deste README ainda está na fila.

agent-skills

Security, token-efficiency, content-authoring, meta (skill-building), and integration skills for AI coding agents. Works across Claude Code, Cursor, GitHub Copilot, Codex, and Gemini CLI.

Skills in this collection

SkillOne-line purposeCategory
external-content-sanitizerDefensive runtime sanitizer for external untrusted content (WebFetch / WebSearch / cloned repos)security
token-optimizationDiagnostic + tactic catalog for reducing token usage across 5 layers (system prompt, tool defs, history, tool results, output)productivity
content-template-gatewayGate for any agent-authored structured content (file or external destination) — identifies content-type + variant from intent, enforces template use via hard-refusal directive, forges templates when missingcontent authoring
skill-forgeSelf-learning meta-skill: research a knowledge gap → synthesize a portable SKILL.md (create or improve) with fact-check + self-review; broad topics fan out into multiple skillsmeta / authoring
atlassian-rest-opsCall the Atlassian Cloud REST API directly (Confluence v2 + Jira v3) via curl — bundled OpenAPI + $ref-resolver, per-API patterns, ADF/storage rich-text; no SDKintegration
github-cli-opsPerform any github.com operation CLI-first via gh, falling back to gh api (REST) / gh api graphql where no command exists — per-call GH_TOKEN auth (no gh auth switch) from caller-injected credentials, bundled OpenAPI + $ref-resolver for all 1,186 ops, gh secret set for secret encryptionintegration
design-reviewAdversarial pre-approval review of a design doc — spec / plan / RFC / ADR — hunts recurring gap categories (+ a plan lens for plans), verifies claims against the codebase (file:line, no fabrication), returns severities + a ready / has-blockers verdict; review-only (never edits or approves)review
project-document-discoveryDecide which documents a project needs to ship to production (and what it takes to produce each) — turns an idea into a proportional document plan: the set + per-document producer role/tools/skills + an acyclic dependency graph, keyed to project archetype; discovery only (not authoring)planning
authoring-prdAuthor a comprehensive, plannable PRD from a product idea — the method + quality bar (evidenced problem, measurable metrics, defensible MVP boundary, testable acceptance criteria, never fabricates evidence), not the section list; composes with a PRD template tool + deep research; produce-side onlycontent authoring
reviewing-prdJudge a finished PRD against a plannability bar (problem evidenced, metrics measurable, MVP boundary defensible, features plannable, no fabricated evidence) — an acceptance gate; emits VERDICT: approve|revise + actionable findings, no false-revise; single-sources its bar from authoring-prdcontent authoring
authoring-feature-specAuthor a feature spec — elaborate a PRD's named features into implementable, testable detail (trace to PRD, observable behavior, I/O + states, edge cases with handling, Given/When/Then criteria); composes with a feature-spec template tool; assumes the PRD as upstream inputcontent authoring
reviewing-feature-specJudge a finished feature spec against an implementability + testability bar (every feature traced, behavior unambiguous, I/O + states complete, edge cases with response, criteria independently testable) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-feature-speccontent authoring
authoring-user-flowsAuthor a user-flows document — the navigation graph of the paths a user takes to each goal (entry points, branches, error/recovery paths, screens traversed); derives flows from the PRD's goals/personas, no dead ends, each flow as a synced Mermaid diagram + numbered narrative; composes with a user-flows template toolcontent authoring
reviewing-user-flowsJudge a finished user-flows doc against a completeness + walkability bar (every goal mapped, every flow with entry/exit, every branch resolved, no dead ends, both notations in sync, screens enumerable) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-user-flowscontent authoring
authoring-wireframesAuthor a wireframes document — the structural lo-fi design of each screen (layout regions, hierarchy, components, affordances, empty/loading/populated/error states) as a textual layout description + ASCII sketch + annotations; one wireframe per flow-named screen; composes with a wireframes template toolcontent authoring
reviewing-wireframesJudge a finished wireframes doc (textual markdown, not Figma) against a buildability + coverage bar (every flow-named screen + all four states, unambiguous layout, components design-system-consistent, affordances + a11y) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-wireframescontent authoring
authoring-design-systemAuthor a design-system document — principles, tokens (color/type/spacing/elevation/motion), a component catalog (anatomy/states/variants/usage/a11y), patterns, accessibility, voice; semantic-token tiering + an archetype-sized catalog covering the screens' real components; textual artifact; composes with a design-system template toolcontent authoring
reviewing-design-systemJudge a finished design-system doc against a usability + consistency + accessibility bar (tokens referenced by intent, components fully specced, catalog covers the surface area + standard set, numeric WCAG) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-design-systemcontent authoring
authoring-technical-designAuthor a technical design doc (TDD) for one feature/component — the method + implementability bar (trace every decision to a requirement, one real alternative with a decision criterion, reference the architecture/api-spec/data-model rather than duplicate, failure modes + testing + rollout); composes with a technical-design template tool; assumes the PRD + feature-spec as upstream inputcontent authoring
authoring-architecture-docAuthor a whole-system architecture doc — the method + usability bar (boundary first, one responsibility per component, justify each tech choice, a realization per NFR target) recording each key decision as a standalone, linked ADR file (the doc carries only a decisions index); composes with an architecture-doc template tool + an ADR template tool; assumes the PRD + product direction as inputcontent authoring
authoring-api-specAuthor an API specification (the engineering wire contract) — the method + no-ambiguity bar (render in the project's style — OpenAPI/SDL/proto — type every field, enumerate the error cases not just the happy path, reference the data-model rather than redefine it); composes with an api-spec template tool; assumes the feature-spec as upstream inputcontent authoring
authoring-data-modelAuthor a data model doc (the persistence/domain model) — the method + integrity/queryability bar (derive entities from the feature-spec + access patterns, detect the paradigm — relational or document/NoSQL — make integrity rules explicit, justify each index by an access pattern); composes with a data-model template tool; assumes the feature-spec as upstream inputcontent authoring
authoring-user-guideAuthor an end-user guide — the consumer-facing help a (non-technical) user reads: the method + usability/accuracy bar (full Diataxis, one how-to per handed-in goal, modes kept distinct, end-user feature/config reference — not the API, steps accurate to the product); composes with a user-guide template tool; assumes the feature-spec + user-flows + wireframes as upstream inputcontent authoring
authoring-developer-guideAuthor developer-tool documentation — the SDK/library/CLI/API-platform adoption + integration narrative: the method + adoptability/accuracy bar (goals-not-endpoints, fast first success, concepts before reference, code-centric recipes, runnable accurate code, links — not copies — the api-reference); composes with a developer-guide template tool; assumes the feature-spec + api-reference + PRD as upstream inputcontent authoring
authoring-api-referenceAuthor a published, consumer-facing API reference — the method + usability/contract-consistency bar (derive every endpoint/field/error from the api-spec — no drift, onboarding-first getting-started + auth, a worked example per operation, prose-first yet generation-adaptive); composes with an api-reference template tool; assumes the api-spec as upstream inputcontent authoring
reviewing-user-guideJudge a finished end-user guide against a usability + accuracy bar (one how-to per handed-in goal, Diataxis modes correctly typed, feature/config reference complete — not the API, steps accurate, troubleshooting covers error states) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-user-guidecontent authoring
reviewing-developer-guideJudge a finished developer guide against an adoptability + accuracy bar (verifiable first success, concepts before recipes, runnable code accurate to the tool, links — not duplicates — the api-reference) with named upstream-accuracy + api-reference-linking checks — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-developer-guidecontent authoring
reviewing-api-referenceJudge a finished published API reference against a usability + contract-consistency bar (every api-spec operation documented with a worked example, every endpoint/shape/error traces to the contract — no drift, getting-started + auth, samples) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-api-referencecontent authoring
authoring-release-runbookAuthor a release/deployment runbook — the method + executability/safety bar (idempotent copy-paste-safe steps each with an expected result, deploy derived from the architecture-doc + technical-design and verification from the test-plan, blue-green default overridable per project, a documented revert for every forward change, no secret inlined); composes with a release-runbook template tool; assumes the architecture-doc + technical-design + test-plan as upstream inputcontent authoring
authoring-test-planAuthor a test plan / QA verification plan — the method + coverage/testability bar (every case traced to a feature-spec behavior or api-spec operation/error, a risk-weighted catalog not the input-permutation cross-product, testable entry/exit criteria, non-functional levels from the NFRs); composes with a test-plan template tool; assumes the feature-spec + api-spec + PRD as upstream inputcontent authoring
reviewing-release-runbookJudge a finished release runbook against an executability + safety bar (every step verified, a complete + safe rollback with a revert for every forward change — load-bearing, concrete escalation/monitoring, no secret inlined, commands accurate to the upstreams) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-release-runbookcontent authoring
reviewing-test-planJudge a finished test plan against a coverage + testability bar (every upstream behavior has a traceable case, a risk-weighted catalog — a coverage gap or a combinatorial blow-up is a finding, testable entry/exit, environments specified) — an acceptance gate; emits VERDICT: approve|revise + findings; pairs with authoring-test-plancontent authoring
reviewing-document-setJudge a finished SET of documents as one corpus for cross-document coherence (consistency incl. one name per entity, traceability from the root, contradictions, dependency integrity, no divergent duplication, ready-to-plan) — the corpus-level analog of a design review, run after each document's own gate; emits one VERDICT: approve|revise + per-document-attributed findings, no false-revisecontent authoring
pydantic-v2Write correct, current Pydantic v2 — BaseModel + Field constraints, @field_validator/@model_validator, model_dump*, ConfigDict, pydantic-settings, TypeAdapter, discriminated unions — and modernize v1-era idioms (class Config, .dict(), @validator); standalone-Pydantic, defers framework wiring to fastapiengineering
rest-api-designDesign a REST/HTTP API surface and its contract — resources/URLs, methods + status codes, one error model (RFC 9457 problem+json), success/pagination envelope, versioning/auth/rate-limit, rendered as an OpenAPI 3.1 contract; the design discipline above the framework, defers handler code to fastapi/pydantic-v2engineering
python-monorepo-architectureArchitect a multi-package Python uv-workspace monorepo (shared lib + app/CLI members) — the cross-package layer: when to split, the workspace wiring ([tool.uv.workspace] / [tool.uv.sources] {workspace=true}), the acyclic depend-inward dependency direction (apps→core, never app↔app), the import-isolation discipline uv can't enforce (+ optional import-linter), member-boundary public API, and safe extraction; owns the workspace wiring, composes with uv + python-project-structureengineering
openapi-ts-clientGenerate a typed TypeScript client from an OpenAPI 3.1 contract (e.g. a FastAPI /openapi.json) with @hey-api/openapi-ts — typed models, a typed SDK, TanStack Query hooks, and Zod schemas, regenerated from the spec not hand-written; covers the config, the fetch/axios/next clients, the tanstack-query + zod plugins, the regen + CI-drift workflow, and the FastAPI operationId fix; defers TanStack Query usage to tanstack-queryengineering
biomeLint + format a JS/TS project with Biome v2 — one fast Rust tool (the JS analog of ruff): the biome.json config (formatter, linter rule groups + domains, assist/import-organize, VCS, overrides, monorepo extends), the CLI (biome check --write, biome ci), ESLint/Prettier migration, the v1→v2 deltas (--apply → --write), and authoring custom rules as GritQL plugins; defers pipeline task-wiring to turborepoengineering
typescript-typecheckRun TypeScript type-checking as a standalone gate — tsc --noEmit separate from the bundler (no transpiler type-checks: Vite/esbuild/SWC strip types), a genuinely strict tsconfig (beyond strict: true), the Vite split-config, composite project references for a monorepo, the CI gate, and the tsgo/TS-7.0 status; the TS analog of a ty gate, defers the build to vite + pipeline to turborepoengineering
polyglot-git-hooksSet up Git hooks for a polyglot/monorepo with Lefthook — one lefthook.yml running format/lint on staged files at pre-commit and type-check/test at pre-push across mixed-language subtrees (TS + Python) in parallel: install + fresh-clone activation, the schema (glob/root/{staged_files}/stage_fixed/parallel), a genuinely polyglot (biome + ruff) example, hooks-vs-CI, the --no-verify bypass; defers tool flags to biome/ruff/ty/typescript-typecheckengineering
tsdocWrite TSDoc doc-comments on a TypeScript public surface (@microsoft/tsdoc) — what to document (exported functions/types/components/hooks) vs skip (private/generated/trivial/type-restating), the block/inline/modifier tag taxonomy, summary-then-@remarks, and the cardinal rule (no {type} in comments — TS has them); enforcement convention-only by default (eslint-plugin-tsdoc optional); the TS analog of a docstring disciplineengineering
react-component-testingThe RTL + MSW + vitest-axe component-test layer for a Vite + React + TS SPA under Vitest (jsdom) — render a real tree, drive it like a user (user-event), mock the network boundary with MSW (not the module, so a generated @hey-api/openapi-ts client + serialization run and contract drift surfaces), and assert runtime a11y (vitest-axe toHaveNoViolations); the middle of the test pyramid, defers the runner to vitest, the router harness to tanstack-router, e2e to playwright-best-practicesengineering
tanstack-routerSet up + use TanStack Router (@tanstack/react-router) in a Vite + React + TS SPA — the type-safe route tree (createRouter + RouterProvider + the Register merge), the tanstackRouter Vite plugin, file-based (primary) + code-based routing, validated search params, loaders + the TanStack Query handshake, code-splitting, preloading, auth routes, route masking, and a memory-history test harness; defers query mechanics to tanstack-query, fences out TanStack Start (SSR)engineering
sqlalchemyBuild a portable SQLAlchemy 2.x relational data layer that runs unchanged on SQLite + PostgreSQL + MySQL — the typed ORM (DeclarativeBase / Mapped[...] / mapped_column), one-engine-per-process + short-lived sessions, a sync/async driver matrix, and the cross-dialect gotcha set (row locking / JSON / upsert / identity / isolation that silently differs per engine); ORM-first, sync-first; defers migrations to alembic, the lease loop to sql-job-queueengineering
alembicRun Alembic migrations on a SQLAlchemy 2.x layer across SQLite + PostgreSQL + MySQL from one history — wire env.py/alembic.ini to Base.metadata (URL from env), the revision → autogenerate → review → upgrade/downgrade workflow + merge, the autogenerate-drafts-you-review discipline, the SQLite batch (move-and-copy) gotcha, and the create_all()-vs-Alembic + baseline-stamp decision; sync-first; defers model authoring to sqlalchemyengineering
sql-job-queueBuild a DB-backed ready-set job scheduler on SQLAlchemy 2.x — a single-box embeddable tick loop where the DB is the sole durable substrate and readiness is dependency-driven: the generic jobs/job_deps model, the ready-set query, the three per-dialect lease branches (FOR UPDATE SKIP LOCKED on PG/MySQL 8 vs BEGIN IMMEDIATE on SQLite), crash-resume + hung-worker timeout, weighted fair-share, the tick loop, at-least-once idempotency; sync-first; composes sqlalchemy's locking primitiveengineering

Quick install (Claude Code)

npx skills add bm629/agent-skills@external-content-sanitizer
npx skills add bm629/agent-skills@token-optimization
npx skills add bm629/agent-skills@content-template-gateway
npx skills add bm629/agent-skills@skill-forge
npx skills add bm629/agent-skills@atlassian-rest-ops
npx skills add bm629/agent-skills@github-cli-ops
npx skills add bm629/agent-skills@design-review
npx skills add bm629/agent-skills@project-document-discovery
npx skills add bm629/agent-skills@authoring-prd
npx skills add bm629/agent-skills@reviewing-prd
npx skills add bm629/agent-skills@authoring-feature-spec
npx skills add bm629/agent-skills@reviewing-feature-spec
npx skills add bm629/agent-skills@authoring-user-flows
npx skills add bm629/agent-skills@reviewing-user-flows
npx skills add bm629/agent-skills@authoring-wireframes
npx skills add bm629/agent-skills@reviewing-wireframes
npx skills add bm629/agent-skills@authoring-design-system
npx skills add bm629/agent-skills@reviewing-design-system
npx skills add bm629/agent-skills@authoring-technical-design
npx skills add bm629/agent-skills@authoring-architecture-doc
npx skills add bm629/agent-skills@authoring-api-spec
npx skills add bm629/agent-skills@authoring-data-model
npx skills add bm629/agent-skills@authoring-user-guide
npx skills add bm629/agent-skills@authoring-developer-guide
npx skills add bm629/agent-skills@authoring-api-reference
npx skills add bm629/agent-skills@reviewing-user-guide
npx skills add bm629/agent-skills@reviewing-developer-guide
npx skills add bm629/agent-skills@reviewing-api-reference
npx skills add bm629/agent-skills@authoring-release-runbook
npx skills add bm629/agent-skills@authoring-test-plan
npx skills add bm629/agent-skills@reviewing-release-runbook
npx skills add bm629/agent-skills@reviewing-test-plan
npx skills add bm629/agent-skills@reviewing-document-set
npx skills add bm629/agent-skills@pydantic-v2
npx skills add bm629/agent-skills@rest-api-design
npx skills add bm629/agent-skills@python-monorepo-architecture
npx skills add bm629/agent-skills@openapi-ts-client
npx skills add bm629/agent-skills@biome
npx skills add bm629/agent-skills@typescript-typecheck
npx skills add bm629/agent-skills@polyglot-git-hooks
npx skills add bm629/agent-skills@tsdoc
npx skills add bm629/agent-skills@sqlalchemy
npx skills add bm629/agent-skills@alembic
npx skills add bm629/agent-skills@sql-job-queue

For Cursor, GitHub Copilot, Codex, or Gemini CLI — see the installation guide.

Documentation

DocCovers
docs/installation.mdPer-agent install instructions for all 4 target agents + Gemini bonus; troubleshooting
docs/skills/external-content-sanitizer.mdDeep dive: when to invoke, args, workflow, output format, safety invariants
docs/skills/token-optimization.mdDeep dive: 5-layer model, measure-first workflow, per-layer tactics
docs/skills/content-template-gateway.mdDeep dive: 5-phase workflow (identify / check / enforce / forge / advise), 3 invocation modes, ASCII directive format, destination-agnostic framing
docs/skills/skill-forge.mdDeep dive: 8-step workflow (triage / find-research-verify / synthesize / write+self-review), synthesize-only + forge-mark + capability-based deps, multi-skill fan-out
docs/skills/atlassian-rest-ops.mdDeep dive: find→resolve→curl workflow, per-API patterns (base URL, pagination, errors), ADF vs storage rich-text, caller-injected credential contract, bundled OpenAPI + resolver
docs/skills/github-cli-ops.mdDeep dive: CLI-first + gh api fallback workflow, per-call GH_TOKEN auth (no gh auth switch) from caller-injected credentials, the common gh-api-only areas (~1/3 of the surface), bundled OpenAPI + resolver, gh secret set encryption
docs/skills/design-review.mdDeep dive: the 8-step review workflow, the 9-category gap rubric + conditional plan lens, verify-against-code (file:line, no fabrication, greenfield N/A, bounded), findings + verdict format, review-only guarantees
docs/skills/project-document-discovery.mdDeep dive: the 6-step selection discipline, the seven lifecycle bands + four domain overlays + per-archetype proportionality, the producer-role + OSS-tooling map, the dependency DAG, discovery-only guarantees
docs/skills/authoring-prd.mdDeep dive: the 5-step workflow (structure-from-template / discover gaps / research / per-section method / self-check), the 8-condition plannability bar, compose-not-restate + never-fabricate guarantees
docs/skills/reviewing-prd.mdDeep dive: the 8-condition plannability bar, the VERDICT: approve|revise + actionable-findings contract, no-false-revise discipline, single-sourced-from-authoring-prd
docs/skills/authoring-feature-spec.mdDeep dive: the per-feature method (PRD-trace / observable behavior / I/O+states / edge-cases-with-handling / Given-When-Then criteria), compose-with-template + PRD-is-upstream guarantees
docs/skills/reviewing-feature-spec.mdDeep dive: the implementability+testability bar, the VERDICT: approve|revise contract, no-false-revise, single-sourced-with-authoring-feature-spec
docs/skills/authoring-user-flows.mdDeep dive: the flow-derivation method (goals/personas → flows, no-dead-ends edge sweep, synced Mermaid + numbered narrative), compose-with-template + PRD-is-upstream guarantees
docs/skills/reviewing-user-flows.mdDeep dive: the completeness + walkability bar, the VERDICT: approve|revise contract, no-false-revise, single-sourced-with-authoring-user-flows
docs/skills/authoring-wireframes.mdDeep dive: the screen-derivation method (one wireframe per flow-named screen, per-screen states, design-system reference), textual layout-desc + ASCII + annotations, structural-lo-fi guarantees
docs/skills/reviewing-wireframes.mdDeep dive: the buildability + coverage bar, judges textual markdown not Figma, the VERDICT: approve|revise contract, single-sourced-with-authoring-wireframes
docs/skills/authoring-design-system.mdDeep dive: the token/component method (semantic-token tiering, surface-area floor + standard set, per-component a11y), textual artifact, precedes-wireframes + compose-with-template guarantees
docs/skills/reviewing-design-system.mdDeep dive: the usability + consistency + accessibility bar, the VERDICT: approve|revise contract, no-false-revise of a proportional system, single-sourced-with-authoring-design-system
docs/skills/authoring-technical-design.mdDeep dive: the design method (structure-from-template / requirement-trace / per-section method / implementability self-check), reference-not-duplicate + feature-altitude + one-real-alternative guarantees
docs/skills/authoring-architecture-doc.mdDeep dive: the architecture method (boundary-first / responsibility-per-component / realization-per-NFR), the standalone-linked-ADR decision mechanism, sized-to-archetype + compose-with-two-templates guarantees
docs/skills/authoring-api-spec.mdDeep dive: the contract method (style-first / type-both-sides / enumerate-error-cases / examples-match-schemas), style-agnostic rigor + reference-the-data-model + contract-not-reference guarantees
docs/skills/authoring-data-model.mdDeep dive: the modeling method (paradigm detection / access-patterns-first / cardinality + referential rule / justified indexes / stated tradeoffs), paradigm-aware + one-directional-vs-api-spec guarantees
docs/skills/authoring-user-guide.mdDeep dive: the end-user-docs method (full Diataxis, one-how-to-per-handed-in-goal, modes-kept-distinct, end-user-not-API reference, error-sourced troubleshooting), compose-with-template + single-sourced-with-reviewing-user-guide guarantees
docs/skills/authoring-developer-guide.mdDeep dive: the developer-experience method (goals-not-endpoints / fast first success / concepts-before-reference / code-centric recipes / links-not-copies-the-api-reference), accurate-runnable-code + single-sourced-with-reviewing-developer-guide guarantees
docs/skills/authoring-api-reference.mdDeep dive: the consumer-reference method (derive-every-endpoint-from-the-api-spec / onboarding-first / worked-example-per-operation / prose-first-yet-generation-adaptive), no-drift + single-sourced-with-reviewing-api-reference guarantees
docs/skills/reviewing-user-guide.mdDeep dive: the usability + accuracy bar (per-handed-in-goal how-to coverage, Diataxis typing, complete end-user reference, accurate steps, error-state troubleshooting), VERDICT: approve|revise contract, no-false-revise, single-sourced-with-authoring-user-guide
docs/skills/reviewing-developer-guide.mdDeep dive: the adoptability + accuracy bar with named upstream-accuracy + api-reference-linking checks (verifiable first success, concepts-before-recipes, runnable accurate code, link-not-duplicate), VERDICT: approve|revise contract, single-sourced-with-authoring-developer-guide
docs/skills/reviewing-api-reference.mdDeep dive: the usability + contract-consistency bar (every operation documented, every endpoint/shape/error traces to the handed-in api-spec — the load-bearing no-drift check), VERDICT: approve|revise contract, single-sourced-with-authoring-api-reference
docs/skills/authoring-release-runbook.mdDeep dive: the operational method (SRE-grounded, deploy-from-architecture+technical-design, verify-from-test-plan, idempotent copy-paste-safe steps, blue-green-default-overridable, revert-per-forward-change, secrets-by-reference), compose-with-template + single-sourced-with-reviewing-release-runbook guarantees
docs/skills/authoring-test-plan.mdDeep dive: the test-strategy method (case-per-behavior/operation/error, choose-the-levels, risk-weighted-not-cross-product catalog, testable entry/exit, NFR-sourced non-functional levels), specs-cases-not-scripts + single-sourced-with-reviewing-test-plan guarantees
docs/skills/reviewing-release-runbook.mdDeep dive: the executability + safety bar (per-step verification, complete+safe rollback with a revert per forward change — load-bearing, concrete escalation/monitoring, no-inlined-secret, upstream-accurate commands), VERDICT: approve|revise contract, single-sourced-with-authoring-release-runbook
docs/skills/reviewing-test-plan.mdDeep dive: the coverage + testability bar (traceable-case-per-behavior, risk-weighted catalog — coverage-gap and combinatorial-blow-up both findings, testable entry/exit, environments specified), VERDICT: approve|revise contract, single-sourced-with-authoring-test-plan
docs/skills/pydantic-v2.mdDeep dive: the 8-step current-v2 workflow (define / constrain / validate / serialize / configure / settings / structure / errors), the hard v2-only rules, the v1→v2 modernization scope, and the fastapi boundary
docs/skills/rest-api-design.mdDeep dive: the 7-step design workflow (resources / methods / status codes / RFC 9457 error model / pagination envelope / versioning-auth-rate-limit / OpenAPI 3.1 contract), the hard rules, and the fastapi/pydantic-v2 handoff
docs/skills/python-monorepo-architecture.mdDeep dive: the 7-step cross-package workflow (split? / workspace wiring / depend-inward direction / import-isolation enforcement / boundary API / tests / safe extraction), the hard rules, and the uv + python-project-structure composition
docs/skills/openapi-ts-client.mdDeep dive: the 6-step workflow (install / configure / generate / consume SDK / hooks + Zod / FastAPI + regen), the hard rules, the fetch/axios/next clients + v0.73.0 bundling, and the tanstack-query hand-off
docs/skills/biome.mdDeep dive: the 6-step workflow (install+init / configure / run / CI gate / migrate / GritQL plugin), the hard rules, the v1→v2 deltas, and the turborepo hand-off
docs/skills/typescript-typecheck.mdDeep dive: the 5-step workflow (why-separate / strict tsconfig / Vite split-config / project references / CI gate), the hard rules, the bundler-doesn't-typecheck rationale, the tsgo status, and the vite/turborepo hand-offs
docs/skills/polyglot-git-hooks.mdDeep dive: the 6-step workflow (pick / install+activate / schema / polyglot example / hooks-vs-CI / --no-verify), the hard rules, the genuinely-polyglot (biome + ruff) example, and the tool-skill hand-offs
docs/skills/tsdoc.mdDeep dive: the 5-step workflow (decide / summary+@remarks / intent-not-type / right tag / enforcement), the hard rules, the TSDoc-vs-JSDoc rule, and the convention-only-vs-eslint-plugin-tsdoc choice
docs/skills/react-component-testing.mdDeep dive: the 7-step workflow (network-boundary principle / jsdom env / accessible queries / await user-event / async / providers / a11y), the hard rules, the MSW-vs-vi.mock + happy-dom caveats, and the vitest/tanstack-router/biome/playwright-best-practices hand-offs
docs/skills/tanstack-router.mdDeep dive: the 7-step workflow (plugin / type-safe setup / root route / worked route / navigation / loader↔query seam / test harness), the hard rules, the file-based-primary + code-based coverage, and the tanstack-query/vite + TanStack-Start/React-Router boundaries
docs/skills/sqlalchemy.mdDeep dive: the 7-step workflow (URL / engine / models / bootstrap+session / sync-async driver matrix / async aside / cross-dialect gotchas), the hard rules, the load-bearing gotcha set (row locking / JSON / upsert / identity / isolation), and the alembic/sql-job-queue boundaries
docs/skills/alembic.mdDeep dive: the 9-step workflow (init / URL-from-env / target_metadata / online runner / author / apply / batch / branching / async), the hard rules, the autogenerate-drafts-you-review + SQLite batch move-and-copy gotchas, and the create_all()-vs-Alembic + baseline-stamp decision
docs/skills/sql-job-queue.mdDeep dive: the 9-step workflow (confirm-shape / data model / ready-set query / atomic lease / crash-resume / fair-share / tick loop / wake / idempotency), the hard rules, the three per-dialect lease branches (PG / MySQL 8 / SQLite), and the broker/APScheduler/Airflow non-fits
docs/architecture.mdRepo layout, metadata files, why the SKILL.md frontmatter has per-agent extensions: blocks
docs/compatibility.mdAgent compatibility matrix; v1 status vs v2 plugin-packaging roadmap
docs/contributing.mdHow to file issues, propose new skills, modify existing ones

Why these skills, why together?

Each fills a genuinely empty niche in the public skill ecosystem (verified against skills.sh as of 2026-05-24):

  • external-content-sanitizer is the only defensive operational guardrail for incoming untrusted content. Other skills in this space are either offensive attack playbooks (red team), audit tools (scan your own skills for vulnerabilities), or doc-style guidelines.
  • token-optimization is the only strategic methodology spanning all five token-budget layers. Other skills tackle a single layer (caching, context management, or output sizing) in isolation.
  • content-template-gateway is the only template-enforcement gateway that catches every content-authoring attempt (user or agent) — file-bound or external-bound (GitHub PR / issue, Jira ticket, commit message, Slack post, Confluence page, etc.) — and either returns an existing template with a hard-refusal directive or forges a new one. Other template skills are passive — they wait to be invoked explicitly, and they only know about files.
  • skill-forge turns a knowledge gap into a portable skill — research → fact-check → synthesize (or improve) a SKILL.md, with a multi-cycle self-review. It's the meta-skill that can build the others, and the skills it produces are self-contained + portable.
  • atlassian-rest-ops gives full-coverage Confluence Cloud v2 + Jira Cloud v3 access by calling the REST API directly (curl + a bundled OpenAPI spec + a $ref-resolver) — no SDK, no pip, with the per-API and ADF/storage rich-text gotchas handled.
  • github-cli-ops gives full-coverage github.com access CLI-first (the gh CLI), with gh api + a bundled OpenAPI $ref-resolver for the ~1/3 of the REST surface that has no first-class command (teams, checks, packages, code-scanning, dependabot, git-data, reactions, apps, …). Per-call GH_TOKEN auth means no global gh auth switch; gh secret set handles client-side secret encryption. It's the GitHub sibling of atlassian-rest-ops under the per-provider service-skill pattern.
  • design-review is the only design-document reviewer that runs before code exists and verifies its findings against the actual codebase (file:line, never fabricated). Code-review skills target diffs; this targets the spec/plan/RFC/ADR, hunting recurring gap categories (bootstrap & ownership, naming honesty, scale, hidden assumptions, consistency-with-shipped-code, idempotency/failure, security, necessity, completeness) — plus, when the doc is a plan, a plan lens (task granularity, dependency-DAG, coverage-vs-spec, exit-criteria testability) — and returning a ready / has-blockers verdict. Review-only — it recommends; the human approves, the author fixes.
  • project-document-discovery answers a question no other skill in the set does: which documents does this project need to ship to production, and what does it take to produce each? It turns an idea into a proportional document plan — sized to the project archetype (a thin CLI tool gets a handful; a UI product many), each document tagged with its producer role, OSS-first tooling, and an acyclic dependency order — guarding against the heavy-fixed-taxonomy anti-pattern. Discovery only: it picks the set; authoring each document is a separate concern (it composes with content-template-gateway).

Hand-authored or forge-built; see each skill's deep-dive doc for details.

Status

v2.24.0 — restructures the two provider ops skills (atlassian-rest-ops, github-cli-ops) to consume caller-injected credentials instead of self-resolving from a .service-accounts.yaml record: Step 1 + the reference docs now receive base_url/email/host + the acting capability from the caller and resolve the token by an ordered load rule (the project .env value if that file exists and defines the var, else the environment variable of that name — no scope-walk, no --account), with a clearly-optional "Standalone usage" appendix for the by-hand record+.env bridge. The scripts/*.sh and their fixed env-var interface are unchanged.

v2.23.0 — adds three engineering skills, the SQL/scheduler skill set for agent-flow's DB-backed scheduler (the global ready-set scheduler that replaces per-project state behind a State seam): sqlalchemy — build a portable SQLAlchemy 2.x relational data layer that runs unchanged on SQLite + PostgreSQL + MySQL (the typed ORM-first DeclarativeBase / Mapped[...] / mapped_column, one-engine-per-process + short-lived sessions, sync-first with an async aside + a per-dialect driver matrix, and the load-bearing cross-dialect gotcha set — row locking, JSON vs PG JSONB, upsert ON CONFLICT vs ON DUPLICATE KEY UPDATE, autoincrement/identity, isolation — that silently differs per engine); alembic — run Alembic migrations on that layer across all three dialects from one history (wire env.py/alembic.ini to Base.metadata with the URL from the environment, the revision → autogenerate → review → upgrade/downgrade workflow + merge, the autogenerate-drafts-you-review discipline against its data-losing blind spots, the SQLite batch move-and-copy gotcha — SQLite can't ALTER most schema so the same batch_alter_table code recreates on SQLite and emits plain ALTER on PG/MySQL — and the create_all()-vs-Alembic decision + the baseline-stamp adoption path); and sql-job-queue — build a DB-backed ready-set scheduler on SQLAlchemy 2.x (a single-box embeddable tick loop where the DB is the sole durable substrate and readiness is dependency-driven: the generic jobs/job_deps model, the ready-set query, the three per-dialect lease branches — FOR UPDATE SKIP LOCKED on PostgreSQL + MySQL 8 vs BEGIN IMMEDIATE on SQLite — crash-resume via heartbeat + lease-expiry reclaim + a hung-worker timeout, weighted fair-share over group_key, the scan→rank→lease→dispatch→persist→reclaim tick loop, and the at-least-once idempotency contract with its atomic-finalize guard; it composes sqlalchemy's with_for_update(skip_locked=...) locking primitive rather than re-teaching it). All three are sync-first and multi-dialect; alembic and sql-job-queue build on sqlalchemy's data layer. Forged via the skill-build playbook (spec → design-review → plan → design-review → forge → fresh-review). Additive — existing skills unchanged.

v2.22.0 — adds two engineering skills, the Phase-0 prerequisites for the agent-flow dashboard (slice-3) frontend build: react-component-testing — the RTL + MSW + vitest-axe component-test layer for a Vite + React + TS SPA under Vitest/jsdom (the network-boundary principle — mock with MSW so a generated @hey-api/openapi-ts client + serialization run and contract drift surfaces, never module-mock; the jsdom env explicitly not happy-dom which breaks axe; accessible queries; always-await user-event v14; the MSW setupServer lifecycle; a per-test TanStack Query client; runtime a11y via toHaveNoViolations; jsdom-primary with a Vitest-browser-mode reference); and tanstack-router — set up + use TanStack Router in a Vite + React + TS SPA (the type-safe route tree with the Register merge, the tanstackRouter Vite plugin, file-based-primary + code-based routing, validated search params, route loaders + the TanStack Query ensureQueryData↔useSuspenseQuery handshake framed through routing, code-splitting, preloading, auth routes, route masking, and a memory-history test harness consumed by react-component-testing; defers query mechanics to tanstack-query, fences out TanStack Start). Both forged via the skill-build playbook (spec → design-review → plan → design-review → forge → fresh-review) and main-thread doc-grounded-verified against the live official docs (which confirmed the happy-dom/axe caveat + vitest-axe API, and the tanstackRouter plugin export + Zod-v3/v4 adapter split). Additive — existing skills unchanged.

v2.21.0 — adds three engineering skills completing the agent-flow dashboard (slice-3) TypeScript toolchain, each the parity analog of a Python tool: typescript-typecheck — TypeScript type-checking as a standalone gate (tsc --noEmit separate from the bundler since no transpiler type-checks, a genuinely strict tsconfig beyond strict: true, the Vite split-config, composite project references, the CI gate, the tsgo/TS-7.0 status), the analog of a ty gate; polyglot-git-hooks — Git hooks for a polyglot/monorepo with Lefthook (one lefthook.yml, staged-file scoping, a genuinely polyglot pre-commit running biome + ruff, pre-push tsc/ty/tests, hooks-vs-CI, the --no-verify bypass); and tsdoc — TSDoc doc-comments on a TypeScript public surface (the block/inline/modifier tag taxonomy, the what-to-document discipline, the cardinal no-{type} rule, convention-only enforcement with eslint-plugin-tsdoc as an optional pointer), the analog of a Google-style docstring standard. All three forged via the skill-build playbook (spec → design-review → plan → design-review → forge → fresh-review → dry-run verify) and additionally main-thread doc-grounded-verified against the live official docs (which caught and fixed a Lefthook jobs:-versioning inaccuracy). Additive — existing skills unchanged.

v2.20.0 — adds two engineering skills for the agent-flow dashboard (slice-3) frontend work: openapi-ts-client — generate a typed TypeScript client from an OpenAPI 3.1 contract (e.g. a FastAPI /openapi.json) with @hey-api/openapi-ts: typed models, a typed SDK, TanStack Query hooks, and Zod schemas, regenerated from the spec rather than hand-written (covers the openapi-ts.config.ts config, the fetch/axios/next clients + the v0.73.0 client bundling, the regenerate + CI-drift workflow, and the FastAPI operationId fix; defers TanStack Query usage to tanstack-query); and biome — lint + format a JS/TS project with Biome v2, the JS analog of ruff (the biome.json config, the CLI incl. the read-only biome ci gate, ESLint/Prettier migration, the v1→v2 deltas, and authoring custom rules as GritQL plugins; defers pipeline task-wiring to turborepo). Both forged via the skill-build playbook (spec → design-review → plan → design-review → forge → fresh-review → dry-run verify) and dry-run verified. Additive — existing skills unchanged.

v2.19.0 — adds python-monorepo-architecture (engineering), the cross-package layer for a multi-package Python uv-workspace monorepo: when to split a codebase into a shared library plus app/CLI members (and when not — conflicting deps / divergent requires-python aren't one workspace), the workspace wiring it owns ([tool.uv.workspace] + [tool.uv.sources] {workspace=true}, single lockfile, --package), the acyclic depend-inward dependency direction (apps→core, never app↔app, the lib depends on no app), the import-isolation discipline uv can't enforce (boundary by convention + review, with import-linter as optional CI enforcement), the member-boundary public API, cross-member test layout, and safety-net-first extraction. Owns the uv-workspace wiring the uv skill lacks and composes with uv (basics) + python-project-structure (intra-package). Dry-run verified. Additive — existing skills unchanged.

v2.18.0 — adds the first two engineering skills (a new category alongside security, productivity, content-authoring, meta, and integration), forged for the agent-flow API-building work: pydantic-v2 — write correct, current Pydantic v2 (the post-v1 API — ConfigDict, model_dump*, model_validate*, @field_validator/@model_validator, pydantic-settings, TypeAdapter, discriminated unions — plus modernizing v1-era idioms like class Config, .dict(), @validator; standalone-Pydantic, defers framework wiring to the FastAPI layer) and rest-api-design — the design discipline above any web framework: resource/URL modeling, method + status-code choice, one error model (RFC 9457 problem+json by default), a success/pagination envelope, a versioning/auth/rate-limit stance, all rendered as an OpenAPI 3.1 contract (it produces the decisions and the contract, not the handler code). Both are dry-run verified and reference each other and the framework layer rather than duplicating it. Additive — existing skills unchanged.

v2.16.0 — adds reviewing-document-set, a standalone corpus-level reviewer (the analog of design-review across a whole document set). It judges a finished set of project documents for cross-document coherence on six dimensions — consistency incl. one name per entity, completeness & traceability anchored on the upstream-most document, contradictions, dependency integrity, no divergent duplication, and ready-to-plan — and emits a single VERDICT: approve|revise with each finding prefixed by the affected document id(s) so a caller can act per document. Grounded in IEEE 830, requirements traceability, single-source-of-truth, and Definition-of-Ready practice; dry-run verified (catches seeded cross-document defects, approves a coherent corpus). Additive — existing skills unchanged.

v2.15.0 — completes the Delivery cluster (the fifth and final cluster) of the agent-flow document-skill library (twenty-ninth–thirty-second skills), and with it the entire library: the two go-to-production document pairs. authoring-release-runbook + reviewing-release-runbook (the broad operational go-live runbook — prerequisites/sign-offs, pre-deploy checks, idempotent copy-paste-safe deploy steps each with an expected result, post-deploy verification reusing the test-plan exit criteria, a complete + safe rollback with a documented revert for every forward change, escalation/monitoring; the deploy strategy defaults to blue-green and is overridable per project; secrets referenced by their store, never inlined) and authoring-test-plan + reviewing-test-plan (the QA / verification strategy plus a risk-weighted test-case catalog — every behavior traced to a case, catalog depth scaled by risk rather than the input-permutation cross-product, testable entry/exit criteria, non-functional levels from the NFRs). Each reviewer emits exactly VERDICT: approve|revise + actionable findings with no-false-revise discipline and single-sources its bar from its authoring sibling's dossier so produce and review never drift. Built via the batched orchestrator (parallel forge, cap 3, + an independent fresh-reviewer dry-run per skill — all four PASS: the authoring pair produced grounded, executable/traceable docs; the reviewers caught every seeded weak-doc defect, including the load-bearing rollback-completeness and coverage-gap/combinatorial-blow-up checks, and approved the good docs). With this the document-skill library is complete across all five clusters (Product, Design/UX, Engineering, User-facing, Delivery). Additive — existing skills unchanged.

v2.14.0 — completes the User-facing cluster of the agent-flow document-skill library (twenty-sixth–twenty-eighth skills), the second of two sub-batches: the three reviewing- siblings of the v2.13.0 authoring trio — reviewing-user-guide (judge an end-user guide against a usability + accuracy bar: one how-to per handed-in goal, the Diataxis modes correctly typed, a complete end-user feature/config reference, steps accurate to the product, troubleshooting covering the error states), reviewing-developer-guide (judge a developer guide against an adoptability + accuracy bar with named upstream-accuracy + api-reference-linking checks: a verifiable first success, concepts before recipes, runnable code accurate to the tool, links — not duplicates — the api-reference), and reviewing-api-reference (judge a published API reference against a usability + contract-consistency bar: every api-spec operation documented with a worked example, every endpoint/shape/error traced to the handed-in api-spec with no drift — the load-bearing check). Each emits exactly VERDICT: approve|revise + actionable findings with no-false-revise discipline, and single-sources its bar from its authoring sibling's dossier so produce and review never drift. Built via the batched orchestrator (parallel forge, cap 3, + an independent fresh-reviewer two-sample dry-run per skill — all three PASS: catches the seeded weak-doc defects, approves the good doc). With this the User-facing cluster (6 skills, 3 pairs) is complete. Additive — existing skills unchanged.

v2.13.0 — adds the authoring half of the User-facing cluster of the agent-flow document-skill library (twenty-third–twenty-fifth skills), the first of two sub-batches: authoring-user-guide (the consumer-facing end-user guide — full Diataxis incl. an end-user feature/config reference, one how-to per handed-in goal with the four modes kept distinct, steps accurate to the product, troubleshooting from the real error states), authoring-developer-guide (the developer-tool adoption + integration narrative for an SDK/library/CLI/API platform — goals-not-endpoints, a fast first success, concepts before reference, code-centric integration recipes, links — never copies — the api-reference), and authoring-api-reference (the published consumer-facing API reference derived from the engineering api-spec — onboarding-first getting-started + auth, a worked example per operation, every endpoint/field/error traced to the contract with no drift, prose-first yet generation-adaptive). Each is a textual markdown artifact whose method + bar are medium-independent, carries the inline producer-upstream contract, and composes with a new gateway template (user-guide / developer-guide / api-reference). The reviewing- siblings ship next in v2.14.0 (each single-sourcing its bar from these authoring dossiers). Built via the batched build orchestrator (parallel forge, cap 3, + an independent fresh-reviewer dry-run per skill — all three PASS). Additive — existing skills unchanged.

v2.12.0 — completes the document-dependency-contract change (ship 2/2, after v2.11.0's discovery re-audit): a library-wide producer-upstream contract pass over all 14 agent-flow document skills (each → v1.1.0). Every authoring-<type> now carries an inline ## Inputs block — consume the full depends_on set the plan hands you (don't assume a fixed input), be self-contained (produce from whatever context you receive; an absent upstream becomes an explicit assumption, never fabrication), and use a research capability where available for a comprehensive, exhaustive document. Every reviewing-<type> gains the matching hard rule — judge the document against the upstreams it was given (a not-produced upstream is never a revise trigger; a produced-but-ignored one is a fair finding). Verified end-to-end by a fresh-reviewer multi-depends_on dry-run (a richer handed-in set produces a more comprehensive doc; a leaner set degrades gracefully into surfaced assumptions; the reviewer neither false-revises nor lets an ignored upstream slip). Also drops the last stray glyphs from the skills' when-to-activate lists. Additive — each skill's method + quality bar are unchanged.

v2.11.0 — re-audits project-document-discovery's dependency model (skill → v1.2.0), the first of two ships for the agent-flow document-dependency-contract change. A document's depends_on now lists every document that informs it — not only the strictly-blocking input — and every catalog entry across the seven bands + four overlays carries an explicit depends_on list; discovery copies those edges into the manifest pruned to the project's set (verified acyclic; the api-spec/data-model pair stays one-directional). The effect: a downstream document's producer is handed the full enriching upstream set (e.g. user-flows now consume the feature-spec, not just the PRD), so produced documents come out more comprehensive. The matching producer-contract framing pass over the authoring/reviewing skills (consume-the-handed-in-set · self-contained · research-using) lands next in v2.12.0. Additive — the skill's selection discipline + proportionality are unchanged.

v2.10.0 — adds the Engineering cluster of the agent-flow document-skill library (nineteenth–twenty-second skills), authoring-only: authoring-technical-design (a TDD for one feature/component — trace every decision to a requirement, one real alternative with a decision criterion, reference the architecture/api-spec/data-model rather than duplicate, failure modes + testing + rollout), authoring-architecture-doc (the whole-system structure — boundary first, a responsibility per component, a realization per NFR target, each key decision recorded as a standalone, linked ADR file with only a decisions index in the doc), authoring-api-spec (the engineering wire contract — style-agnostic rigor across OpenAPI/SDL/proto, every field typed, the error cases enumerated not just the happy path, referencing the data-model rather than redefining it), and authoring-data-model (the persistence/domain model — paradigm-aware across relational and document/NoSQL, integrity rules explicit, each index justified by an access pattern, one-directional vs the api-spec). Each is a textual markdown artifact whose method + bar are medium-independent. This cluster has no reviewing- siblings — the four engineering docs are gated at runtime by the generic design-review skill, so each authoring skill's self-check bar is that gate's checklist; a new gateway adr template ships alongside for the standalone decision records. Built via the batched build orchestrator (parallel forge, cap 3, + an independent fresh-reviewer dry-run per skill). Additive — existing skills unchanged.

v2.9.0 — adds the Design/UX cluster of the agent-flow document-skill library (thirteenth–eighteenth skills): three authoring/reviewing pairs — authoring-user-flows / reviewing-user-flows (the navigation graph: paths, branches, error/recovery, screens — synced Mermaid + numbered narrative, no dead ends), authoring-wireframes / reviewing-wireframes (structural lo-fi screen design as a textual layout description + ASCII sketch + annotations, all four per-screen states, one wireframe per flow-named screen), and authoring-design-system / reviewing-design-system (tokens + a component catalog with semantic-token tiering, per-component a11y, and an archetype-sized catalog covering the screens' real components). Each is a textual markdown artifact (a remote design-tool backend is a future concern). The reviewers emit VERDICT: approve|revise + actionable findings with no-false-revise discipline; each pair single-sources its bar from one shared dossier so produce and review never drift. Built via the batched build orchestrator (parallel forge, cap 3, + an independent fresh-reviewer dry-run per pair). Additive — existing skills unchanged.

v2.8.0 — adds the Product cluster of the agent-flow document-skill library (tenth–twelfth skills): reviewing-prd (judge a PRD against a plannability bar), authoring-feature-spec (elaborate a PRD's features into testable detail), and reviewing-feature-spec (judge a feature spec against an implementability+testability bar). The reviewers emit VERDICT: approve|revise + actionable findings with no-false-revise discipline; each authoring/reviewing pair single-sources its bar from one shared dossier so produce and review never drift. Built via the batched build orchestrator (parallel forge + independent fresh-reviewer pass per skill). Additive — existing skills unchanged.

v2.7.0 — expands project-document-discovery to v1.1.0: the document-type catalog grows from five lifecycle bands to seven (adds Band 0 project-management/ planning + Band 6 user-facing documentation) plus four domain overlays (data/ML, security/compliance, legal/governance, regulated/validation) triggered only when a project's domain calls for them. Band 4 gains threat model / DPIA / SBOM; Band 5 gains SLA-SLO / incident+postmortem / DR / migration; the archetype table adds ML/AI, OSS-library, and commercial-SaaS rows. Closes coverage gaps from a comprehensive research pass; the new document types were fresh-reviewer fact-checked (12/12 verified). Additive — the skill's body, rules, and proportionality discipline are unchanged.

v2.6.0 — adds authoring-prd (ninth skill): author a comprehensive, plannable PRD from a product idea — the method + quality bar (evidenced problem, measurable metrics, defensible MVP boundary, testable acceptance criteria), composing with a PRD template tool + a deep-research capability. Never fabricates evidence (honest flagged assumptions instead); produce-side only — a companion PRD-review skill asserts the same bar. Forge-built (deep-research grounded, 3 fresh-reviewer self-review cycles) + dogfooded on a sample idea. Additive — the existing eight skills are unchanged.

v2.5.0 — adds project-document-discovery (eighth skill): from a project idea, decides which documents the project needs to ship to production and what it takes to produce each — a proportional document plan (the document set + per-document producer role/tools/skills + an acyclic dependency graph), keyed to the project archetype. Discovery only (composes with content-template-gateway for authoring). Forge-built (deep-research grounded) + dogfooded on sample ideas. Additive — the existing seven skills are unchanged.

v2.4.0 — renames spec-review → design-review (it reviews any design document — spec, plan, RFC, ADR — not just specs) and adds a conditional plan lens (task granularity · dependency-DAG · coverage-vs-spec · exit-criteria testability) that activates when the reviewed doc is a plan. The @spec-review package path is removed (clean break, like doc-template-gateway → content-template-gateway); install @design-review. The review behavior (9-category rubric, code-grounded file:line verification) is otherwise unchanged.

v2.3.0 — adds spec-review (seventh skill): an adversarial pre-approval reviewer for spec / design doc / RFC / plan documents. Hunts a 9-category gap rubric and verifies claims against the actual codebase (file:line, no fabrication, greenfield N/A, bounded), returning severities + a ready / has-blockers verdict. Review-only — never edits or approves. Forge-built and dogfooded on a real spec. Additive — the existing six skills are unchanged.

v2.2.0 — adds github-cli-ops (sixth skill): full-coverage github.com access, CLI-first via gh with a gh api (REST) + bundled-OpenAPI $ref-resolver fallback for the ~1/3 of the API with no first-class command. Per-call GH_TOKEN auth (no gh auth switch); gh secret set for secret encryption. Forge-built (3 review cycles) + live-smoked against real github.com. Additive — the existing five skills are unchanged.

v2.1.0 — adds two skills: skill-forge (a self-learning meta-skill that researches a knowledge gap and synthesizes a portable SKILL.md) and atlassian-rest-ops (direct Confluence / Jira Cloud REST access via curl + bundled OpenAPI). Additive — the existing three skills are unchanged.

v2.0.0 — renames the third skill from doc-template-gateway to content-template-gateway and widens its scope from doc-files-only to any agent-authored structured content (any destination). Breaking for consumers of the v1.1.x @doc-template-gateway package path; the old name simply ceases with no backwards-compat shim. All three skills continue to work via direct npx skills add URL on all five supported agents.

Not yet indexed in skills.sh registry — the repo won't appear in npx skills find or the public leaderboard until a future version adds the .claude-plugin/marketplace.json manifest. Install today by sharing the direct URL. Pre-rendered per-agent plugin packages are also future work.

See architecture.md § Roadmap for the roadmap.

License

MIT © 2026 Bhushan Modi. See LICENSE.

Ver o original no GitHub

Bom para

Relacionados