Agent Skills

AI agent skills for Claude Code and compatible agents

Tested per skill, scanned by Cisco's skill-scanner.

• Install
• Requirements
• Skills
  • Workflow Skills
  • Coding Skills
  • Design Skills
  • Claude Code Skills
  • Media Skills
  • Productivity Skills
  • Writing Skills
  • Companion Skills
• Pipeline
• Testing
• Security
• Standards
• License

Install

Install via skills.sh:

# All skills
npx skills add coroboros/agent-skills

# Individual skill
npx skills add coroboros/agent-skills --skill <name>

Requirements

• bash
• python3 (3.10+, stdlib only — no pip install needed)
• A filesystem

Some skills wrap external CLIs — each is declared in its SKILL.md.

Skills

Skills are grouped by plugin. Each plugin collects related skills — expand any section below to see usage, flags, and behavior. Companion skills live in their tool's repo and install from it — see Companion Skills.

Skills inherit the session model — no model: pins, so a stronger session is never downgraded by a skill. Scope is two-tier per the Agent Skills spec: portable skills omit the compatibility field entirely; Claude Code-optimized skills declare it and degrade gracefully on any open-standard agent (see Standards).

Workflow Skills

Strategic thinking, planning, and implementation — forge, apex, ultrapex, oneshot.

forge

Pre-implementation thinking — research the problem space, weigh approaches with devil's-advocate rigor, decide what's reversible while surfacing the load-bearing forks for the user, and emit one apex-ready plan. The "think" half; apex is the "build" half.

Usage

# Exploratory question — default emits a Decision and pauses for decompose
/forge should we use Neon or Supabase for our serverless Postgres?

# Build verb in the idea — promotes to a Spec with workstreams
/forge -s add user authentication with OAuth and email/password

# Auto mode + create GitHub issues
/forge -s -a -i migrate from REST to GraphQL

Flags

Uppercase forms disable the ambient default when the skill runs with a pre-set mode. Requires gh authenticated when using -i or passing a GitHub URL/#N to -f.

What it does

1. Hunt — frames and reframes the real problem, then researches wide via parallel subagents above a hard floor: ≥1 codebase + ≥1 external agent every run, -e the only escape. Triangulates sources rather than picking one, and auto-launches a second research round when the premortem surfaces an unresearched failure mode. On-demand references for breadth (research-discipline.md), the 5-question clarify playbook (clarify-playbook.md), and subagent prompt skeletons (subagent-prompts.md).
2. Judge — diverges ≥3 structurally distinct approaches, stress-tests with premortem + steelman, then runs an adversarial panel (3-5 lensed clean-context critics in parallel) and a bounded convergence round on the survivors — the same conversation cannot reliably argue against the plan it just shipped (adversarial-panel.md).
3. Decide — three tiers: decide the reversible and conventional calls, surface the structurally load-bearing forks for the user (named with the pick, the runner-up, and what would flip it), escalate the few forks the user genuinely owns.
4. Forge — chooses the artifact shape, walks a pre-save audit, saves, validates (when there are workstreams), pauses for revision under non-auto, then routes.

Routing. Default = # Decision: (terminal — present and ask the user whether to decompose into workstreams, then wait). Promotes to # Spec: (with 3-7 workstreams + /apex bridge) when -a is set, when -i forces issue creation, when -f points at a prior Spec, when the idea carries an unambiguous build verb (build, add, implement, migrate, refactor, create, …), when it carries an explicit decomposition signal (plan, break down, spec out, workstreams, issues, roadmap), or when the Decision IS the build plan.

Sources

• anthropics/knowledge-work-plugins — product-brainstorming — divergent/convergent ideation modes and frameworks
• anthropics/knowledge-work-plugins — write-spec — PRD structure, acceptance-criteria craft, ruthless prioritization
• Melvynx/aiblueprint — ultrathink — craftsman simplification discipline
• mattpocock/skills — grill-me — decision-tree interview behind the opt-in deep grill
• mattpocock/skills — to-issues — vertical-slice decomposition and HITL/AFK tagging

apex

Systematic implementation using the APEX methodology — Analyze, Plan, Execute, eXamine — with parallel subagents and self-validation.

Usage

# Autonomous + save outputs
/apex -a -s implement user registration

# From a GitHub issue
/apex -f "#42" implement what issue 42 describes

# From a prior forge plan
/apex -f ~/.agents/output/{project}/forge/forge-{slug}.md implement WS-1

# Resume a previous task
/apex -r 01-auth-middleware

Flags

Uppercase forms disable the ambient default when the skill runs with a pre-set mode.

What it does

• Analyze — launches 1–10 parallel subagents based on task complexity. Infers acceptance criteria in Given/When/Then form with explicit ## Not Included negative scope. When -f points to a spec (H1 # Spec: + ## Workstreams), accepts the spec's AC verbatim (closure rule) instead of re-inferring.
• Plan — file-by-file implementation strategy with AC mapping. Inline Challenge mini-phase (premortem + alternative consideration) stress-tests the plan. Surgical-scope advisory fires when the plan touches >5 files, >2 systems, or introduces cross-cutting concerns — advisory only, never blocks.
• Execute — todo-driven implementation with progressive step loading.
• eXamine — derivation lens (code↔plan reconciliation, classifying each divergence as GAP / SCOPE-ADD / DECISION-OVERRIDE / CONSISTENT) runs before typecheck/lint/tests. GAP blocks completion; SCOPE-ADD advisory unless declared in negative scope; DECISION-OVERRIDE surfaces for user judgment. Optional /goal integration via -g loops the session until AC verified — transcript-only Haiku evaluator, requires Claude Code v2.1.139+; auto-on under claude -p.
• Resume — -r auto-validates state via validate_state.sh before restoration; partial or corrupt task dirs fail loud rather than cascade.

Accepts output from forge via -f. Works standalone.

Trust model

Analyze fetches third-party content into the workflow — web research via general-purpose subagents, library docs via Context7, GitHub issue bodies via -f #N, any file passed to -f. An adversarial document hosted at a fetched URL, or pasted into an issue body, can attempt indirect prompt injection. User review of the analysis report before approving the plan is the trust boundary — confirm the surfaced files, patterns, and acceptance criteria match intent. Pass -e (economy mode) to disable subagents and remove the third-party surface entirely. Full disclosure in skills/apex/SKILL.md § Trust model.

Sources

• Melvynx/aiblueprint — apex — APEX methodology (Analyze, Plan, Execute, eXamine) reference implementation

ultrapex

Outcome-driven end-to-end implementation for Fable-class frontier models — the judgment-first sibling of /apex: same mission, invariants instead of step scripts.

Usage

# Implement end to end, save the report
/ultrapex -s implement user registration

# Build a forge plan
/ultrapex -f ~/.agents/output/{project}/forge/forge-{slug}.md

Flags

What it does

Five invariants instead of gated steps: understand before building, decide and commit (pause only at genuine forks), build complete and scoped, verify adversarially with fresh-context refuter subagents scaled to blast radius, report grounded in tool-result evidence. Self-scoped by a Model scope section — on models below Fable-class it routes to /apex, which keeps step gates, resume, and economy mode.

oneshot

Single-pass feature implementation — Explore, Code, Test. Ship now, iterate later.

Usage

/oneshot add dark mode toggle to the navbar
/oneshot #42

What it does

1. Resolve — if input is a GitHub issue (#N or URL), fetches via gh and uses the title/body
2. Explore — finds 2–3 key files, searches for patterns (no tours)
3. Complexity check — if >5 files or multiple systems, suggests /apex or /forge instead
4. Code — follows existing codebase patterns exactly
5. Test — runs lint and typecheck, fixes only what it broke

One task only. No tangential improvements, no refactoring outside scope. Stops after 2 failed attempts.

Sources

• Melvynx/aiblueprint — oneshot — Explore/Code/Test loop with complexity escalation to apex or forge

Coding Skills

Bootstrap projects and review changes before commit — scaffold, code-ultrareview.

scaffold

Scaffold new web projects with an opinionated stack on Cloudflare Workers.

Strict opinion — no Vercel/Netlify, no ESLint/Prettier. Use a different scaffold for any other stack.

Requirements

• stable even-numbered Node.js >= 22.12.0
• pnpm — provision a reviewed version via Corepack (corepack enable && corepack install --global pnpm@<reviewed-version>) or the official pnpm installer
• jq

Usage

/scaffold next-cloudflare my-saas
/scaffold astro-cloudflare landing-page
/scaffold next-cf                        # alias

Scaffolds

Shared: TypeScript strict, pnpm, Biome, Tailwind CSS.

What it does

Runs the official framework CLI, preserves the generator's ignore rules while overlaying the opinionated config (Biome, Cloudflare Workers, canonical AGENTS.md, thin CLAUDE.md adapter, shared .agents/rules/, pnpm scripts, .worktreeinclude — copies dev-critical gitignored files into Claude Code worktrees), and installs the full stack. When installed, /award-design (award-level direction), /frontend-dev (everyday UI), and /design-system are optional follow-on handoffs.

code-ultrareview

Eight-axis judgment code review at full strength, in-session. The default runs every axis and the full applicable battery with no sampling; --axes is an explicitly scoped mode with no repository verdict. The 8 axes (Correctness, Simplification, Tests, Documentation, Style, Intent, Design/API, Performance) run as parallel Explore subagents on Claude Code or the harness equivalent; Coherence joins as a 9th when a manifest, SKILL.md, tsconfig.json, pyproject.toml, Cargo.toml, go.mod, or root README.md is in the diff. In-session on the user's own subscription — distinct from Anthropic's remote /ultrareview.

Usage

/code-ultrareview                              # full 8-axis review, print report
/code-ultrareview -s                           # save the report + JSONL for /apex -f
/code-ultrareview -b origin/main               # review HEAD against an explicit base
/code-ultrareview --verify-build               # require the canonical project test gate to pass
/code-ultrareview --mutation-test              # add Stryker / Pitest / mutmut on changed files
/code-ultrareview --reconcile @auto            # add Intent-axis derivation sub-mode
/code-ultrareview --apply-safe                 # full review + gated low-risk fixes
/code-ultrareview --preflight                  # list tools the battery would run, no review
/code-ultrareview --axes correctness,tests     # subset of axes

Flags

The five phases

1. Scope — deterministic, no LLM: resolves the diff, classifies the repo (one of 9 kinds), reads the cross-agent instruction chain, decides whether Coherence activates.
2. Tool battery — per-language static analysis (table below); findings carry confidence: 100 and skip validation. Never auto-installs.
3. Axis review — 8–9 parallel Explore subagents, each scoped to its axis with the diff + filtered tool findings, scoring 0–100 against the verbatim Anthropic rubric.
4. Validation — a fresh-context validator (Haiku on Claude Code) re-scores every sub-80 finding. A2 no-silent-drop: promoted (≥80), demoted with reason, or surfaced in ### ⚠️ Unverified — never omitted. --verify-build runs before this.
5. Synthesis — dedup, inter-axis precedence, a Ship / Fix-then-ship / Needs work verdict, Conventional Comments JSONL, and a mandatory What I did NOT check closing section (defers security to /security-review, runtime perf, flaky detection).

Tool battery — tool → axis

The battery resolves every applicable analyzer before running the first one. A JavaScript declaration at the repository root or one workspace covering every input relevant to that tool is authoritative: the battery runs that direct or hoisted binary. In a Yarn Plug'n'Play project, where node_modules/.bin is intentionally absent, it invokes the declared binary through Yarn with network access disabled. Multiple declarations or mixed declared and undeclared package scopes block until the analyzer is declared once at the repository root. Without a declaration, it may use an installed PATH command. It never resolves packages at runtime. Missing or failed analyzers block with exact remediation and rerun commands before any axis reviewer or verdict. Run /code-ultrareview --preflight to validate the current repo.

Bundled Semgrep perf-rules (references/perf-rules/) route N+1 and sync-IO findings to the Performance axis.

Rules

• Zero auto-install — never runs brew / cargo / go / pip / npm -g; natives are installed explicitly.
• Atomic coverage — a missing or failed applicable analyzer stops before axis review; fix the printed prerequisite and rerun. An analyzer that cannot apply to the scope is recorded as not applicable; the review continues.
• Cite precisely — every finding carries file:line; instruction-rule findings quote the violated rule verbatim and name its source file.

Sources

• anthropics/claude-plugins-official — code-review — verbatim 0/25/50/75/100 rubric, HIGH SIGNAL criteria, false-positive taxonomy, agent-assumption rule, parallel-reviewer + Haiku-validator pattern
• anthropics/claude-plugins-official — code-simplifier — Simplification axis precedent (nested ternaries forbidden, "fewer lines over readability" forbidden)
• Anthropic — Code Review docs — Managed Code Review severity tiers (Important / Nit / Pre-existing) adopted in synthesis
• Anthropic — /ultrareview docs — remote sandbox + multi-agent fleet + per-finding independent verification (the upstream this skill distinguishes itself from — in-session vs remote, distinct namespace)
• mattpocock/skills — improve-codebase-architecture — deletion test for shallow-module / wide-interface smells (Ousterhout deep modules) in the Design/API axis

Design Skills

Award-level art direction, the everyday frontend lane, and DESIGN.md token governance — award-design, frontend-dev, design-system.

award-design

An art director targeting Awwwards SOTD 7.5+, FWA, CSSDA. Takes the lead when the brief names the ceiling: award-winning, premium, signature, a new visual identity, an uplift or ground-up redesign. Forces a committed, anti-default visual universe, writes it as a DESIGN.md (the Google open standard) and a design-plan.md whose ladder of build chunks any executor runs one at a time; handed one chunk, builds that chunk alone under its gates. Adapts to an existing DESIGN.md and alerts when it is thin. Frontend only — single-token tweaks route to /design-system, everyday no-award work and dashboards or internal tools at any ambition to /frontend-dev, never backend. A review mode audits any site at any time.

Usage

/award-design landing page for a sustainable coffee brand            # direction → DESIGN.md + design-plan.md with the ladder
/award-design chunk hero                                             # build one ladder chunk
/award-design -u https://linear.app portfolio for a motion designer  # brand-extract a live site as the seed
/award-design review https://example.com                             # audit an existing site

A brief ends with the direction (DESIGN.md and design-plan.md with its ladder) and builds nothing; the ladder's chunks build, one per executor run. chunk <id>, or a pasted ladder chunk, builds that chunk alone and writes its Report into the ladder row. -u <url> reverse-engineers the brand from a live site as the archetype seed; the observation informs the direction but doesn't constrain it — the brief is still the destination. review <url|path> runs the adversarial critic against any site at any time, no build required.

Archetypes

Each archetype anchors to a canonical winner (corpus-credentialed). The reference file splits DNA (non-negotiable identity, mood-agnostic) from common expressions (2–4 named stacks per archetype), so one DNA admits multiple valid styles — Immersive runs cinematic-dark, editorial-portrait, or daylight-automotive without losing identity.

Key features

• Direction by dice — the model writes 5–7 candidate spines, then a seeded roll (scripts/direction_roll.py, SHA-256, offline, reproducible from its printed key) assigns one with the model's top two structurally unreachable, because a model's own ranking converges on the same direction every run. Challengers dealt from sibling archetypes must beat the assignment on audience identification and product clarity to take the build; the category standard stays on the table as the user's standing exit, never the model's recommendation
• The six-block contract — THESIS · OWN-WORLD · STORY (the desire arc's five content answers) · FIRST-VIEWPORT · FORM+SEED · SIGNATURE (verb · medium · trigger · replay), ≤180 words, written before any build file and copied into the first artifact's opening comment. A block that reads like a mood is not decided yet; a fresh-context R1 refutes the concept before code exists
• The ladder — the direction run ends with design-plan.md, its build written under LADDER: as chunks from references/chunk-template.md (Read first · Implement · Verify · Out of scope · Report), in order: the shell → the hero (2–3 distinct directions through one shared render frame, a fresh-context judge picking beside the archetype's live exemplar) → the sections, paced like a score with one climax and at least one rest → the award surfaces (loader, nav, cursor, footer moment, route transitions, sound; each committed or declared out with a reason) → further pages → the review. One chunk per executor run: this skill in chunk mode, /apex, /ultrapex, or any agent; a chunk that would change DESIGN.md is handed back as a scope change
• Two-tier archetype knowledge — nine ~40-line tier-1 files (DNA, anti-signals, reflex lists) pushed into context by the roll itself; nine tier-2 references loaded by heading (effect palettes, page recipes, mid-page life, spectacle menus), every claim carrying its evidence class — winner, shipped, technique, theory — and only the first three bind
• Techniques as skeletons, facts with dates — seven complete wirings (references/skeletons.md) each closing on the failure it prevents (the Lenis autoRaf double-drive ships fixed); references/stack-facts.md is the dated authority for every version and support figure, with staleness surfaced by the scanner past 180 days
• The mechanical floor — the static scanner (42 rules incl. the OPTICAL-* craft family), two browser payloads injected by the harness (render-floor.js: text-on-text, clipped glyphs, zero-width content, CTA-in-fold, missing mobile nav, per width 375–1920; pixel-metrics.js: emptiness, ink profile, ground commitment, accent frequency — evidence only), and the computed-style detector, run by every chunk's Verify on the files and pages it touches. One browser session per run; payloads never own a process
• The review owns the verdict — the ladder's last chunk, one fresh-context driven audit (references/gate/review.md): inventory before anchoring, the comparative desire read beside the live exemplar (DESIRE-READ: BEATS|LOSES — cause: concept|execution|craft routes the remedy), a bounded fix loop, and a ship label the builder cannot write — READY only via the reviewer's synthesis or the human's yes, REVIEWED-SAME-CONTEXT when neither exists
• Review mode standalone — award-design review <url|path> runs the same instrument on any site: archetype derived from the target, scored against the awwwards rubric with the desire read and ordered findings, no ship label
• Anti-AI-slop hard constraints — the AI-purple gradient, Inter/Roboto on the display face, pure #000/#fff, placeholder names and fake stats, meta-labels, eyebrow spam, scroll hijack, sub-device-resolution signature assets — match-and-refuse, machine-checked where a rule is named, overridden only by a quoted client clause
• Imagery — real assets, an acquire-and-verify protocol for branded builds, every signature asset ≥ device pixels at its worst rendered moment, never faked out of divs
• WebGL/3D delegation — a committed scene is one ladder chunk handed to one subagent under a tested delegation contract (DESIGN.md quoted verbatim, fidelity and input-correctness floors, poster-first LCP); the returned module is integrated in-context, never co-written
• Judging criteria — Design 40%, Usability 30%, Creativity 20%, Content 10%; HM 6.5+, SOTD ~7.5+, routine SOTD 7.2–7.9. Performance measured with provenance: LCP < 1.5s, CLS < 0.05, INP < 100ms
• DESIGN.md handoff — authors the DESIGN.md up front and every chunk builds under it; /design-system governs it afterward (drift, updates, audits). Clean author-vs-govern boundary

Sources

• Award-winning websites 2025-2030 (Coroboros Research) — judging criteria, SOTD/SOTY patterns, studio analysis (Locomotive, Active Theory, Resn, Immersive Garden, Cuberto)
• Leonxlnx/taste-skill — the ambient-forcing / art-director reference
• Google DESIGN.md — the open standard for the DESIGN.md this skill writes; @google/design.md CLI lints the output
• greensock/gsap-skills — motion canon, deferred to by name when installed
• Vercel Web Interface Guidelines — UX quality rules
• dev-browser — CLI visual review

frontend-dev

The everyday frontend lane — pages, dashboards, forms, components, quick landings. Commits a five-line direction (SURFACE · WORLD · TYPE · COLOR · SIGNATURE) before any code, fixes composition by surface archetype, holds hard floors on type, spacing, color, and motion, and refuses the model's fingerprint page by name. Reads a DESIGN.md or an award-design ladder chunk as the brief when one exists. One file, fully resident — no references, no scripts.

Usage

/frontend-dev add a changelog page          # everyday work — ritual, floors, fresh-pixels verify
/frontend-dev build the admin dashboard     # Monitor surface — dense grid, full states, no hero
/frontend-dev quick landing for the beta    # Persuade surface — conversion lines above the ritual

Key features

• The commit ritual — five lines with concrete values, written in the response and copied into the first file's top comment; the first instinct is named and rejected, identity derives from the subject's world, never a template
• Surface archetypes — seven compositions (Persuade, Monitor, Decide, Create, Browse, Read, Enter) decided by what the page is for; hero-plus-cards fits exactly one of them
• Hard floors — snapped type scale, body ≥ 16px, 45–75ch measure, base-4 spacing, one accent doing accent work only, contrast ≥ 4.5:1, the separation ladder (spacing → dividers → tint → borders → shadows), one easing family, a reduced-motion branch always
• The fingerprint ban — ten model defaults matched and refused: the purple gradient, Inter on display, three equal cards, eyebrows, center-stack, nested cards, default glassmorphism, invented stats, em-dash copy, icon toppers
• States and ship — five interactive states, three data states, and a ship checklist (375/768/1440, designed 404, alt text, skip link, keyboard path, zero console errors, one signature moment)
• Conversion pass for landings — OFFER / AUDIENCE / ACTION above the ritual; proof beside claims, an objections section, risk reversal, one CTA repeated
• Brief consumption — DESIGN.md tokens are law when present; an award-design ladder chunk hands to /award-design chunk mode when installed, else runs under its own Verify; award asks on a landing, portfolio, product or marketing site, single-token changes, and empty directories route to /award-design, /design-system, /scaffold; dashboards and internal tools stay at any ambition

Sources

• The winning recipe of AI design skills (Coroboros Research) — the eleven-system corpus read this lane distils
• elayadesign/ai-design-skills — the resident single-file lane, conversion before visuals, terminal checklists
• elayadesign/redesign-skill — the "make it look better" register
• NousResearch/hermes-agent — surface archetypes; slop as a compositional defect
• pbakaus/impeccable — the first-instinct-is-spent commitment, measured verification
• Nutlope/hallmark — the fingerprint ban lists
• openai/plugins — the separation ladder, state coverage, blocking gates

design-system

Govern an existing DESIGN.md — the Google DESIGN.md open standard (YAML frontmatter tokens + eight prose sections). Activates by intent during UI edits to enforce token-only sourcing when a DESIGN.md is present, and steps aside when none exists — it never blocks the edit or invents a design direction (that is /award-design's job — it forces a universe, writes the DESIGN.md and the build ladder; everyday UI work without a file belongs to /frontend-dev). Exposes seven subcommands, four backed by the canonical CLI, for the full DESIGN.md lifecycle. audit-extensions closes the bidirectional drift loop between DESIGN.md extension namespaces (motion, shadows, aspect-ratios, heights, containers, breakpoints, z-index, border-widths, opacity, scroll-triggers — see references/extended-tokens.md) and the globals.css @theme mirror.

Requirements

• designmd on PATH: npm install --global --ignore-scripts @google/design.md, then designmd --version. Bundled wrappers never resolve packages at runtime; a missing, failed, or invalid CLI blocks with exact repair and rerun guidance.

Usage

Use during UI edits such as:

• src/components/**, src/app/**, src/pages/**, src/layouts/**, src/styles/**
• src/features/*/components/**
• DESIGN.md, tailwind.config.*

It is also invocable directly via /design-system with one of seven subcommands:

/design-system audit                                # lint ./DESIGN.md, report with fix proposals
/design-system audit ./docs/DESIGN.md -s            # save the report under ~/.agents/output/
/design-system diff                                 # diff ./DESIGN.md vs HEAD (git-aware)
/design-system diff old.md new.md                   # two-file diff
/design-system export tailwind                      # → tailwind.theme.json
/design-system export dtcg -o tokens.json           # W3C DTCG format
/design-system spec --rules                         # emit canonical spec + lint rules
/design-system migrate ./legacy-DESIGN.md           # Stitch 9-section → Google standard
/des