tstack

Plugin tstack from marketplace tstack in luizhcrocha/skills. Commands read from the repo's manifest — yesterday.

Skills (82)

• animate

  Build an animation or transition that passes review-animations, or name a motion effect (\"what's it called when...\"). Use to animate a component, add motion, or find the term for an effect.

• animation-performance

  Keep web animations inside the frame budget: composite-only properties, off-main-thread motion, CSS vs WAAPI vs rAF, will-change, and finding why one drops frames. Use when an animation is janky or stutters, or to pick which property to animate.

• apple-design

  Apple's fluid-interface principles for the web: springs, velocity handoff, momentum, rubber-banding, materials, type. Use for gesture-driven UI, sheets, drag or swipe, or an Apple-style feel.

• architect

  Sketch types, signatures and the module map from competing candidates before code, then implement against it. Use for \"architect this\", \"design this first\", \"sketch the types\", or non-trivial work.

• arena

  Run N parallel attempts at one task under distinct constraints, pick a base, graft the best of the others. Use for \"arena this\" or competing designs of one contested shape.

• benchmark-checklist

  Vet a perf measurement (limiter, tuning, limits, errors, repeatability, relevance, and whether the work happened) before you report or act on it. Use when you run a benchmark or report a speedup or regression you measured.

• blast-radius

  Find what a change could break beyond the diff, and prove the fact it is safe by running real code. Use for \"blast radius of X\", \"what could this break\", or a small diff you don't trust.

• break-ui

  Stress-test a piece of UI with realistic worst-case data (long names, missing fields, huge counts, non-Latin text, emoji), shown behind a Demo/Worst case toggle, and report each break with its fix. Use for \"break this\", \"try the worst case\", edge cases in a component.

• choreograph

  Coordinate several elements that animate together: what moves, in what order, how much they overlap, what stays still. Use for staggered lists, hero entrances, view swaps, multi-step flows, morphs, or motion that \"feels mechanical\" or \"too much going on\".

• codebase-design

  Deep-module design vocabulary (module, interface, seam, depth). Use to design or improve an interface, place a seam, make code testable, or when another skill needs the vocabulary.

• correct

  Find the mistakes agents keep repeating in this repo and make each one impossible. Try architecture first, then types, then a lint whose error names the fix, then a test, and write docs last. Prove each check fails on a real past mistake. Repeat this each time the operator corrects you. Use for /cor

• create-formal-verification-skill

  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, s

• create-verification-skill

  Generate a project-local verify-<app> skill that launches the app and drives it like a user, with a feature map. Use for \"make a verify skill\", or when proving a change means improvising the launch.

• design-engineering

  Craft rules for web UI polish (press states, origins, transforms, clip-path, gestures, performance, accessibility) and a Before/After review table. Use to polish UI or review it for feel.

• diagnosing-bugs

  Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.

• domain-modeling

  Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a CONTEXT.md, or recording or editing an ADR.

• explain

  Explain a piece of work plainly (what, how, why) as one conversational account. Use for \"explain this change to me\", \"help me really understand X\", \"walk me through this PR\".

• figure-it-out

  Design an auditable bespoke playbook when no tuca-mode playbook fits. Use for \"figure it out\", a large migration or port, a cross-cutting change, or work Luiz reviews after stepping away.

• find-animation-opportunities

  Find places in a UI that don't animate but should, and reject the ones that shouldn't; read-only, exact values. Use for \"what could animate here?\" or \"make this feel more alive\".

• gestures

  Build drag, swipe and sheet interactions that track the finger 1:1 and stay interruptible: velocity, dismiss thresholds, rubber-banding, snap points. Use for drawers, sheets, swipe-to-dismiss, drag-to-reorder, hold-to-confirm, or a gesture that jumps on release.

• grill-with-docs

  A relentless interview to sharpen a plan or design, which also creates docs (ADR's and glossary) as we go.

• how

  Explain how code works, as onboarding a senior engineer. Use for \"how does X work\", \"zoom out\", a map of an area, a walkthrough before changing unfamiliar code, or \"where should this live\".

• implement

  Implement a piece of work based on a spec or set of tickets.

• improve-animations

  Audit a codebase's animation and motion code and write prioritized, self-contained fix plans for other agents; read-only on source. Use to \"improve the animations\" or \"audit the motion\".

• improve-codebase-architecture

  Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

• lang-c

  C rules and taste for tstack (C23, GCC/Clang, sanitizers, clang-tidy, QMK keymaps). Use when writing, reviewing or testing C code.

• lang-cpp

  C++ rules and taste for tstack (C++23, Core Guidelines, RAII and ownership, std::expected, sanitizers, CMake). Use when writing, reviewing or testing C++ code.

• lang-cs

  C# and .NET rules and taste for tstack, from nullable discipline and records to analyzers, Microsoft.Testing.Platform, test tools and Temporal .NET gotchas. Use when writing, reviewing or testing C# code.

• lang-go

  Go rules and taste for tstack: defers modern idioms to JetBrains' use-modern-go, adds gates, errors, seams and the testing ladder (rapid, go test -fuzz, synctest). Use when writing, reviewing or testing Go code.

• lang-nix

  Nix rules and taste for tstack: flakes, NixOS and home-manager modules, devenv, the latest-release rule, nixfmt and flake checks, VM tests. Use when writing, reviewing or testing Nix code, a flake, or a devenv.

• lang-nu

  Nushell rules and taste for tstack: bash habits that break, external failures and pipefail, typed signatures, explicit module imports, redirection, Luiz's config in the dotfiles, nu-check and std/assert. Use when writing, reviewing or testing Nushell code, or a command for Luiz's shell.

• lang-py

  Python rules and taste for tstack: uv environments, ruff, basedpyright, pytest and Hypothesis, bounded worker pools. Use when writing, reviewing or testing Python code.

• lang-refresh

  Check the lang-* skills against their sources' latest releases and propose updates as jj changes. Use for "refresh the language skills", "are the lang skills current?", a new major release of a language or tool, or a scheduled run.

• lang-rust

  Rust rules and taste for tstack: non-negotiables, error and module style, the fmt/clippy/test gates, and the testing ladder's Rust tools. Use when writing, reviewing or testing Rust code.

• lang-swift

  Swift rules and taste for tstack: Swift 6.4, value types first, the 6.2 concurrency model, swift-format and SwiftLint gates, Swift Testing and the ladder. Use when writing, reviewing or testing Swift code.

• lang-ts

  TypeScript rules and taste for tstack: parse at boundaries, typed failures, strict contracts, Vite+ gates, the ladder's tools, Cloudflare and Effect topics. Use when writing, reviewing or testing TypeScript code.

• lang-zig

  Zig rules and taste for tstack: the 0.16 std.Io and build APIs, allocator and errdefer discipline, TigerBeetle-style assertions, and the testing ladder's Zig tools. Use when writing, reviewing or testing Zig code.

• lint-audit

  Audit tstack's lint rules against their registry and trials; propose promotions and retirements; re-vendor the packs. Use for \"lint audit\", a periodic run, or after a lint pack changed.

• lint-evolve

  Turn a repeated lesson into a native lint rule, tested on the real incident and trialled across Luiz's repos. Use for \"make this a lint rule\", or a finding, gotcha or MUST KILL seen twice that a linter could catch.

• maintain-formal-verification-skill

  Bring a project's formal verification back in line with the code after the code changes: find the commits that touched verified code, update the model, harness, or properties to describe the code as it is now, rerun, and say whether each failure is drift in the verification or a bug in the code. Use

• maintain-verification-skill

  Audit a verify-<app> skill and feature map against the app as it is now, with one live pass, then one change of proven fixes. Use for \"audit the verify skill\", a failed verify run, or UI churn.

• migrate-to-agents-md

  Move a repo's agent instructions from CLAUDE.md into AGENTS.md, so Claude Code and every other coding agent read one file and no CLAUDE.md shadows it. Run when a repo has a CLAUDE.md, when CLAUDE.md and AGENTS.md both exist, or when Claude ignores an AGENTS.md.

• mobile-native

  Make a web app feel native on a phone: sticky hover, tap flash, 100vh, input zoom, tap delay, overscroll, safe areas, theme-color. Use when a web UI feels wrong on mobile, or for a PWA or touch UI.

• no-comments

  Strip narrating comments from a diff, fix what they papered over, offer to encode claims as types, tests or lints. Use before landing, when a playbook asks, or \"no comments\", \"deslop the comments\".

• pick-ui-library

  Pick a frontend library from a curated list (primitives, toasts, command menus, charts, motion, drag and drop, state, styling). Use before hand-rolling a UI component or adding a frontend dependency.

• principles

  Engineering principles, one file each. Use when a design, refactor, debugging, testing or delegation decision needs a rule to settle it, or a playbook names a principle.

• prototype

  Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

• remove-animations

  Find the animations a UI does not need (keyboard actions, high-frequency surfaces, functional data, purposeless decoration) and remove them, cleaning up what they leave. Subtracts only. Use when the app \"feels slow\" or \"over-animated\".

• research

  Investigate a question against primary sources and save the findings as Markdown in the repo. Use to research a topic, gather docs or API facts, or delegate reading to a background agent.

• resolving-merge-conflicts

  Resolve conflicts by intent: jj changes left conflicted by a rebase, squash or workspace update, or a git merge/rebase. Use when `jj log` shows (conflict) or git stops mid-merge.

• review-animations

  Review animation and motion code (CSS transitions, keyframes, Motion, springs, gestures) against a strict craft bar, with a Block or Approve verdict. Use for a UI diff that adds or changes motion.

• review

  Review changes since a fixed point (default: the landing bookmark's remote) on two axes, Standards and Spec, in parallel, or as a Deep review that keeps only findings a run proves. Use to review a branch, stack, PR or WIP, \"review since X\", \"tear this apart\", \"stress test this\", a contested de

• setup-luizrocha-skills

  Sets up an `## Agent skills` block in AGENTS.md/CLAUDE.md and `docs/agents/` so the engineering skills know this repo's issue tracker (GitHub or local markdown), triage label vocabulary, and domain doc layout. Run before first use of `to-issues`, `to-spec`, `triage`, `diagnosing-bugs`, `review`, `td

• statechart

  Check a TLA+ model of a system that moves between states, such as a product flow, a protocol, or a service, and draw it as a Mermaid statechart. The report gives the shortest path to each state that breaks a rule. Use for /statechart, or to show a bug as a path through states.

• swarm

  Fan out N parallel workers over slices or race arms and return one PASS / ISSUES / BLOCKED report. Use for \"swarm this\", coverage matrices, races, best-of runs, gauntlets of checks.

• tdd

  Test-first development and choosing the right evidence (example, integration, property, model-based, fuzz, mutation, simulation). Use when writing tests, fixing bugs test-first, \"red-green-refactor\", or proving a change works.

• to-issues

  Break a plan, spec or PRD into independently grabbable issues as tracer-bullet vertical slices. Use to turn a plan into issues or implementation tickets.

• to-spec

  Turn the current conversation into a spec and publish it to the project issue tracker: no interview, just synthesis of what you've already discussed.

• triage

  Triage issues through a state machine driven by triage roles. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.

• tuca-mode

  Luiz's working mode for the session. A playbook for every task, the principles, autonomy and reply rules. Off with "stop tuca-mode".

• why

  Find why code is the way it is, from every record, as a cited, confidence-tiered answer. Use for \"why does X work this way\", \"why did we pick Y\", regressions, postmortems, before changing code of unknown reason.

• wizard

  Generate an interactive bash wizard for steps only a human can do (provisioning, credentials, CI secrets, third-party dashboards, one-off cutovers). Not for steps the agent can do itself.

• worktree-janitor

  Shape a messy jj @ into a clean, described stack (split by intent, fixups absorbed, conflicts resolved, empty @ on top), then audit it. Use before landing or pushing, or when @ holds mixed or undescribed edits.

• automate-me

  Refresh /tuca-mode from how Luiz actually works, mined from his recent Claude Code transcripts, as jj changes for him to review.

• bro

  Bro. That last message did not land: say it again, plainly.

• grill-me

  A relentless interview to sharpen a plan or design.

• grilling

  Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases.

• handoff

  Compact the current conversation into a handoff document for another agent to pick up.

• in-your-own-words

  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.

• ketchup-video

  Catch the user up like /ketchup, with a short subtitled video of slides for what happened and the waiting calls as text under it. Use for /ketchup-video.

• ketchup

  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.

• memo

  Record durable memory with memo. Use when a session learns a decision, gotcha, preference or open thread worth keeping, corrects or closes one, or memo prints a compaction task.

• orchestrate

  Run pending or given tasks in parallel across agents (subagents, a workflow or a team), partitioned so workers never share files. Use to parallelize work, fan out tasks, or \"orchestrate\" a batch.

• recall

  Answer from the record what we know or did before, or catch Luiz up on recent work. Use for \"what do we know about X\", past decisions, \"catch me up\", \"where did I leave off\".

• reflect

  Mine this session's transcript for durable learnings through three reviewers and a synthesizer, then land the approved skill edits as a jj change in the tstack repo and the rest as memo notes.

• sharpen

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

• show-me-your-work

  Keep a reviewable decision log (what, why, evidence, result) for long or unattended work, audited and reviewed before hand-back. Use for autonomous runs, hillclimbs, bespoke playbooks.

• show-me
• teach
• technical-writing
• unslop
• writing-for-agents

Subagents (3)

• comment-sicko

  A deranged comment-hater that savors deletion and condemns workaround code. Spawned by /no-comments, which audits its report; call that skill rather than this agent.

• reader

  A read-only Reader (docs/models.md). Reads a lot and returns a short result under the caller's cap; writes no files. Spawned by skills that hand out read-and-reduce work, such as recall's miners and automate-me's readers.

• worktree-janitor

  A janitor who cannot stand a messy jj @. Shapes the given scope into a clean, described stack and reports it. Spawned by /worktree-janitor, which audits the result; call that skill rather than this agent.

Hooks (4)

• SessionStart

  "${CLAUDE_PLUGIN_ROOT}/hooks/tstack-hook" SessionStart

• Stop

  "${CLAUDE_PLUGIN_ROOT}/hooks/tstack-hook" Stop

• PreCompact

  "${CLAUDE_PLUGIN_ROOT}/hooks/tstack-hook" PreCompact

• PreToolUse

  "${CLAUDE_PLUGIN_ROOT}/hooks/tstack-hook" PreToolUse

Similar plugins