go-mailing-list

Add a Playwright end-to-end test for a user-facing flow — sign-in, form submit, multi-step wizard, payment, navigation, etc. Detects existing Playwright setup and inherits its config (baseURL, projects, fixtures, auth state); installs Playwright via the official `npm init playwright@latest` flow only with explicit user approval. Wires one smoke test that hits the real running dev server before generating the full flow. Prefers role-based selectors (`getByRole`, `getByLabel`) over CSS/test-ids; uses `expect`-with-auto-retry assertions; adds an auth-state fixture for tests that need a logged-in user. Trigger phrases — "add an e2e test", "playwright test", "browser test for X", "test the signup flow", "/add-e2e-test", "end-to-end test". Skip for — pure unit-testable logic (use code-write-tests), API-only flows (use code-write-tests with supertest/fetch), and projects where the user explicitly does not want a browser harness.

Sibling to add-skeleton-loaders. After data fetching is wired in a route or component, verify and auto-fix the two non-loading states most often forgotten — empty (the request succeeded but returned zero items / null) and error (the request failed). Empty states get a clear message + primary call-to-action. Error states get a human-readable message + retry affordance + (in dev) a way to surface the actual error. Uses the project's existing UI primitives — shadcn `<EmptyState />` if present, project conventions otherwise. Does NOT cover loading skeletons. Trigger phrases — "add empty state", "what if this list is empty", "add error state", "handle the error case", "/add-empty-error-states", "error UI", "no results UI", any time a route was just wired with `useQuery` / `useSuspenseQuery` / loader. Skip for — pure static pages, mutations (useMutation has different patterns), modals/dialogs whose empty state is the parent's responsibility.

End-to-end workflow for planning and shipping a new feature in an existing codebase. Phases — clarify → explore → design → mandatory plan-approval gate → implement (subagent fan-out where useful) → verify → gated reviews (code + duplication always; security if backend logic changed; performance if DB/queries changed) → automated tests. Also enforces UI-convention parity: any new instance of a recurring UI surface (modal, dialog, drawer, form) must match sibling conventions for hotkeys, kbd hints, focus, and loading states. Accepts `mode=fast|balanced|production` to control depth (default: production); also accepts `include=<phases>` / `skip=<phases>` overrides. Use when the user asks to add, build, ship, or implement a new feature: "add a feature", "build this", "implement X", "new feature", "plan and build", "ship this". Skip for bug fixes (use fix-bug), pure refactors, enum/state renames (use code-realign), or one-line tweaks.

Scaffold a form in this TanStack Start app following the project's conventions — a single zod schema reused on the client (react-hook-form resolver) AND on the server function (input validation), shadcn `<Form>`/`<FormField>` primitives for the UI, a server function in `src/fn/` that calls a use case or data-access function, a `useMutation` wired to that server fn with optimistic / pending UI, and proper success / error handling that integrates with the route's invalidations. Detects whether the project uses react-hook-form (default in shadcn setups) or TanStack Form, and follows whichever is already in use. Trigger phrases — "add a form", "create form for X", "/add-form", "new form", "form to create/edit X", "form for the new entity", "scaffold a form". Skip for — pure read-only views, search inputs that are not form submissions (use a controlled input directly), and forms whose validation is so trivial the schema-on-both-sides pattern is overkill (single field with no rules).

After a bug fix lands (or is staged), generate a regression test that fails on the pre-fix code and passes on the post-fix code — pinning the bug so it can't silently return. Walks the agent through reproducing the failure first (against the pre-fix state via `git stash` or temporary revert), writing the assertion that captures it, then verifying the test goes red without the fix and green with it. Trigger phrases — "add a regression test", "pin this bug", "write a test for the fix", "/add-regression-test", "lock in this bug fix", "make sure this doesn't come back", or invoke automatically after a /fix-bug session that produced a code fix. Skip for — fixes whose behavior change is already covered by existing passing tests, pure refactors with no behavior delta, fixes to test code itself, and unreproducible heisenbugs.

Generate a developer seed-data script for a feature — creates representative rows through the data-access layer (not raw SQL) so the seed respects schema, foreign keys, and any business invariants encoded in DA functions. Detects an existing `scripts/seed.ts` (or the project's convention) and extends it; if none exists, creates one and wires a `seed` script in `package.json`. Defaults to idempotent inserts (upsert by natural key, or wipe-then-insert behind a flag) so re-running doesn't double-create. Trigger phrases — "seed data for X", "add fixtures", "/add-seed-data", "demo data", "create some sample posts", "fill the dev DB", "seed the database with users". Skip for — production data, test fixtures (those live in test files, not the seed), and one-off scripts the user runs manually (use a dedicated migration or admin script).

Verify that any new TanStack Start route — or any new data-fetching section added to an existing route — renders shadcn `<Skeleton />` placeholders matching the eventual layout while data is in flight. Auto-fix gaps inline before reporting done. Trigger phrases and scenarios — creating a file in `src/routes/`, adding `useSuspenseQuery`/`useQuery`/route `loader` to a page, "new route", "new page", "add a page", "loading state", "skeleton", "Suspense fallback", "pendingComponent", any route showing a spinner / "Loading..." / blank space while fetching. Skip for: routes with no async data (pure static pages), pure backend changes, copy-only edits, mutation-only buttons (use a different loading pattern), modals/dialogs that fetch (skeleton inside the modal body still applies, but route-level rules don't).

Address every unresolved review comment on a GitHub pull request — locate the PR (current branch, PR URL, PR number, or issue number with linked PR), fetch both inline review comments and PR-level issue comments, then for each thread ground the fix in the branch's commits and diff, edit the code, make ONE commit per comment, reply to the thread, and resolve it. Trigger phrases — "address PR comments", "address review comments", "fix review feedback", "respond to PR review", "/address-pr-comments", "address the comments on PR

Initialize or refresh a project for the AgentSystem plugin system by writing a concise table-of-contents of available AgentSystem skills into the project's agent-instruction file (CLAUDE.md and/or AGENTS.md). The TOC lists each skill's invoke command and one-line "when to use" so future LLM sessions route to the right skill faster. Idempotent — re-run anytime to pick up new skills. Trigger phrases — "init agentsystem", "agentsystem init", "set up agentsystem in this project", "add agentsystem TOC", "refresh skill index", "/agentsystem-init", "list agentsystem skills in CLAUDE.md", "make this project agentsystem-aware". Skip for projects that aren't using the AgentSystem plugin system.

Static accessibility audit of a route/component — checks keyboard reachability, screen-reader semantics (ARIA labels, label/input association, roles), and WCAG AA color contrast. Auto-fixes the mechanical gaps inline (icon-button labels, image alt, label htmlFor, div-as-button → button, missing role/aria-*); reports structural ones (focus traps, tab-order rewrites, contrast token swaps that need design input). Pure file reads + grep, no axe-core or browser. Trigger phrases — "a11y audit", "accessibility audit", "screen reader check", "keyboard accessibility", "WCAG", "aria check", "/audit-a11y", "is this accessible", "audit this page for a11y", "tab order", "contrast check". Skip for — pure backend/server changes, copy-only edits, CSS tokens-only changes with no UI affected, and audits requiring real browser/axe-core (recommend Playwright + axe instead).

Audit analytics event tracking across a route, feature, or the whole client surface — verifies that important user actions emit events, that event names match the project's existing taxonomy (snake_case vs camelCase, prefix conventions, verb tense), that property names are consistent across siblings, and that no PII (emails, raw user IDs in some setups, secrets) is being shipped in event properties. Detects the project's analytics SDK (PostHog, Amplitude, Segment, Mixpanel, GA4, custom wrapper) by import; uses the project's existing event catalog as the convention source if one exists. Reports gaps and inconsistencies; never invents events. Trigger phrases — "audit analytics", "check event tracking", "/audit-analytics", "are we tracking X", "missing events on this page", "event taxonomy", "are events consistent", "PII in analytics". Skip for — projects with no analytics SDK installed, server-only analytics (different concerns; out of scope here), and one-off internal admin pages explicitly excluded from track

Static performance audit of a route, page, server function, or module — finds N+1 query patterns, missing DB indexes for filtered/joined columns, oversized SELECT * fetches, blocking sequential awaits that could parallelize, unmemoized React hot-path computations, oversized client bundles from accidental server-only imports leaking to the client, and synchronous file/network reads inside request handlers. Reads files; does not run benchmarks. Reports findings ranked by likely impact with concrete fixes (add index on X, batch with dataloader, Promise.all these awaits, dynamic-import this dep, move this to the loader). Trigger phrases — "audit perf", "this page is slow", "why is this slow", "/audit-perf", "perf review", "find n+1", "check for performance issues", "audit query performance", "bundle size audit". Skip for — single-line tweaks, copy edits, infra-level perf (DB tuning, k8s sizing), and runtime profiling needs (recommend a real profiler).

Per-route SEO and social-share metadata audit — checks `<title>`, meta description, canonical URL, Open Graph tags (og:title, og:description, og:image, og:url, og:type), Twitter card tags, viewport, robots directives, and the presence of a sitemap and robots.txt. For TanStack Start, reads route `head()` exports; for Next.js, reads `metadata` / `generateMetadata`; for plain HTML, reads `<head>`. Reports per-route findings with severity, plus repo-level findings (missing sitemap, no robots.txt, missing default OG image asset). Auto-fixes only the trivial defaults (boilerplate viewport meta, repo-level sitemap stub) with explicit user approval; route-specific copy is reported, never invented. Trigger phrases — "seo audit", "audit meta tags", "check og tags", "social share preview", "/audit-seo-meta", "missing meta description", "fix sharing preview", "twitter card", "canonical url". Skip for — apps that are intentionally non-public (auth-walled SaaS dashboards), purely internal tools, and pages explicitly marked

Whole-codebase tech-debt sweep. Orchestrates every available code-* audit/cleanup skill (duplication, type safety, data integrity, security, contracts, error boundaries, loading states, a11y, concurrency, client-bundle, observability, perf, simplify) across the repo — not just the diff — to find and remove accumulated tech-debt. Produces one consolidated, severity-ranked findings report, then applies mechanical fixes inline and gates structural fixes per-item. Use when the user says "audit the codebase", "tech-debt sweep", "deep clean", "/audit", "find all the rot", "production-readiness pass", "full cleanup", or when ship routes here for a production-grade hardening pass. Skip for — focused diff-only reviews (use code-simplify), single-concern audits (call the specific code-check-* skill directly), and any context where the user only wants a quick fix.

Bootstrap an empty directory into a runnable project from the AgentSystemLabs/launch-kit template — clones the template, strips its git history, runs setup (env file, install, docker compose), launches the dev server, and diagnoses missing prerequisites (Node, Docker, Docker Compose, git, package manager) with OS-specific install hints. Use when the user says "init launch-kit", "/bootstrap-project", "start a new launch-kit project", "scaffold launch-kit here", "set up launch-kit", "new project from launch-kit", or runs Claude in an empty directory and asks to spin up the AgentSystemLabs starter. Skip for: existing projects with code already present (refuse or require explicit override), templates other than AgentSystemLabs/launch-kit, or pure prereq install (use the OS package manager directly).

Pre-PR gauntlet — run the project's typecheck, linter, formatter, and test suite against the branch's diff vs. the base, plus a residue sweep for `console.log`, `.only` / `.skip`, debugger statements, leftover TODOs in changed files, dropped lockfiles, and unintended large/binary additions. Reports each gate's pass/fail with the exact reproduction command. Auto-fixes only the format-and-lint-fix gate when it has a known auto-fix; everything else is reported, never silently fixed. Trigger phrases — "pre-pr check", "ready to PR?", "is this PRable", "pre-flight this branch", "gauntlet", "/check-pr-readiness", "lint+test+types before PR". Skip for — branches with no commits beyond base, doc-only or comment-only diffs (still useful but optional), repos with no CI conventions to enforce.

Generate and review a Drizzle (or Prisma / Knex / raw SQL) migration safely — classifies the change as additive, mutating, or destructive; for mutating/destructive changes, splits into a multi-phase plan (deploy code that tolerates both shapes → migrate → deploy code that requires the new shape). Catches the landmines: NOT NULL on a populated column without backfill, dropping a column still referenced by old code, adding a unique constraint with existing duplicates, large-table index without `CONCURRENTLY`, type changes that rewrite the table, default values evaluated at migration time vs. row time. Trigger phrases — "add a migration", "schema change", "add column to X", "drop column X", "rename column", "add index", "/code-add-migration", "drizzle migration", "alter table". Skip for — pure code changes with no schema impact, seed-data-only changes (use add-seed-data), and infra-level changes (DB version upgrades, replication setup).

Internal handoff target invoked by add-feature, modify-feature, and tweak-ui after UI mutation. Scoped, changed-files-only accessibility audit — a faster sibling to `audit-a11y` that runs automatically without producing whole-app noise. Catches icon buttons missing accessible names, dialogs missing focus trap or initial focus, custom clickable `<div>`s where a `<button>` belongs, form errors not associated with their fields (`aria-describedby` missing), broken keyboard paths (no `:focus-visible` on a custom interactive element). Reports findings ranked by severity; auto-fixes only mechanical issues (`aria-label` on icon button, `htmlFor` on label, `<div onClick>` → `<button>` when no other interactive nesting). Trigger phrases for routing: "a11y check", "accessibility regression", "did this break a11y", "audit a11y in changes". Skip for backend-only changes, doc/comment-only changes, test-fixture-only edits.

Internal handoff target invoked by add-feature, modify-feature, and code-enforce-layers when client-side code changes. Audits accidental client-bundle bloat and server-only leakage — server libraries (drizzle, prisma, fs, child_process, postmark, stripe-node, server-only env) imported into a client route or component, large dependencies added to the first-load bundle (lodash, moment, draft-js, monaco, recharts), images or videos shipped unoptimized (PNG/JPG > 200KB without responsive variants), env or server config reaching the browser bundle, and rarely-used editor/chart/admin code that should be dynamically imported. Reports findings ranked by severity; auto-fixes only mechanical issues (lodash-es full-import → named import). Trigger phrases for routing: "check bundle", "audit client bundle", "any server import in client", "did this bloat the bundle". Skip for pure backend/migration changes, doc/comment-only edits.

Internal handoff target invoked by add-feature, modify-feature, and fix-bug after mutations, background jobs, or webhook handlers change. Audits race conditions, retry-safety, and idempotency — double-click creating duplicate records (no submit lock, no idempotency key), webhook retry processing twice (no dedupe by event id), background job that's not idempotent, read-modify-write paths that race under parallel requests (no row lock or atomic update), multi-step writes missing a transaction, stale async response overwriting newer client state (no request-id guard or `AbortController`). Reports findings ranked by severity; auto-fixes only mechanical issues (add `AbortController` to a `useEffect` fetch). Trigger phrases for routing: "check for races", "is this idempotent", "audit concurrency", "check transaction boundary", "any double-submit risk", "check webhook idempotency". Skip for read-only changes, UI-only edits, doc/comment-only changes.

Internal handoff target invoked by add-feature, modify-feature, and fix-bug after changes that cross the client/server boundary. Audits API/route/schema contracts for drift the type system can't catch — frontend reads field `x` while backend now returns `y`, route param renamed but `<Link>`/loader/form callers still use the old shape, zod schema diverged from DB schema or returned DTO, OpenAPI/tRPC/server-fn/generated client callers drift from implementation. Reports findings ranked by severity; auto-fixes only mechanical mismatches (renamed field reference, stale param name) and reports structural ones. Trigger phrases for routing: "check contracts", "any contract drift", "verify shapes match", "audit API contracts", "check route params", "check schema/DTO match". Skip for comment/format-only changes, doc-only edits, non-TS files.

Internal handoff target invoked by add-feature, modify-feature, code-add-migration, and code-realign whenever a change touches migrations, schema, persistence, imports, deletes, or background jobs. Audits data-integrity risks the type system can't catch — NOT NULL columns added without backfill or default, delete paths that orphan rows/files/cache/external resources, uniqueness assumptions not enforced by DB constraints, migrations unsafe for existing production data, seed and test data no longer matching the schema. Reports findings ranked by severity; auto-fixes only mechanical issues (missing default on a clearly-nullable add, stale seed field after rename) and reports structural ones. Trigger phrases for routing: "check data integrity", "is this migration safe", "any orphaned rows", "data audit", "check delete cascade", "verify backfill", "check uniqueness". Skip for read-only changes, UI-only edits, doc/comment-only changes.

Internal handoff target invoked by add-feature, modify-feature, code-realign, and other mutation skills as a post-step audit of recently-edited TypeScript/TSX files. Detects parallel-enum drift the type system can't catch — parallel-array drift, repeated literal-equality filters, scattered enum literals, per-variant if-chains, sibling JSX blocks differing only by a literal prop. Reports findings ranked by severity; does NOT auto-fix. Trigger phrases for routing: "check for duplication", "any similar issues", "look for parallel patterns", "scan for drift", "audit enum usage", "find drift", "any other places like this". Skip for single-line fixes, comment/format-only changes, test-fixture edits, non-TS files.

Internal handoff target invoked by add-feature, modify-feature, and fix-bug after a feature lands to audit failure paths. Catches the failure-mode gaps that produce blank screens and silent corruption — promise rejections that leak to a blank screen (no `errorComponent`/error boundary), server errors that become a generic toast with no retry, form submits that double-submit on failure (button re-enabled before retry-safe), TanStack route loaders without `errorComponent`, background failures with no user-visible recovery or durable record. Reports findings ranked by severity; auto-fixes only mechanical issues (disable button when `isPending`, add missing `errorComponent` stub matching project convention). Trigger phrases for routing: "check error handling", "any failure paths missing", "audit error boundaries", "what happens on failure", "check error UX". Skip for pure backend changes that don't add user-facing flows, doc/comment-only changes.

Internal handoff target invoked by add-feature and modify-feature after async UI changes. Audits async-state UX consistency complementary to add-skeleton-loaders (which adds skeletons for new routes) and add-empty-error-states (which covers empty/error). Catches submit buttons not disabled while submitting, spinner used where sibling flows use skeletons, optimistic updates missing rollback on error, missing route pendingComponent, inconsistent empty/loading/error treatment across siblings. Reports findings ranked by severity; auto-fixes only mechanical issues (add `disabled={isPending}` to a submit button, add `aria-busy` to a clear async region). Trigger phrases for routing: "check loading states", "audit async UX", "any pending state missing", "check submit lockout", "check optimistic rollback". Skip for backend-only changes, doc/comment-only changes, test-fixture-only edits.

Internal handoff target invoked by add-feature, modify-feature, and fix-bug after critical-path changes. Read-only audit of observability coverage — sibling to `code-add-observability` (which inserts logs); this skill REPORTS gaps without auto-instrumenting. Catches new critical paths with no structured log, errors swallowed without context (bare `catch {}` or logged without the original error), jobs/webhooks lacking a correlation id propagated through the work, missing latency/failure metrics on a hot endpoint, and PII (emails, raw user content, tokens) included in log lines. Reports findings ranked by severity; does NOT auto-fix. Trigger phrases for routing: "check observability", "any logging gaps", "coverage audit", "audit logs", "any PII in logs". Skip for UI-only changes that don't touch async/error paths, doc/comment-only edits.

Final pre-publish handoff invoked by commit-push-and-make-pr, commit-and-push, open-pr, and release skills. Summarizes what changed on the branch and what could break in production — public API surface changes, persistence shape changes, auth/payment/permission changes, new env vars or operational setup, manual-QA-needed paths, doc/changelog/migration-notes deltas, and rollback concerns. Reads git log + diff vs. the base branch; categorizes each change by risk; produces a concise risk briefing the user reads BEFORE pushing or opening a PR. Does NOT block — informs. Trigger phrases for routing: "release risk", "what could break", "pre-publish check", "ship summary", "what's risky in this branch", "check before push". Skip for branches with zero diff vs. base, doc-only branches, comment-only branches.

Internal handoff target invoked by fix-bug when a failure crosses process or runtime boundaries — Electron vs Node, browser vs server, dev server vs packaged app, worker vs main thread, CLI vs app runtime, native modules, ABI mismatch, preload script, IPC boundary, SSR vs client bundle, electron-rebuild, postinstall, or NODE_MODULE_VERSION errors. Traces which process actually loads the failing code before changing libraries, scripts, or rebuild commands. Trigger phrases for routing: "NODE_MODULE_VERSION", "electron-rebuild", "preload", "main vs renderer", "ABI mismatch", "native module not found", "works in dev fails packaged".

Internal handoff target invoked by add-feature, modify-feature, and other mutation skills when working in TanStack Start projects to enforce the layered architecture — routes/components/hooks/queries call server functions in `src/fn/`, which call use cases or data access; only `src/data-access/` touches Drizzle/the database. Activates whenever a feature crosses the client→server→DB boundary or when files are created in `src/routes/`, `src/components/`, `src/hooks/`, `src/queries/`, `src/fn/`, `src/use-cases/`, or `src/data-access/`. Trigger phrases for routing: "where does this go", "create endpoint", "new server function", "fetch data", "save to database".

Tighten TypeScript safety in changed files — strip `any`, dangerous `as` casts, `@ts-ignore`/`@ts-expect-error`, and missing return types on exported APIs; add zod (or existing project validator) at boundary surfaces (HTTP/server-fn input, IPC, queue handlers, webhook bodies, env parsing). Auto-fixes the mechanical occurrences inline; reports structural ones that need domain modeling. Trigger phrases — "harden types", "tighten types", "remove anys", "strip ts-ignore", "add zod validation", "validate this input", "audit type safety", "/code-harden-types". Skip for — pure JS files, generated code (drizzle/openapi/graphql codegen output), test fixtures where `as any` is intentional wiring, and discriminated-union narrowing the compiler can't infer.

Internal handoff target invoked by add-feature, modify-feature, or fix-bug when they detect a domain-model rename — an enum/state/vocabulary change with persisted values that requires a tracked data migration. Users typically don't invoke this directly; the front-door skill routes here once the work is identified as a realignment (changes meaning) rather than a refactor (preserves behavior) or cleanup (no requirement change). Trigger phrases for routing: "rename this status", "these states don't match how it actually works", "the model is out of sync", "enum migration", "state machine rename", "domain model update", removing a dead enum value, adding a new lifecycle state, renaming a persisted enum. Skip for behavior-preserving structural changes (refactor) or stylistic tidying (cleanup).

Internal handoff target invoked as a post-step by add-feature, modify-feature, fix-bug, fix-pr-tests, address-pr-comments, remove-feature, code-realign, and reorganize-files to clean up freshly-changed code. Reviews the git diff for DRY violations, duplicate code, oversized files/functions/components, magic numbers, poor naming, tight coupling, missed reuse of existing utilities, and inefficient patterns; refactors in place without breaking behavior. Writes a safety-net test first when the refactor risks behavior change. Default scope is changed files; expands to siblings only when a flagged smell points there. Trigger phrases for routing: "simplify", "clean this up", "DRY this", "find code smells", "any duplication", "split this up". Skip for type-only edits, pure formatting, generated files, and changes the user has explicitly scoped to "no refactor".

Internal handoff target invoked as Phase 8 of add-feature and as the test step for modify-feature and code-realign — and any time a feature lands without a test step. Stack-agnostic phased workflow for adding or expanding an automated test suite for a chosen module. Detects existing test harness (Vitest/Jest/Playwright/pytest/go test/cargo test/RSpec/JUnit) via config files, lockfile, and scripts; if absent, proposes the smallest industry-standard runner for the stack and waits for user approval before installing. Wires ONE smoke test that must pass before generating the rest, inherits naming/mocking conventions from existing tests, and defaults to a real test DB with mocks only at third-party API boundaries. Trigger phrases for routing: "write tests", "add tests for X", "expand the test suite", "cover this with tests". Skip for pure type-only refactors with no behavior change, single-line copy edits, generated files, and projects where the user explicitly says "no tests".

Run the agentsystem-core commit skill to produce grouped commits from the working tree, then push the current branch to its remote (setting upstream with -u when missing). No-op when there is nothing to commit. Never force-pushes. Use when the user says "commit and push", "/commit-and-push", "commit then push", "push these changes", or asks to commit work and publish it to the remote in one step. Skip for: amend/fixup workflows, pushes without a fresh commit (use `git push` directly), force-push requests, when the user has already committed and only wants to push, or when the user wants the full engineering pipeline (use `/ship` for plan → implement → test → review).

One-shot "commits + branch push + PR" workflow — split a dirty working tree into logically grouped commits, create/push the branch if needed, and open a GitHub pull request with a senior-engineer-quality title, high-level (non-technical) description, auto-applied labels matched against the repo's existing label set, and "might address

One-shot ship workflow on `main` — delegate to the `commit-and-push` skill (group commits, push branch), then delegate to the `release` skill with a default minor version bump, then push the new tag to origin. Use when the user says "commit push and release", "/commit-push-and-release", "ship and release", "commit then release", or wants to publish working-tree changes AND cut a versioned release in a single step. Aborts on a clean working tree (nothing to commit) and aborts when the current branch is not `main`. Skip for: feature-branch work (releases here only cut from `main`), commit-only or release-only flows (use `commit-and-push` or `release` directly), major/patch bumps requested without arg (default is minor — pass an explicit arg or invoke `release` directly), and amend/force-push workflows.

Split a working tree with many changed files into multiple logically-grouped commits instead of one mega-commit. Groups files by relatedness (shared module, feature slice, layer, test+impl pairs, rename+edit pairs) and orders commits so each one builds on its own (schema → backend → frontend; deps before consumers). Use when the user says "commit these changes", "make multiple commits", "split this into commits", "clean commit history", "commit by feature", "commit in groups", "/commit", "stack these commits", "don't make one big commit", or when `git status` shows many unrelated files staged for one commit. Skip for: single-file changes, commits the user has already staged with `git add`, or when the user explicitly asks for one commit.

Create a GitHub issue from a short user description, auto-classify it with type + area + priority labels, ensure those labels exist in the repo (creating any that are missing with consistent colors), then create the issue via `gh issue create` and print the URL. Trigger phrases — "create an issue", "open a github issue", "file a bug", "log this as an issue", "/create-issue", "make a ticket for this", "track this in github". Skip for — PRs (use open-pr), commenting on existing issues (use `gh issue comment`), non-GitHub trackers (Linear, Jira).

Spin up an isolated git worktree at `.worktrees/<branch>/` with auto-allocated UI/API/DB ports, a generated `.env`, installed deps, a per-worktree Postgres container, and migrations applied — so multiple branches run side-by-side without colliding on ports or databases. On first ever run in a repo, refactors hardcoded port literals to env-driven config (with approval) before creating the first worktree. Trigger phrases — "new worktree", "create a worktree", "spin up a worktree", "parallel branch", "work on two branches at once", "/create-worktree". Skip for — non-Node projects without docker-compose, bare `git worktree add` requests where the user explicitly does not want extra setup, monorepos with multiple apps (this skill assumes one app per repo), and Windows hosts (port range and `docker compose` invocation assume macOS/Linux).

React-specific silent-failure patterns the generic fix-bug skill won't catch — closure side-effects inside `setState` updaters, stale `useCallback([])` closures, `useEffect` dep array bugs, StrictMode double-invocation surprises, and focus/DOM races during unmount. Use as a routed sub-skill from fix-bug when the bug is in a React app and the failure is in the state-management layer (visible state changes "partially correct" — one paired update lands but a sibling side effect doesn't fire). Run when the user says "/debug-react", routes to this skill explicitly, or when fix-bug's trace lands at a `useState`/`useReducer`/context store. Skip for crashes with a stack trace or pure render-output bugs — those have their own evidence.