joshuahayeswashere/jstack

Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. Use for /architect, 'architect this', 'design this', or non-trivial work where jumping to code would lock in the wrong shape.

Make one artifact twice, apart, as two runner crews, have a judge crew score both, and a graft crew pick a base and graft the other's best into it. Typed in a home. Use for /arena, 'arena this', or 'throw it in the arena'.

Use for /automate-me, "automate me", "create/update/refresh my -mode skill", "turn/capture my preferences or working style into a skill", or wanting agents to follow how the user works. Drafts or revises a personal -mode skill by the authoring-a-skill playbook and unslop, optionally pulling fresh evidence from recent transcripts.

Vet a measured number (its limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before it is reported or acted on. Use for /benchmark-checklist, or when a playbook step names this skill.

Find what a change could break somewhere else before it ships, beyond the diff, and prove the one fact it's safe because of by running real code instead of writing it up. Use for /blast-radius, 'blast radius of X', 'what could this break', or reviewing a small diff you don't trust.

Restate the last message in plain human language, with no jargon. Use for /bro.

Find the mistakes agents keep repeating in a repo and make each one impossible - structure first, then types, then a test, and a written rule last - and prove each check fails on a real past mistake. Runs only when the user types /correct or $correct, or a brief names it.

Generate a project-local skill that formally verifies the code where a bug costs the most and tests reach the least, in any language, with whichever verification tool fits. Use for /create-formal-verification-skill, "model-check this race", "prove this invariant", or when concurrency, retries, state machines, parsers, or unsafe code need more than tests.

Generate a project-local verification skill, .claude/skills/verify-<app>/, that drives the repo's app the way a user does, in any language, framework or platform. Use for /create-verification-skill, "make a verify skill for this repo", or when a repo has no scripted way to prove UI, CLI or service behavior.

Make this thread a crewmate - do the one task a home wrote a brief for, in this thread's own worktree, write the result back to the brief, and stay on the pull request it opened. Use when the user or a home starts a thread with /crew <slug> or $crew <slug>.

Make this thread an expert - the always-on subject matter expert whose folder is named, which researches and answers asks about its one subject from its sources and its notes, and never writes code. Use when the user or another thread starts a thread with /expert <name> or $expert <name>.

Frame a task no playbook fits (a large migration, an ambitious multi-part change, work reviewed after stepping away) and, in a home, turn it into plan entries whose crewmates each keep a decision log. Use for /figure-it-out or 'figure it out'.

Grill the user relentlessly about a plan, decision, or idea, until nothing is left assumed. Use for /grilling, or when a home plans work whose shape is not settled.

Close this thread and leave the next one a short start - stop what runs, write a note of ten lines at most, and, for a repo's home, start the next home and settle this thread. The next home reads the rest from jbus. Use when the user invokes /handoff or $handoff, says to wrap up, move on or start fresh, or when the home skill's hand-off conditions are met.

Make this thread the home for the repo it runs in - read the repo's short handoff, plan work with the user, hand each task to a crewmate thread, and hand off to a fresh home before the context grows. Use when the user invokes /home or $home, opens a new thread to continue work in a repo, or asks to pick up where the last thread left off.

Use for /how, "how does X work", code walkthroughs before changing something, and placement / ownership / layering questions ("where should this live", "which package owns this", "is this the right layer"). Explains subsystem architecture, runtime flow, onboarding mental models. Use why for motivation.

Restate in your own words what you think the user's goals are and what problem they're trying to solve. Use for /in-your-own-words.

Use for /interrogate, "interrogate", "adversarial review", "challenge this", "stress test this code", "find blind spots", or "tear this apart". Two reviewers that do not see each other challenge changes, and the lead filters what they found.

Catch the user up on what changed in this chat since their last message, in plain words and small visuals. List every item waiting on them with what they need to decide it from the reply alone. Use for /ketchup.

Keep a repo's verify skill, .claude/skills/verify-<app>/, and its feature map honest as the app changes: typed in the repo's home, it sends one scout per feature file to read the feature from source, then writes one crewmate brief for the live pass over every feature and at most one pull request of proven corrections. Use for /maintain-verification-skill or "audit the verify skill".

Build a page whose buttons wake this T3 Code thread through a schedule_task webhook, served on the tailnet by a local server that keeps the webhook's URL and key off the browser. Use for /make-bot-ui, 'make a bot UI', 'buttons that wake this thread'.

Set up a repo's first home - its state directory, its T3 Code project, its table in jbus's config, what it lacks for jbus to merge in it, and its home thread. It finishes a home that was started by hand, and does only what is missing. Use for /new-home <repo>.

Use for /no-comments: a comment hunter reads the scope and condemns every comment that has no exception, then this thread deletes what it accepts, fixes the code a comment was excusing, and offers encodings for claimed constraints.

Opt out of the automatic home - make this thread an ordinary thread, or switch the automatic home off or back on for the whole repo, or switch the repo's automatic merge off or back on. Use when the user invokes /nohome or $nohome, or says this thread should not be a home, should just do the work itself, or should stop planning and handing out.

Answer a help question about jstack: how to get set up, which role takes a piece of work, and which playbook and skills fit a brief, a scout's request or a plain question, each with the file it came from. Type /poteto-help with a question, a brief's path or its slug.

Have a finished pull request reviewed in a fresh thread - one review thread per pull request reads its diff itself, judges what it found, and proves the one safety fact by running code (pstack's review, with no reviewer subagents and no fixes), sends the findings to the thread that did the work, and records them in the brief. Use when the user invokes /pr-review or $pr-review in a home or in a crewmate's thread, or asks to review the pull requests that have finished.

Reconstruct your recent working context from your own chat history, the home's record, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Use for /recall, 'recall my work on X', 'catch me up', 'what have I been working on', 'where did I leave off', before starting or resuming work.

Read one thread's transcript with three review subagents and a synthesiser, and end in proposed edits and proposed plan entries for the home to put to the user. It starts four subagents and edits nothing. Runs only when the user types /reflect or $reflect, or a brief names it.

Make this thread a scout - research the one question a home wrote a request for, with read-only tool calls over the code and the docs, write the report (and the crewmate's brief or a visual page when asked), and tell the home. Use when the user or a home starts a thread with /scout <slug> or $scout <slug>.

Set this machine up for jstack, or check it again - run the checkout's own install.sh --setup, which walks every need once, writes the configs that are not there and links the units, then the doctor, and report what was done, what was already there and the one command for each thing only the user can do. Use for /setup-pstack.

Make a task deeper, not bigger, then rewrite the prompt. Use for /sharpen.

Keep a decision log for long or unattended work, one TSV row per decision (what, why, evidence, result), so the user can review it after stepping away. Use for /show-me-your-work, or when a playbook step names this skill.

Fan a task out to up to ten scout and crew threads a step, drain them, and build one table from their Reports and Results. Typed in a home. Use for /swarm, 'swarm this', or parallel coverage, races, gauntlets and exploration.

Use for /tdd: fix a bug test-first, with a focused regression test that fails before the fix and passes after it. For a bug with a clear, cheap test path. Skip when the test path is unclear, expensive or integration-heavy.

Explain a body of work plainly so a person actually understands it. Runs the how and why skills and weaves what they find into one clear explanation. Use for /teach, 'teach me this', 'help me really understand X', 'explain this change or subsystem to me'.

Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax. Use for /technical-writing or when writing or reviewing docs, RFCs, readmes, PR descriptions, or commit messages.

TypeScript best practices. Use for /typescript-best-practices, typed before reading or editing .ts or .tsx files.

Cut AI tells from any writing. Use for /unslop, or when a playbook step names this skill.

Use for /why, 'why does X work this way', 'why we picked Y', design rationale, regressions, postmortems, or data-backed thresholds. Finds the MCP servers this session has and queries each evidence category (source control, issue tracker, long-form docs, real-time chat, infrastructure observability, error tracking, product analytics warehouse) in parallel, then returns a cited read on decisions and tradeoffs. Use how for runtime behavior.