Skip to content

arthrod/conejo-skills

v3.3.0MIT

arthrod's curated skill set, centred on the Conejo coding-philosophy family (conejo, conejo-code, conejo-debug, conejo-frontend, conejo-merge, conejo-legal) plus the obra/superpowers process skills, Pydantic AI, Plate/DOCX, Tauri/better-auth, Rust, and the Pi terminal agent.

arthrod's Skill Registry

License: MIT

81 skills — last sync 2026-11-13. v3.3.0

Major restructure: families collapsed (Pi → 2 skills, Pydantic AI → 1 with references/, Rust → rust-author + rust-review, Better Auth slimmed, design dials folded into impeccable), new combined skills (conejo absorbs code-review + autofix + pr-triage-gh, marimo absorbs 4 marimo skills, ml-gpu-training absorbs CUDA setup). All design tools include a Stitch-first mandate (STITCH-DESIGN.md in each design-skill folder). 13 design/UI skills folded into conejo-frontend/refs/ as reference docs.

v3.3.0 (2026-11-06) — the development-system release. The 15 process-discipline skills are re-vendored from obra/superpowers v7.0.2 (22f0b46) with upstream text kept verbatim and this repo's rules appended in a <!-- conejo:start --> … <!-- conejo:end --> block (see Development system rules). Three doctrines are now canonical in conejo-code/references/: agent-dispatch.md (other-corpus model CLIs — how to list and select models for pi, crush, codex, grok, cline, octo), acceptance-criteria.md (every plan task carries acceptance criteria with an independent measurer) and stacked-prs-and-ci.md (stacked PRs via gh stack; CI/CD wait only on the last task; PR comments one by one). House stack switched to pnpm / uv / pyrefly / oxlint / oxfmt / vite / vitest / Astro / cargo-nextest. Marketplace manifest reconciled with what is on disk.

Conejo coding-philosophy family

The conejo-* skills form a tightly coupled coding + PR workflow. They share four doctrines authored once inside conejo-code/references/ and route to each other:

  • testing-doctrine.md — universal red-green TDD.
  • agent-dispatch.md — the Warren Protocol: dispatch work to other-corpus model CLIs (pi → crush → codex → grok → cline → octo → subagents) to preserve context and get a different corpus's opinion; the reviewer is never the author's model. Lists, per tool, how to see its models and how to select one.
  • acceptance-criteria.md — every plan task has acceptance criteria, each with an independent measurer (a command, probe, click-flow, diff or metric that proves the behavior from outside the code). Red before, green after; the reviewer runs it.
  • stacked-prs-and-ci.md — stacked PRs via gh stack (one plan = one stack, one task = one layer, never hand-rebase); wait for CI/CD only on the plan's last task; PR comments answered one by one, ledger reconciled.
SkillRole
conejoUniversal dispatcher/philosophy — enforces red-green TDD, acceptance criteria with independent measurers on every task, stacked PRs driven by gh stack (no hand rebases of the chain), evidence-before-claims, other-corpus agent dispatch, CI/CD wait only on the last task, the hidden-gems review doctrine, one-by-one PR replies and the no-batch-review rule. Carries the house stack preference. Routes work to the specialised siblings below.
conejo-codeActive coding loop. Holds the four canonical doctrines: references/testing-doctrine.md (red-green-refactor, no green-without-red, no implementation without a failing test), references/agent-dispatch.md (pi/crush/codex/grok/cline/octo dispatch ladder with model listing + selection commands, adversarial review prompts, model preferences), references/acceptance-criteria.md (independent measurers, RED/GREEN, ledger format) and references/stacked-prs-and-ci.md (gh stack command set, CI-only-on-last-task rule).
conejo-frontendVERY STRICT UI gate. Mandates agent-browser E2E click-flows for every UI assertion; forbids tRPC calls to assert UI state (allowed only for auth/seeding). Requires a 24/7 dev server, React + Tailwind v4 + shadcn/ui; rejects Ant Design. Mandatory screenshot + browser-console + design-critique loop before any visible change counts as done. 13 design/UI skills live under skills/conejo-frontend/refs/ as reference docs reached via its index — they are not standalone registered skills.
conejo-mergeCalm-implement PR handler: one comment at a time, without exception — gate each comment individually (batch review is forbidden; the verdict ledger must reconcile), group into tasks, test/install/ship, reply with state changes. Hidden-gems doctrine: different bots = different corpora, so weird nits get more scrutiny, not less. Deep engines live under skills/conejo-merge/refs/ (CodeRabbit CLI engine, autofix, PR triage incl. the gh stack stacked-PR workflow and merge order, proud-zanahoria).
conejo-legalSingle-issue US doctrinal legal research run with PR-review discipline: source-audited OKF legal_issue bundle (SKOS digest, source/snippet ledger), same hidden-gems and one-by-one verification rules as the code family.
conejo-debugSkeptical investigator & autonomous deep work: hunt PRs like crime scenes, interrogate CodeRabbit plans, systematic debugging protocol with multi-agent second opinions, strict TDD fixes. Slow, powerful, one clue at a time.

Foundational top-level skills — react, react-best-practices, react-composables and tailwind-v4 remain registered as independent top-level skills because they are used well beyond frontend work and are referenced by non-frontend skill families. layout was folded into conejo-frontend/refs/ and impeccable (commit 9a0b1f6).

Helper scripts

ScriptPurpose
scripts/install-conejo-hooks.shOpt-in hook installer: idempotently merges two Claude Code hooks into a settings.json (default ~/.claude/settings.json, override with --settings) — a `PreToolUse(Edit
scripts/sync-to-claude.shMirrors the conejo-* skills to ~/.claude/skills and prunes the 13 folded design skills that now live inside conejo-frontend/refs/. Symlink-aware, refuses to delete locally-modified directories, supports --dry-run and --root <path>.
scripts/update-skills.shDefault (publish): refreshes vendored skills from their original upstream remotes (via scripts/update-vendored.sh), then copies ./skills/ → ~/.agents/skills/ (overwrite) and symlinks ~/.claude/skills/<name> → ../../.agents/skills/<name>. --reverse flips direction: ~/.claude/skills/ → ./skills/ (additive, or --yolo to wipe). --skip-vendored skips the upstream refresh. Step 3b also symlinks every skill into each other agent's skills dir that exists (~/.pi/agent/skills, ~/.codex/skills, ~/.config/crush/skills, ~/.grok/skills, ~/.cline/skills, ~/.gemini/skills, ~/.config/agents/skills; override with AGENT_DIRS="…") so pi/codex/crush/grok/cline see the same skills as Claude. DRY_RUN=1 everywhere.
scripts/update-vendored.shPer-skill upstream refresh. Reads scripts/vendored-sources.tsv and re-fetches each IDENTICAL/MERE-COPY skill's SKILL.md (+ references/) from github.com/<repo> via gh api. Skips CUSTOMIZED and SUPERPOWERS rows, warns on LIGHT-EDIT unless FORCE=1. Preserves <!-- cross-ref --> and <!-- conejo --> blocks.
scripts/refresh-superpowers.shWhole-directory refresh of the 15 superpowers skills: pulls obra/superpowers into the git-ignored ./superpowers/ clone (REF=<tag> to pin), replaces each skills/<name>/ (scripts, prompts, references and all), re-appends the vendored footer and the skill's <!-- conejo --> block. DRY_RUN=1; optional skill-name arguments for a subset.

Development system rules (Arthur, 2026-11-06)

Five rules, enforced from the conejo non-negotiables and from the conejo block of every vendored superpowers skill. Canonical text lives in the doctrine files named in each row.

RuleWhat it meansCanonical
Other-corpus reviews, strictlyEvery spec, plan, code and PR-comment review comes from a model that did not write the work: GLM/MiniMax/DeepSeek via pi or crush, GPT via codex, Grok via grok, plus cline and octo. Same-corpus Claude subagents review only as the last rung. Adversarial framing always; praise-only output is a null result.conejo-code/references/agent-dispatch.md — list models: pi-help / pi --list-models, crush models, codex /model or ~/.codex/config.toml, grok models, cline auth, octo list; select: pi --provider X --model Y, crush run -m, codex exec -m, grok -m, cline -P … -m …, octo prompt --model
Acceptance criteria on every plan taskNo exceptions. Each criterion is an observable behavior plus an independent measurer runnable by someone who never read the diff. Measurers go RED before and GREEN after; the reviewer runs them; the ledger records their output.conejo-code/references/acceptance-criteria.md
Stacked PRs via gh stackGitHub supports stacks natively. One plan = one stack, one task = one layer (feat/<plan>-<N>-<slug>), gh stack add / push / rebase --no-trunk / merge; never hand-rebase the chain. Explain stacks to the partner once per project.conejo-code/references/stacked-prs-and-ci.md
Wait for CI/CD only on the last taskMiddle of a plan: commit, gh stack push, next task — no polling of Actions or bots. Last task: wait with a 10-minute cap, then process comments. Runners that never start (billing) are not a failure to wait on; local suite + measurers are the evidence.conejo-code/references/stacked-prs-and-ci.md
PR comments one by oneEvery comment gets its own verdict (implement / push back / duplicate-of-#N) and its own in-thread reply; implemented + pushed-back + duplicate-linked == total. The weird nit is the likely hidden gem.conejo-merge Phase 5

Stack preference (house tooling)

AreaUseNever
Package managerspnpm (TS/JS), uv (Python), cargo (Rust)npm, bun, yarn, pip, poetry
TS/JSvite (build), vitest (tests), oxlint (lint), oxfmt (format), Astro (sites), elysia (servers), ESM onlyjest, biome, eslint, prettier
Pythonuv, pyrefly (types), ruff (lint/format), pytest, async-first stackmypy/pyright unless already wired
Rustcargo-nextest (cargo nextest run), clippy, rustfmt, mbx (mr_boxington: mbx setup once, then plain cargo runs through a shared, self-pruning build cache so builds don't explode context or disk)—
Every projectcomplete README.md (what/install/usage/development) with CI/version/license/coverage badges, GitHub topics, tagged semver releases, packages published via OIDC trusted publishing (npm / PyPI / crates.io)long-lived publish tokens

Vendored superpowers skills

15 skills come from obra/superpowers v7.0.2 (22f0b46): brainstorming, diagnosing-superpowers, dispatching-parallel-agents, executing-plans, finishing-a-development-branch, receiving-code-review, requesting-code-review, subagent-driven-development, systematic-debugging, test-driven-development, using-git-worktrees, using-superpowers, verification-before-completion, writing-plans, writing-skills. Upstream text (SKILL.md, scripts, prompts, references) is kept verbatim; local rules live only in the <!-- conejo:start --> … <!-- conejo:end --> block at the end of each SKILL.md and are re-applied by scripts/refresh-superpowers.sh. In this bundle superpowers:<name> references resolve as <name> (or arthrod-skills:<name>).

Sync

./scripts/update-skills.sh                   # publish (default): refresh vendored from upstream,
                                             #   then ./skills/ → ~/.agents (copies) + ~/.claude and
                                             #   every other agent's skills dir (symlinks)
./scripts/update-skills.sh --skip-vendored   # publish, skip the upstream refresh step
./scripts/update-skills.sh --reverse         # subscribe: ~/.claude/skills → ./skills/ (additive)
./scripts/update-skills.sh --reverse --yolo  # subscribe, wipe ./skills/ first
DRY_RUN=1 ./scripts/update-skills.sh         # dry run, no writes anywhere

REF=v7.0.2 ./scripts/refresh-superpowers.sh  # re-vendor the superpowers skills (conejo blocks re-applied)
DRY_RUN=1 ./scripts/refresh-superpowers.sh   # show what a refresh would touch

Install

/plugin marketplace add arthrod/conejo-skills
/plugin install arthrod-skills

Family Map

FamilySkills
PR / code review workflowconejo-merge, conejo-debug, conejo, code-review, receiving-code-review, requesting-code-review
Design (Stitch-first)impeccable, adapt — plus 13 design/UI skills folded under conejo-frontend/refs/ (not separately invocable: layout, ui-ux-pro-max, ux-design-brief, shadcn-parity, stitch-design-taste, refine-distill-frontend, increase-impact-personality-frontend, typeset, colorize, type-mania, tanstack-router, tanstack-router-best-practices, json-render, seo-audit)
Pydantic AIpydantic-acp, pydantic-ai-agent-builder, pydanticai-docs, pydantic-ai-common-pitfalls, pydantic-ai-testing
Better Authbetter-auth, better-auth-best-practices, better-auth-security, better-auth-providers, better-auth-explain-error, better-auth-tauri-setup, better-auth-tauri-pitfalls
Rustrust-author, rust-review
Pi terminal agentpi-using, pi-extending
Testing / QAtesting-strategy, testing-review, browser-test-agent, desktop-test-agent-tauri, dogfood, dogfood-quirks
AI SDKs / Agentsllm-chat-sdks, ag-ui-copilotkit, ag-ui-pydantic, mcp-builder, agent-architecture-analysis, computer-use-agents, orchestrating-swarms, deepagents
ML / GPUml-gpu-training
i18n / Docs / Blog / Releasesi18n-inlang-localization, blog-handoff, blog-writing, adr, changeset
Process discipline (vendored from obra/superpowers v7.0.2 + conejo blocks)diagnosing-superpowers, brainstorming, writing-plans, executing-plans, subagent-driven-development, dispatching-parallel-agents, systematic-debugging, verification-before-completion, test-driven-development, using-superpowers, using-git-worktrees, writing-skills, finishing-a-development-branch
Frontend stacksreact, react-best-practices, react-composables, tailwind-v4, hono
Infra / env / sandbox / Val Townenv-dogma, val-town, agent-sandbox
Legalconejo-legal
Otheradvanced-elicitation, coderlm, draft-docs, major-task, marimo, python-code-review, ralph-prd-generator, review-llm-artifacts, review-plan, review-python, review-rust, sqlalchemy-code-review, sqlite-vec

Full Index

adapt

Adapt designs to work across different screen sizes, devices, contexts, or platforms. Implements breakpoints, fluid layouts, and touch targets. Use when the user mentions responsive design, mobile layouts, breakpoints,…

adr

Architectural Decision Record (ADR) workflow — extract decisions from conversations/transcripts, then format them as MADR documents with Definition of Done (E.C.A.D.R.). Covers the full extract → write pipeline. Trigger…

advanced-elicitation

Use when you want to improve response quality through meta-cognitive reasoning. Applies 15+ reasoning methods to reconsider and refine initial outputs.

ag-ui-copilotkit

Build agentic UIs using AG-UI protocol with Pydantic AI (Python backend) and CopilotKit (React/Next.js frontend). Use when creating AI-powered applications that need bidirectional agent-UI communication, shared state be…

ag-ui-pydantic

Build AI agent UIs using the AG-UI protocol with pydantic-ai (Python backend) and CopilotKit (React frontend). Use when creating agentic chat interfaces, human-in-the-loop workflows, generative UIs with state management…

agent-architecture-analysis

Use when auditing an agent codebase against the 12-Factor Agents methodology, reviewing LLM-powered system architecture, or assessing agentic app compliance. Triggers on "analyze agent architecture", "12-factor audit…

agent-sandbox

Kernel-enforced (landlock) capability-based sandbox for running AI agents and untrusted code via nono — restrict filesystem, block network, inject credentials, take rollback snapshots, audit trails. Use for sandboxing a…

better-auth

Skill for integrating Better Auth - comprehensive TypeScript authentication framework for Cloudflare D1, Next.js, Nuxt, and 15+ frameworks. Use when adding auth, encountering D1 adapter errors, or implementing OAuth/2FA…

better-auth-best-practices

Best-practices guide for Better Auth's most-used features — email/password authentication (verification, password reset, hashing, policies), organization plugin (multi-tenant orgs, teams, RBAC), and two-factor authentic…

better-auth-explain-error

Explain Better Auth error codes and provide solutions with code examples

better-auth-providers

Display Better Auth available authentication providers and their configuration

better-auth-security

This skill provides guidance for implementing security features that span across Better Auth, including rate limiting, CSRF protection, session security, trusted origins, secret management, OAuth security, IP tracking,…

better-auth-tauri-pitfalls

Debugging guide and platform-specific gotchas for @daveyplate/better-auth-tauri. Use when troubleshooting auth failures in Tauri desktop apps, diagnosing 404 callback errors, fixing macOS cookie/deep-link issues, or deb…

better-auth-tauri-setup

Integration guide for @daveyplate/better-auth-tauri - cookie-based auth in Tauri v2 desktop apps via deep links. Use when setting up Better Auth in a Tauri application, configuring social OAuth for desktop, or wiring up…

blog-handoff

Use when a research/development session is ending and the work needs to be captured for a blog post writer. Triggers on "handoff", "blog post", "write up the work", "capture for blog", "document what we did". You MUST p…

blog-writing

Use when writing a technical blog post from a BLOG_HANDOFF.md document. Triggers on "write the blog", "draft the post", "blog from handoff", "turn this into a blog". REQUIRES a handoff document as input — use blog-hando…

brainstorming

You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).

browser-test-agent

Web browser automation & testing for AI agents — agent-browser CLI (Chrome/CDP, fill forms, click, scrape, screenshot, dev-server verification with page-load + console-error + UI-element checks) plus Playwright toolkit…

changeset

Write concise package-release changesets for monorepo publishing — one action verb + one impact statement per bullet, imperative voice, user-impact only. Use when creating a .changeset/*.md for a published package.

code-review

AI-powered code review using CodeRabbit. Default code-review skill. Trigger for any explicit review request AND autonomously when the agent thinks a review is needed (code/PR/quality/security).

coderlm

Primary tool for all code navigation and reading in supported languages (Rust, Python, TypeScript, JavaScript, Go, Java, Scala, SQL). Use instead of Read, Grep, and Glob for finding symbols, reading function implementat…

computer-use-agents

Build AI agents that interact with computers like humans do -

conejo

arthrod's coding philosophy and dispatcher. Universal red-green TDD, acceptance criteria with independent measurers on every task, stacked PRs via gh stack, evidence-before-claims, context-preserving agent dispatch to…

conejo-code

Active coding loop — feature stages (brainstorm→plan→interface→tests→implement→improve→review→loop), red-green TDD execution, acceptance criteria with independent measurers on every task, context-preserving agent dispat…

conejo-debug

Skeptical investigation and autonomous deep work — hunt PRs like crime scenes, interrogate code and CodeRabbit plans, systematic debugging with multi-agent second opinions from OTHER corpora (pi first via pi-help — fa…

conejo-frontend

VERY STRICT frontend gate. Enforces the universal red-green doctrine PLUS the UI superset — agent-browser E2E click-flows (NEVER tRPC to assert UI), 24/7 dev server, test isolation, Astro Framework and Typescript or Rea…

conejo-legal

Research a single US doctrinal legal issue with PR-review discipline and produce a source-audited OKF legal_issue bundle (SKOS digest, source/snippet audit, retained sources), with every run ending merged or closed. Use…

conejo-merge

Main PR-comment handler — calm-implement mode (gate each comment individually, group into tasks, test/install/ship, reply with state changes). Hidden-gems doctrine — different review bots have different training corpora…

deepagents

Deep Agents framework — architectural decisions (when to use Deep Agents vs alternatives, backend strategies, subagent design, middleware approaches) AND code review (bugs, anti-patterns, improvements when reviewing Dee…

desktop-test-agent-tauri

Desktop & Tauri app testing for AI agents — Tauri v2 + WebKitGTK in Docker (AppImage extraction, Gemini Computer Use, virtual display, DOCX export verification) plus Electron app automation (VS Code, Slack, Discord, Fig…

diagnosing-superpowers

Use when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is…

dispatching-parallel-agents

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

dogfood

Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to "dogfood", "QA", "exploratory test", "find issues", "bug hunt", "test this app/site/platform", or review t…

dogfood-quirks

Workarounds for agent-browser version 0.26.0 quirks on Linux (sandbox launch failure, broken --timeout, silent stale refs, find-role syntax). Read BEFORE invoking the /dogfood skill or running any agent-browser command.…

draft-docs

Generate first-draft technical documentation from code analysis

env-dogma

Scorched-earth env/secrets refactor for Vite + Cloudflare Workers + Tauri. Use when consolidating .env sprawl, hardening secrets handling, or auditing env access patterns.

executing-plans

Use when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available

finishing-a-development-branch

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work

hono

Efficiently develop Hono applications using Hono CLI. Supports documentation search, API reference lookup, request testing, and bundle optimization.

i18n-inlang-localization

Everything i18n/localization for apps — inlang projects (setup, plugins, validation), translating app messages (machine translation, missing translations, base locale), and the /translate slash-command workflow. Trigg…

impeccable

Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pag…

llm-chat-sdks

Build LLM-powered chat apps with the right SDK — Anthropic SDK / Claude API (prompt caching, thinking, tool use, batch, files, citations, memory, model migrations) AND Vercel AI SDK (useChat, streamText, tool calls, UIM…

major-task

Work heavyweight framework or library tasks with planning-first research, selective deep analysis, and rigorous handoff

marimo

Everything marimo — writing notebooks (cells, script-mode detection, reactivity), preparing them for scheduled batch runs (Pydantic params, CLI args, WandB), generating anywidget components, and checking WASM/Pyodide co…

mcp-builder

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services,…

ml-gpu-training

Everything GLiNER NER — training-strategy decisions (hyperparam sweeps, LoRA vs full FT, loss/OOM/NaN debugging, eval, WandB tracking) AND remote-GPU ops (launching/monitoring runs on AMD GPU droplets via DigitalOcean,…

orchestrating-swarms

Master multi-agent orchestration using Claude Code's TeammateTool and Task system. Use when coordinating multiple agents, running parallel code reviews, creating pipeline workflows with dependencies, building self-organ…

pi-extending

Building & extending Pi — authoring TypeScript extensions (ExtensionAPI, registerTool, registerProvider, /commands, UI hooks), publishing as npm/git packages (pi-package), embedding via JSON-RPC mode (--mode rpc/json, J…

pi-using

Using the Pi terminal agent — workspace setup, sessions, /commands, compaction, settings.json/AGENTS.md, skill discovery, providers/models, plus theme/keybinding/prompt customization (SYSTEM.md, APPEND_SYSTEM.md, settin…

pydantic-acp

Use pydantic-acp to drive an external ACP CLI agent (crush-acp, cline --acp) as a pydantic-ai model backend — create_acp_model, AcpProvider, delegate host clients (filesystem/terminal/permissions), PromptedOutput struct…

pydantic-ai-agent-builder

Expert guidance for building AI agents with Pydantic AI framework. Use when creating multi-agent systems, AI orchestration workflows, or structured LLM applications with type safety and validation.

pydantic-ai-common-pitfalls

Avoid common mistakes and debug issues in PydanticAI agents. Use when encountering errors, unexpected behavior, or when reviewing agent implementations.

pydantic-ai-testing

Test PydanticAI agents using TestModel, FunctionModel, VCR cassettes, and inline snapshots. Use when writing unit tests, mocking LLM responses, or recording API interactions.

pydanticai-docs

Use this skill whenever the user is working with the Pydantic AI framework — including building AI agents, defining structured outputs with Pydantic models, wiring up tools/function calling, configuring model providers…

python-code-review

Reviews Python code AND pytest test code — type safety, async patterns, error handling, common mistakes, plus pytest setup correctness (test file location, conftest.py wiring, asyncio_mode), fixtures, parametrize, mocki…

ralph-prd-generator

Generates Product Requirements Documents (PRDs) and specifications for Ralph for Claude Code autonomous development. Use when users want to create a PRD, write specifications, plan a new project for Ralph, convert ideas into Ralph-compatible format (PROMPT.md, @fix_plan.md, specs/), or prepare requirements for autonomous AI development loops.

react

React patterns with destructured props, compiler optimization, Effects, and Tailwind v4 syntax. ALWAYS use when using React.

react-best-practices

Use when reading or writing React components (.tsx, .jsx files with React imports).

react-composables

React component architecture for creating composable, accessible components with data attributes. Use when creating/updating composable components, not for higher-level feature/page components.

receiving-code-review

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind…

requesting-code-review

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

review-llm-artifacts

Detects common LLM coding agent artifacts by spawning 4 parallel subagents

review-plan

Review implementation plans for parallelization, TDD, types, libraries, and security before execution

review-python

Comprehensive Python/FastAPI backend code review with optional parallel agents

review-rust

Comprehensive Rust code review with optional parallel agents

rust-author

Authoring & setting up Rust projects — idiomatic Rust (ownership/borrowing/cloning patterns, Result error handling, clippy config, static vs dynamic dispatch, performance, doc tests) plus project scaffolding (Cargo.toml…

rust-review

Comprehensive Rust code review across four lenses — source code (ownership, borrowing, lifetimes, errors, trait design, unsafe, common mistakes), tests (unit, integration, async testing, mocking, property-based), tokio…

sqlalchemy-code-review

Reviews SQLAlchemy code for session management, relationships, N+1 queries, and migration patterns. Use when reviewing SQLAlchemy 2.0 code, checking session lifecycle, relationship() usage, or Alembic migrations.

sqlite-vec

sqlite-vec extension for vector similarity search in SQLite. Use when storing embeddings, performing KNN queries, or building semantic search features. Triggers on sqlite-vec, vec0, MATCH, vec_distance, partition key, f…

subagent-driven-development

Use when executing implementation plans with independent tasks in the current session

systematic-debugging

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

tailwind-v4

Tailwind CSS v4 with CSS-first configuration and design tokens. Use when setting up Tailwind v4, defining theme variables, using OKLCH colors, or configuring dark mode. Triggers on @theme, @tailwindcss/vite, oklch, CSS…

test-driven-development

Use when implementing any feature or bugfix, before writing implementation code

testing-review

Review whole-repo test quality, rerun coverage, score remaining worth-testing files, inspect slow-drift and stale test debt, and publish the next testing batch. Use every few weeks or before large breaking changes and r…

testing-strategy

Enforces dependency isolation, coverage, and test quality standards for Python pytest suites. Use when writing tests, fixing test failures, increasing coverage, or reviewing test quality. Triggers on: write tests, fix t…

using-git-worktrees

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback

using-superpowers

Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions

val-town

Use when building, editing, or deploying code on Val Town - the serverless Deno platform. Triggers on val.town, vals, vt CLI, std/sqlite, std/openai, std/blob, esm.town imports, .http.tsx/.cron.tsx/.email.tsx file namin…

verification-before-completion

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions…

writing-plans

Use when you have a spec or requirements for a multi-step task, before touching code

writing-skills

Use when creating new skills, editing existing skills, or verifying skills work before deployment

License

Original work in this repository is licensed under the MIT License. Vendored and adapted third-party skills keep their upstream licenses; see each skill's frontmatter or folder and THIRD_PARTY_NOTICES.md.