Autodev Core

SEO audit — verify metadata, structured data, and crawlability against a pre-launch checklist, and validate the JSON-LD actually parses.

Accessibility audit against WCAG 2.1 AA — run the automated scan, then the manual checks tooling cannot make, and report in this project's format.

Autonomous task execution with testing and security. Works through all tasks without stopping.

The prd.json schema and task system used by every autodev workflow. Load before reading or writing prd.json, creating stories, or interpreting a task's passes field.

Sweep every repo you are working on for vulnerabilities an attacker can actually reach, prove each one is reachable, and fix the ones that survive. One word starts the whole operation.

Web performance audit against this project's Core Web Vitals and bundle budgets, with a fixed report format.

Live site QA in a real browser. Scans pages for visual, console, accessibility, and performance regressions, and compares against baselines. Use when testing a running site or after deploying.

Pre-deploy checklist with review, security, and test verification. Use when ready to deploy.

Turns a one-line product idea into a spec, a data model and a prd.json backlog, so setup-project and auto can run without a manual planning hop. Use when the user describes something to build rather than a change to make.

Runs unit and browser tests on latest changes. Use after implementing features or fixing bugs.

Parallel quality audit across specialized agents. Finds bugs, violations, and quality issues. Use audit for fixes, brainstorm for features.

Boot the fleet overseer from files with full context — role, registries, live fleet state, open work — in one command. Use when starting a fresh Brain session after a restart, a quota wall, or an account switch.

Shows every Claude Code session on this machine and which ones are blocked on an unanswered question. Use when asked what other sessions are doing, which are waiting, or to open the fleet board.

Name the phase of app-building you are in and get the two or three sentences that matter for it, plus the skills that already exist for that phase. Use at the start of a phase, or when work has drifted and it is unclear which phase it is in.

Capture the BEFORE state while the defect still reproduces, then the AFTER state once the change works, and put both where a human reviewer sees them. Use at the start of any fix, before the first edit, and again once it works. Also when a reviewer would have to take your word for a change.

Standardized git commit, push, and PR creation workflow.

Creates distinctive UI with preserved structure. Avoids generic AI aesthetics. Use when designing or refining user interfaces.

Review changed code for correctness and quality, then apply the project-specific checks Claude Code's built-in reviewer does not know about.

Creates or advances sprints in prd.json. Use when starting new work cycles or closing completed sprints.

Shows sprint progress and task status. Use 'progress' (not 'status' - that's a built-in).

Work is blocked on something only the user can do: choosing a browser or account, clicking a dashboard toggle, entering a credential, approving a grant, plugging in a device. Load the moment an error names a human decision, before retrying it.

Start work in a fresh git worktree branched from the remote default branch, so parallel agents never share a tree. Use before the first edit of any feature, fix or task, and whenever a repo has more than one session working in it.

Convergence loop — brainstorm, fix, re-scan until the codebase is clean. Combines brainstorm→apply→auto in one command.

Dependency updates, major version upgrades, and breaking change resolution. Use when updating packages or handling deprecations.

Stress-test a plan or decision BEFORE building it. Use when the user says grill me, poke holes in this, stress-test this, or what am I missing, and before executing any plan whose premise nobody has attacked.

Code refactoring patterns - extract, split, restructure without changing behavior.

Pre-deploy security check. Runs Claude Code's built-in security review, then the stack-specific scans it does not cover — Supabase RLS, migration secrets, and cloud key hygiene.

Sweep Claude Code Desktop sessions — classify which are finished, check their worktrees are safe to discard, write resume stubs, and archive the safe ones. Use for "archive finished sessions", "session cleanup", "how many sessions do I have open".

Scaffold and grow a project's executable gate file — the checks that run before every deploy and fail the build on the bug families this project actually ships.

The conventions this project holds code to — UI state completeness, design tokens, type-safety boundaries, query-key shape, and the anti-patterns to flag on sight.

Show tool-usage stats from the local telemetry log — which tools a session burns context on, which days were busy, what failed. Use for "tool stats", "what did I spend context on", "which tools am I using most".

Coordinate the fleet while the user is away: survey every repo from git, propose per-repo work grounded in that survey, get one approval, then message the sessions that exist and spawn task chips for repos with none. Never work a repo yourself. Use when asked to run the team overnight or unattended.

Feature ideation, dead code cleanup, and product thinking. Proposes new features and architecture improvements — not bugs or violations (use audit for those).

Archives completed stories from prd.json to reduce token usage.

Derive this project's actual conventions from its code and write them into a project-local rules file, so autodev enforces what this codebase already decided instead of a generic default.

Windows-specific development rules: cmd /c wrappers for MCP, dev servers in an external terminal, path conventions, and the Supabase CLI firewall workaround. Load only when working on Windows.

Scaffolds new projects or onboards existing ones. Detects stack, creates monorepo/single-app, configures strict tooling. Use for greenfield or first-time setup.

A wrong fix costs one cycle; a wrong diagnosis costs every cycle until someone questions the premise. Reproduce before explaining, suspect the frame before inventing a mechanism, and attribute a failure before repairing it. Load before proposing any cause, fix, or explanation.

Keep a reviewable decision trail for work nobody is watching: an unattended or scheduled run, a multi-phase build, a fleet of agents, or anything a human will review after stepping away. Use when starting such work, or when asked to show your work.

Research coding agents, agent SDKs, orchestration frameworks, harnesses, protocols, evaluations and relevant videos, then execute every selected hypothesis against the current repository. Use when asked what is new, what agent practices are worth testing, or to run the framework radar.

Research current marketing-platform changes and practitioner videos, extract claims with incentives and boundary conditions, then safely execute every selected hypothesis. Use for recurring marketing research, campaign or funnel ideas, and supplied marketing videos.

Every proposal gets measured against the current approach and at least one variant before it is adopted, and the measurement is reported. Load before recommending a change, writing a detector, or claiming something is cheap, fast, or better.

Run a cross-vendor tests-first review loop: an adversary model authors failing acceptance tests, the building agent fixes against them, and bounded review rounds end on an exact verdict token. Use for changes where a wrong fix is expensive — gates, harnesses, security paths, anything that grades other code.

Rank the failure classes this project actually ships by mining its own fix commits, then propose executable gates for the top ones. Use when the same kind of bug keeps reaching manual QA.

Read the production signals a repo already emits — error tables, Sentry issues, cron heartbeats, failed deployments — and turn the ones that cross a threshold into candidate prd.json stories with the evidence attached. Use when asked what production is saying, whether errors or dead monitors should be in the backlog, or to run the production radar.

Verification happens on this machine, in a browser you drive, before anything is pushed. Covers the local gate, the batched publish cadence, why GitHub Actions is not the gate, and why a restored browser session fakes a pass. Load before verifying, before pushing, and before any visual check.

A record's size is not its payload's size. An enum is as large as its biggest variant, a growable container carries capacity it will never use, and padding is invisible in the source. Multiplied by a million rows that is real memory. Load before defining a struct, enum or cache entry that will exist in bulk.

Interface design starts from where the hand is and what each element MEANS, not from a palette. Reach zones, progressive density, and the rule that unearned signal destroys real signal. Load before designing a screen, choosing a theme, or adding colour, motion, or output.

The house shell for any HTML report, audit, or findings page an agent publishes: summary-first cards that expand on click with staggered detail, themed scrollbars, and a token system that survives both themes. Load before writing or editing an HTML page a person will read.

What counts as done for each kind of change: the required verification per task type, and the six cross-cutting checks that apply to every task. Load before marking any task complete.

Design-token rules: semantic tokens over inline colors, where tokens are defined, and the one case hardcoded colors are allowed. Load before writing or editing component styles.

The eight ways a change passes typecheck, build, and a clean console and is still wrong. Derived from 3,127 fix commits across three production repos. Load before implementing a feature and again before calling it done.

Writing a document another agent will execute: a SKILL.md, a CLAUDE.md or AGENTS.md line, a subagent brief, a scheduled-task prompt, a doc reached by a pointer. Use when creating or editing any of those.

Ways a gate or test proves nothing while looking decisive: grading a copy of itself, passing on emptiness, a canary firing for the wrong reason, a summary read as a verdict, a probe pointed at the wrong invocation. Load before writing a gate, a mutation harness, or any check guarding generated output.

The order the other skills run in. Four steps: isolate, build, prove, ship. Each carries the condition that ends it. Load before starting any feature, fix or task, and whenever you are about to pick a skill and cannot tell which one comes first.

How to end a turn: a clickable AskUserQuestion panel of vetted, complementary options with a recommendation in every block.

How many agents to spawn, at which model and effort, so a fan-out does not burn the session's limits. Load before spawning subagents, running a workflow, or dispatching background sessions.

Where generated files belong. Archives, backups, handoffs, reports, and screenshots go under .claude/, never the project root. Load before writing any generated artifact.