Claude Code Config

Plan a non-trivial feature by interviewing to resolve unknowns, then studding every function as a runnable walking-skeleton (fake data, real wiring) so names, placement and contracts can be reviewed before any real logic is written. Stops for review; fill is a separate pass.

Land an approved PR: merge to main, delete the branch, tag the version, sync the roadmap, clean up

Adversarial review of a document written as the colleague trying to kill it, aimed at one or two named readers

Update a PR description to account for commits made since it was last written

Produce a demo GIF/MP4: VHS tape for CLI tools, shot-scraper storyboard for web flows, Playwright recording when the storyboard vocabulary can't express the flow; engine chosen from what the demo must show

Generate a commit message. If nothing staged, stage all changes.

Create or update a README for the project root or any directory

Adversarial review of a branch diff written as the colleague trying to get it rejected, aimed at one or two named readers

Split uncommitted changes into granular commits.

Show the profiles stored in the dossier and persona stores

Check the current branch name against convention (type/short-description) and rename it if it drifted.

Build or update the changelog from conventional commits and project it to every surface the project uses

Summarise what the user can now see or do that they couldn't before this unit of work

Map every worktree in this repo in plain language and shepherd safe create/remove actions

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.

Create, update, extend, print or display a project theme family: a core palette plus per-target files (html, vhs, freeze, card, frame, ghostty, tui) that every asset and artefact skill reads deterministically

Silently log friction with Claude Code itself (bugs, missing features, annoying limitations) for hud-cc_releases to check against future fixes

Render verified findings as an actionable, status-grouped HTML artefact.

Render a visual HTML introduction to this codebase for a newly-joined developer

Record a durable fact about a person Jason works with, in their own dossier file

Autonomously run the full delivery loop for the next roadmap task: suggest, worktree, implement, roadmap-sync, PR, self-review. Pass 'loop [N]' to repeat for up to N ready tasks

Create a project roadmap in the rich phase-array format: roadmaps.json as source of truth plus a PHASE task list and prose overview

Interview-led review of the roadmap: strategic health (freshness, priorities, milestone integrity) and dependency-graph rationality, in one pass or by lens

Anti-scope-creep. Forces the question: what is the smallest thing that delivers value?

Summarise Claude Code's own CHANGELOG.md, filtered and grouped for what actually matters to Jason

Show every currently unblocked roadmap task, grouped by milestone or topic

Convert an old simple-style roadmap (single Markdown, four statuses, <a name> anchors, roadmaps.json pointer registry) into the rich phase-array format (roadmaps.json source of truth + PHASE task list + prose overview).

Generate the HTML roadmap dashboard deterministically via roadmap.py render.

Integrate a target branch into the current one by merge, rebase or squash

Assess branch readiness for PR submission: full review methodology plus the checks only a local checkout allows

Passive ethical review: manipulation, accessibility, privacy, sustainability in user-facing features.

Work through a PR's change requests: verify each independently, fix what holds up, reply to every thread

Sync roadmap statuses after work lands: recompute from the dependency graph and refresh every projection, with optional codebase reconciliation

Research a focus (a tool, a practice, a field of candidates) and render the findings as a verified, source-cited HTML artefact in one of a fixed set of formats.

Where generated visual assets live, how project type and theme are resolved, and the quality gate every asset-* skill runs before reporting

Empathy-driven design: think through how real people experience the software; surface and challenge assumptions.

Neo4j and Cypher: graph schema design, query patterns, performance optimisation, PostgreSQL integration.

Svelte 5 and SvelteKit: runes reactivity, component composition, routing, data loading, form handling.

Suggest the next logical task from the roadmap's pre-vetted ready-set, driven by its leverage signals

Review a pull request's diff and print structured findings to the terminal. Holds the canonical review methodology that pr-review and branch-qa_review both call.

Studs every function of a planned feature in its real file as a runnable walking-skeleton (fake data, real wiring), so names, placement and contracts are reviewable before any real logic is written. Lays the skeleton, then checkpoints for review.

OpenTUI terminal UI library reference: @opentui/core, terminal UIs, renderables, Yoga layouts, Zig-native rendering.

Investigate this repo's dependencies in detail

Creates interactive HTML playgrounds — self-contained single-file explorers that let users configure something visually through controls, see a live preview, and copy out a prompt. Use when the user asks to make a playground, explorer, or interactive tool for a topic.

Tag the release after a merge to main, computing the next semver tag with svu

Jason's structural and epistemic-honesty conventions for every artefact Claude creates

Add a well-formed task, or a reviewed batch of them, to a rich-format roadmap: ID assignment, dependency wiring in both directions, graph integrity

Git workflow: branch management, commit conventions, PR patterns, conflict resolution.

Type-safe API design: Zod validation, Result types, SvelteKit endpoints, middleware patterns.

Convert an exported Claude artefact (HTML or JSX) into a working Svelte 5 / SvelteKit 2 project

Interview the user to turn half-formed ideas into a reviewed batch of roadmap-ready tasks. Read-only; roadmap-update-tasks writes the approved proposal.

Polyglot persistence: when to use relational, graph or document databases; integration patterns.

Model-first design: map entities, relationships and boundaries before writing code.

Frontend styling: layout debugging, style consistency, CSS best practices for Svelte/SvelteKit.

Writing style guide for Jason Warren. Applies whenever writing or editing substantive prose for Jason: drafting sections, reports, documentation or rewriting passages.

Pragmatic testing with Vitest: risk-based strategy, Svelte component testing, test-after development.

Jason's placement, invocation and metadata conventions for creating or editing skills