Plugin

Use this skill when the user asks to validate a feature, write or improve tests, report a bug, or audit acceptance criteria coverage — /qa = QA-task workflows (verification, test creation, bug reports, exploratory). /test-strategy = test design principles + pyramid + coverage targets (knowledge). /test-local = test execution workflow.

Use this skill when the user asks to edit internal markdown documentation and source code must stay untouched — the internal documentation workflow to edit technical docs, ADRs, PRDs, design notes, release notes, and UI microcopy without touching source code, applying the Content Writer role. For public-facing blog posts, landing pages, and marketing content use `/content-creation` (it owns the GEO/SEO/humanizer pipeline). For full multi-document user-facing packs (README + API ref + runbook + tutorial) use `/docs-pack`.

Use this skill when running pre-release validation, detecting calibration regression, or tuning a skill — to run plugin evaluation tiers (Tier 1 linters and Tier 2 judge-calibration drift smoke) by wrapping the eval/runner.py harness. Tier 1 is free (no LLM); Tier 2 budgets tokens per `eval/config.json`. Tier 3 (full behavioral suites) is planned but not yet shipped — runner returns error code 3 if invoked.

Use this skill when the user has a PRD or feature brief and needs an executable plan before code is written — to plan feature implementation across services and roles by parsing the PRD/feature brief, reading project architecture (ARCHITECTURE.md, CLAUDE.md), decomposing into work packages per service/role with complexity estimates, and running a multi-reviewer feedback loop (product-manager + solution-architect + system-architect).

Use this skill when iterating a task until a binary success condition holds (test passes, schema validates, output matches a regex) and a power user wants a standalone RALF (Read-Act-Learn-Feedback) iteration loop — to wrap the task in a feedback loop with a mechanically-verifiable oracle and a kill-on signal. Not for open-ended exploration — use /spike for that.

Use this skill when evaluating new tech, prototyping approaches, researching unknowns, or building a proof-of-concept — for a time-boxed exploration with a go/no-go writeup, single-pass with optional reviewer and no RALF (a spike is exploration, not convergence). Not for development (use /develop) or decisions already made.

Use this skill when investigating, diagnosing, and fixing a reported bug — including when the user reports an error message or broken behavior without saying "bugfix" — to run an end-to-end bugfix workflow with a mandatory DEVELOP → REVIEW → QA pipeline: the Lead orchestrates triage intake, environment analysis (`/env-analyze` for local, `/analyze-prod` for production), evidence collection, and bug report, then spawns developer/reviewer/QA via the Anthropic `Agent` tool to apply, review, and verify the fix.

Use this skill when the user asks to analyze, investigate, assess, evaluate, compare, or research a codebase, architecture, system, product, market, or research topic in a structured way — including requests that need explicit scope, framework-driven reasoning, and separated facts/inference/recommendation but do not use the word "analyze" — to run a deep analysis workflow producing traceable scope, evidence, and conclusions. Not for quick one-off lookups or implementation work — this is an investigation-and-conclusions workflow.

Use this skill when implementing a feature with the canonical Anthropic `Agent` tool available — the multi-agent feature implementation pipeline (DEVELOP → REVIEW → QA with developer(s), reviewer, QA, and lead orchestrator) that spawns specialized subagents via the Agent tool (`subagent_type: "ai-skills:<role>"`); preferred over the single-agent /feature-dev fallback.

Use this skill when planning database schema changes with rollback, framework version upgrades, or library replacements — a planned migration with rollback plan across schema, library, version, and framework, run as a multi-agent pipeline with RALF on validation. Not for refactors without external contract change (use /refactor) or small bug-fix releases (use /develop).

Use this skill when cutting a release, tagging a version, preparing a changelog, or publishing release notes — to run the release workflow (version bump, changelog generation, signed git tag, release notes) which detects existing release tooling (release-please, semantic-release, Changesets, GoReleaser, cargo-release, JReleaser) and routes to it, otherwise runs an inline stack-detected release.

Use this skill when reviewing how the plugin behaved across recent runs, after a release to confirm reliability, before filing a plugin bug report, or when planning the next plugin improvement cycle — to collect and analyze past Claude Code session logs for the ai-skills plugin and surface agent, subagent, skill, command, and hook errors, timeouts, unexpected exits, and other anomalies that point at plugin defects. Defaults to the last 7 days of sessions for the current project. Produces an extended Markdown report on disk plus a brief on-screen summary.

Use this skill when breaking up large functions, migrating to new patterns, extracting to a library, or improving testability — to plan and execute a code refactor that changes structure without changing behavior via a multi-agent pipeline with a mandatory test-equivalence gate enforced by RALF. Not for adding features (use /develop) or fixing bugs (use /bugfix).

Use this skill when ready to submit code for review, opening a draft PR, or pushing a branch for review — to create a pull request by collecting the diff, generating a PR description with context, applying a checklist, and pushing, detecting .github/PULL_REQUEST_TEMPLATE.md + CODEOWNERS + stacked-PR tools (Graphite / Sapling / git-spice).

Use this skill when onboarding users to a feature, producing API documentation, or writing operational procedures — to generate a user-facing documentation pack (README, API reference, runbook, tutorial) for a module or feature; distinct from the `docs` knowledge skill — `docs-pack` produces git-versioned user docs while `docs` is general documentation guidance.

Use this skill when editing, reviewing, or producing any public-facing text — blog posts, social media, UI copy, emails, landing pages, documentation — to remove signs of AI-generated writing by detecting and fixing AI patterns including inflated symbolism, promotional language, vague attributions, em dash overuse, rule of three, AI vocabulary, negative parallelisms, sycophantic tone, and filler phrases.

Use this skill when running any daily/weekly/monthly marketing task in a project that already has marketing/MARKETING.md — the recurring marketing operations dispatcher for social posts, blog posts, email campaigns, trend research, analytics, content repurposing, community engagement, and strategy review. For first-time strategy setup, use /marketing-init.

Use this skill when verifying code by running tests, analyzing failures, or addressing coverage gaps — to run the test suite, analyze failures, auto-fix obvious issues, and re-run; serves as a sub-workflow for /develop, /bugfix, and /pre-commit and uses the `test-strategy` skill.

Use this skill when writing or editing public-facing text intended to be cited or quoted by LLMs (ChatGPT, Claude, Perplexity, Gemini, Google AI Overviews) — blog posts, landing pages, help articles, FAQ blocks, programmatic SEO templates, pillar guides — to optimize that text for GEO/AEO (Generative Engine Optimization and Answer Engine Optimization).

Use this skill when running a quality gate over staged changes before a git commit to catch lint/format/type/test failures — a pre-commit quality gate that lints, formats, type-checks, tests, and validates before committing. Detects existing pre-commit framework / Husky / Lefthook / lint-staged and routes to it; otherwise runs an inline stack-detected gate. Not the [pre-commit framework](https://pre-commit.com) itself — see Step 0 for framework detection.

Use this skill when auditing a public-facing page or site for search visibility, before publishing a marketing or blog page, when traffic drops or indexing issues are suspected, when validating JSON-LD / Open Graph / canonical / sitemap setup, or as the SEO gate inside `/content-creation` and `/docs-pack` — to run the SEO review workflow (technical SEO audit, meta tags, structured data validation, Core Web Vitals, crawlability, indexability, AI search readiness) applying the SEO Engineer role.

Use this skill when running a full local QA cycle before commit or PR — a local dev testing workflow that verifies the test environment, provisions infrastructure (Docker, Testcontainers), runs a multi-level test suite (unit → integration → E2E), performs coverage analysis, and applies a quality gate. Applies the QA Engineer role.

Use this skill when reviewing a pull request, merge request, or code change before merge, conducting an architecture review, auditing code for security/performance/quality, or running a pre-merge quality gate — including when applied by a Reviewer or QA subagent — to produce a verdict (APPROVE / REQUEST_CHANGES / COMMENT) using Google's eng-practices framing (code health over perfection) and conventional comments vocabulary (nit / suggestion / issue / praise). Distinct from /security-scan (no dependency CVE scan) and /security-audit (no full OWASP audit).

Use this skill when troubleshooting a deployment, debugging CI flakes, validating an environment before deployment, or when local diagnostics need to span more than just Docker — the multi-scope environment diagnostic covering Kubernetes, CI runner, network, resource usage, and a cross-scope drift snapshot for baselining across runs, with optional `--auto-fix` for container-level safe actions. For Docker-only local triage use `/analyze-local`. Not for code bugs (use /bugfix) or application-level diagnostics (use /spike).

Use this skill when explicit single-agent inline execution is requested or `/develop` is impractical for the situation — to run a single-agent fallback for feature implementation that detects tech stack and applies one engineering role inline (no Developer/Reviewer/QA spawning). The canonical Anthropic `Agent` tool is always available in modern Claude Code, so `/develop` (multi-agent pipeline) should be the default and this fallback should be selected only on a documented technical block.

Use this skill when bootstrapping memory in a freshly cloned repo or when upgrading from a pre-memory plugin version — to initialize the .ai-skills-memory/ skeleton in the current project (directory structure, .gitignore rules, learnings.md template, .committed/ allowlist). Idempotent — safe to re-run on a project that already has memory wired.

Use this skill when fixing a batch of issues from a code review or deep audit document — a multi-agent fix workflow that spawns developer(s), reviewer, QA via the Anthropic `Agent` tool with mandatory DEVELOP → REVIEW → QA pipeline. Auxiliary skill of /bugfix; not directly user-invoked.

Use this skill when investigating a production incident, when an alert fires (latency spike, error rate, pod crashloop), when a customer-reported issue needs prod telemetry, or as the diagnosis step of an incident-response or production-bugfix flow — including when the user describes a prod symptom without asking to "analyze" — to analyze the production environment by collecting Kubernetes pod status, managed database health, logs, metrics, and networking and diagnosing issues, supporting GCP, Azure, and AWS via the `cloud-platforms` skill and applying the SRE or DevOps role.

Use this skill when the user wants "architecture" work but the scope is ambiguous and you want auto-classification — as the architecture entry-point router that classifies the request as feature design, existing-system analysis, or migration/evolution and then dispatches to `/architecture-design`, `/architecture-analyze`, or `/architecture-evolve`. For a known scope, invoke the specialized command directly instead.

Use this skill when assembling a subagent prompt and you need its context kept small and on-topic (db-engineer gets DB sections, ui-ux-designer gets UI/UX sections, etc.) — to load a per-role slice of project context from CLAUDE.md / AGENTS.md / ARCHITECTURE.md / project memory and return Markdown ready to embed in a subagent prompt.

Use this skill when changing infrastructure config (Terraform, Helm, K8s) and a destructive or production-touching operation is involved — to run the infrastructure change workflow (Terraform plan/apply, Helm diff/upgrade, Kubernetes manifest changes) with mandatory approval gates. Applies DevOps role. Safe-by-default with plan review before any mutation.

Use this skill when designing interfaces, creating design systems, auditing accessibility, reviewing existing UI via browser screenshots, specifying components, or preparing design handoff for developers — covering UI/UX design systems, Figma workflows, accessibility checklists, browser-based visual audit with automated screenshots, component specification patterns, and design-to-code handoff procedures.

Use this skill when a local container won't start, a service is unreachable from the host, a local docker-compose stack is misbehaving, or as the Docker-layer diagnosis step of a local bugfix flow — including when the user describes the symptom without naming Docker — to run a Docker-specific local diagnostic that collects container status, logs, networking, and resource usage and diagnoses issues, applying the SRE or DevOps role for investigation. For multi-scope environment analysis (Docker + Kubernetes + CI runner + drift snapshot + optional auto-fix) use `/env-analyze` instead.

Use this skill when researching a content topic, gathering supporting facts/data, auditing existing content, building a blog content brief, or generating headlines/value-props/feature-to-benefit/FAQ/social-proof copy for a blog post, landing page, or email — the reusable knowledge layer behind /content-creation and /marketing email + social-post operations, providing content research workflows (topic research, data/fact gathering, existing-content audit, blog content brief template) and AI text-generation prompt templates for headline generation, value propositions, feature-to-benefit translation, FAQ generation, and social proof.

Use this skill when starting a task to surface prior decisions, gotchas, or conventions that apply — to query `.ai-skills-memory/learnings.md` (L4 project memory) and optionally `~/.claude/ai-skills/learnings.md` (L5 user-global) by topic or keyword, returning matching excerpts with surrounding context.

Use this skill when extending, repairing, or improving plugin assets, when ingesting a `/feedback` report as a fix-cycle backlog, or when you do not remember which lower-level command is right for the job — the umbrella workflow for ai-skills plugin-asset authoring and maintenance: creating, auditing, fixing, improving, refactoring, and migrating skills, agents, rules, hooks, prompts, schemas, and rubrics inside the plugin. Auto-classifies the request, loads the right knowledge skills (`@prompt-engineering`, `@context-engineering`, `@team-protocols`), and spawns the right subagents (`prompt-engineer`, `system-architect`, `python-engineer`, `software-engineer`, `qa-engineer`, `eval-judge`) via the `Agent` tool.

Use this skill when installing the plugin, upgrading to a new version, or troubleshooting unexpected plugin behavior — a self-diagnostic for the ai-skills plugin that validates skill frontmatter, hook executability, run-log parseability, and judge calibration. Default mode is fast and cost-free; `--calibrate-judge` is opt-in.

Use this skill when auditing a repo for vulnerabilities, before a release or production deploy, when a CVE alert needs investigation, when reviewing a third-party dependency upgrade, or as the security gate inside `/code-review`, `/security-audit`, or `/develop` — to run the security scan workflow (dependency audit, OWASP checklist, secrets scan, vulnerability report) applying the software-engineer role with security focus.

Use this skill when writing tests, designing test plans, setting up test infrastructure, or evaluating test quality — test strategy design, a test writing guide, and coverage targets, providing patterns for unit, integration, E2E, and API testing.

Use this skill when bootstrapping a target repository to be ai-skills-aware — on the first run of any ai-skills workflow in a fresh repo, when adopting the ai-skills plugin in an existing repo, or after upgrading to a plugin version that adds new memory paths or templates, including when the user does not say "init" but asks to "set up" or "onboard" the repo — to detect codebase type, create CLAUDE.md + AGENTS.md scaffolding, initialize the .ai-skills-memory/ directory tree from L1 templates, and configure .gitignore. Idempotent — safe to re-run. Accepts `--codebase-type <type>` and `--overwrite`. Not for re-initializing only memory — use `/memory-init` instead.

Use this skill when deploying a completed feature to staging for smoke-testing and verification before a production release — the deploy-to-staging workflow that builds, deploys to a staging environment, runs smoke tests, and verifies.

Use this skill when starting a new feature from concept — to convert a 1–3 sentence feature idea into a complete design pack (PRD, ARCHITECTURE, UX-FLOW, DATA-MODEL, RISKS, IMPLEMENTATION-PLAN, REVIEW-LOG) via a multi-agent three-wave pipeline orchestrated by feature-design-lead. Not for refactors (use /refactor), bugfixes (use /bugfix), or refining existing PRDs (use /develop directly).

Use this skill when running the recurring (daily) knowledge-base rescan for a repo that already has knowledge/.knowledge-sync.yml — the main-thread dispatcher that reads the config, computes the git delta since last_scanned_sha, maps changed paths to affected doc areas, early-exits cheaply when nothing changed, then fans out one Agent(content-writer) per affected area, applies the propose/direct update policy, advances the baseline only on success, and writes an L4 run log — all with the G1 untrusted-content choke-point, secret-scan, deny-list, and budget controls woven in. For first-time setup use /knowledge-sync-init.

Use this skill when bootstrapping marketing for a project that has no MARKETING.md yet — to run one-time marketing strategy initialization that gathers project context, runs an ICP/positioning interview, defines strategy (positioning, messaging, channels, pillars, tactical plan), and produces marketing/MARKETING.md and marketing/content-calendar.md in the target repo. Routes ongoing recurring operations to /marketing.

Use this skill when running a security audit, performing a security gate on code review, threat-modeling an AI/LLM component, or verifying audit coverage against the canonical OWASP categories — the OWASP Web Top 10 (2021) and OWASP GenAI/LLM Top 10 (2025) reference catalog with per-category descriptions and mitigation patterns. Covers broken access control, cryptographic failures, injection, insecure design, security misconfiguration, vulnerable components, auth failures, integrity failures, logging/monitoring failures, SSRF; and LLM01 prompt injection, LLM02 sensitive info disclosure, LLM03 supply-chain, LLM04 model poisoning, LLM05 improper output handling, LLM06 excessive agency, LLM07 system prompt leakage, LLM08 vector/embedding weaknesses, LLM09 misinformation, LLM10 unbounded consumption.

Use this skill when running a pre-release audit, compliance check, or threat modeling — to perform a full security scan of codebase and infrastructure (secrets, dependencies, auth, access control, data handling, cryptography, infra) with coverage against OWASP Top 10 (Web 2021) AND OWASP GenAI/LLM Top 10 (2025) per G3. Not for code-review security feedback (use /code-review) or pen testing (use professional service).

Use this skill when manually delegating from a workflow or building a custom orchestrator — a typed delegation helper that constructs a valid G7 spawn payload for a chosen role, validates against role-selection-table.md and the spawn-payload schema, and returns a fully-formed Agent(...) call ready for orchestrator use.

Use this skill when authoring or auditing a multi-agent skill that spawns named subagents — shared protocols for multi-agent team coordination covering the execution model, named subagent spawning via the Agent tool, file conflict prevention, developer/reviewer/lead protocols, role selection table, and G7 spawn payload + return contract schemas. Referenced by multi-agent workflow skills (`/develop`, `/team-bugfix`, `/feature-design`). Not directly user-invoked.

Use this skill when authoring or running a workflow that needs cloud-platform-specific commands, or when reviewing such workflows for platform coverage — as a knowledge module (not a workflow itself) providing platform-specific CLI commands, managed service patterns, networking, IAM, observability, and operational procedures across GCP, Azure, and AWS. Loaded by `/analyze-prod`, `/infra-change`, `/deploy-production`, and similar workflows.

Use this skill when the agent is authoring or running a Helm upgrade, previewing chart changes with helm diff, rolling back a release, inspecting release history, or managing values files for a Helm chart — for Helm procedures covering helm diff (via helm-diff plugin), atomic upgrade with --atomic and --wait, helm install / upgrade / rollback, release history, and values-file conventions. Loaded by `/infra-change` and other Kubernetes deployment workflows; not a workflow itself.

Use this skill when capturing patterns, lessons learned, or architectural decisions worth surfacing in future sessions — to perform a curated write to L4 (project) or L5 (user-global, opt-in) learnings memory. Spawns memory-curator agent to dedupe + PII-filter + schema-validate before append.

Use this skill when the user needs to write a blog post, create or optimize page content, draft conversion copy, generate visuals, or run a quality audit on existing content — including when the request describes the deliverable without saying "content creation" — to run the content creation workflow plus tools knowledge — blog-post authoring (8-step pipeline), page content optimization, AI text/image generation tools, quality gates, GEO/AEO structure, and humanization. Accepts content type blog-post | page | landing | email | other.

Use this skill when the agent is starting any Terraform or Helm change and needs to determine whether the apply flow is owned by a controller (in which case the change is a git PR, not a local imperative command) — for GitOps and orchestrator detection covering marker patterns and routing rules for Argo CD, Flux, Atlantis, HCP Terraform / Terraform Cloud, Spacelift, and env0. Loaded by `/infra-change` and related infrastructure workflows; not a workflow itself.

Use this skill when querying a production telemetry stack, when authoring or reviewing an analysis workflow that needs vendor query examples, or when identifying which stack is deployed from `CLAUDE.md`, helm charts, `prometheus-operator` CRDs, or an OTel collector config — a knowledge skill providing a production telemetry stack reference covering Prometheus + Grafana, Datadog, Honeycomb, New Relic, Sentry, and OpenTelemetry + Tempo / Jaeger, with per-stack ingestion model, query patterns, UI surface, and when each stack is the right choice. Loaded by `/analyze-prod`, `/analyze-local`, `/env-analyze`, `/infra-change`, and `/bugfix` workflows when production-context diagnosis needs vendor-specific query syntax.

Use this skill when shipping to production after staging is green, when a deploy needs a documented rollback plan, or when the APPROVE-gate workflow is required — the deploy-to-production workflow (final checks, approval gate, deploy, verify, rollback plan) that uses the `deployment-procedures` skill and requires explicit APPROVE before any production mutation.

Use this skill when the agent is defining or revising marketing positioning, messaging, channel mix, content pillars, a tactical/calendar plan, or success metrics — for marketing strategy frameworks covering hierarchy (mission → positioning → messaging → channels → pillars → tactical → calendar), channel-selection (audience/resource/content fit), content-pillar model, and measurement framework (vanity / engagement / pipeline / revenue). The reusable knowledge layer behind /marketing-init (one-time setup) and /marketing (recurring ops) — both reference these frameworks instead of inlining them.

Use this skill when auditing, validating, or fixing an existing plugin skill's frontmatter, body length, progressive-disclosure structure, cross-references, or eval wiring — after editing skills under `plugin/skills/`, before merging a PR that touches them, or when a skill stops triggering as expected — the internal procedure for `/plugin-author audit`. Checks frontmatter against the agentskills.io specification plus ai-skills plugin conventions and optionally applies safe fixes. No longer slash-invocable — call `/plugin-author audit [<name> | --all] [--deep] [--strict] [--fix]` instead. Read by the `prompt-engineer` agent at task start when DEV-ing or reviewing a plugin skill (the safe-fix table and audit checks are the cached digest of upstream spec rules).

Use this skill when designing prompts, building AI features, or auditing LLM security — a prompt engineering knowledge base covering technique taxonomy, template patterns, the OWASP LLM Top 10 security checklist, eval frameworks, structured output contracts, and cost optimization.

Use this skill when developing features or fixing bugs in isolated branches via git worktree — git worktree branch isolation for feature development and bugfixes, covering branch naming, worktree setup, branch verification, and safe cleanup.

Use this skill when a new feature with a PRD needs architectural definition before `/plan` can decompose it for implementation — including when the user describes a feature to be built but does not say "architecture" or "design" — to produce a feature-level design pack — ARD/ADR, C4 diagrams, API contracts, data models, NFR spec, and security review from the PRD. Routes to solution-architect (default — feature-level system design), cloud-architect (`--cloud` for cloud infra design, landing zones, networking, multi-cloud), or devops-architect (`--cicd` for pipeline design, deployment strategy, platform engineering).