mstack

mstack is a Cursor plugin for AMD GPU kernel development and Jira-ticket-driven work. It targets aiter, FlyDSL, Triton, and HIP/MFMA kernels on MI300X (gfx942) and MI355X (gfx950).

It is a fork of pstack (see Upstream). It keeps pstack's process: go deep first, write less code, verify against the real artifact. It adds the kernel domain and a ticket lifecycle.

mstack ends in a deliverable, not always a PR. A ticket can end in a PR, a Jira comment draft, or both. A human approves every Jira post.

mstack routes kernel work through skill functions. A playbook names a skill function, such as lever.menu or isa.diff. One file, skill-functions.md, binds each skill function to the matching skill in your skills dir, the skills resource. python3 scripts/check.py checks that file against the installed skills.

install

/add-plugin mstack

the plugin ships two hooks (hooks/hooks.json). the sessionStart hook syncs the skills that the pr.review and pr.validate skill functions bind to. it syncs each one to the latest origin of its repo. it runs in the background, so a session never waits on it. the stop hook acts only in a chat that froze a hillclimb harness with scripts/climb-gate.py freeze. it sends the turn back to the agent, at most 3 times in a row, in two cases. one case is a frozen file that changed in a worktree of the climb. the other is a current best with no bench artifact that has correctness passed at its HEAD. the current best is S* (the best lever subset) once it is registered, and B (the baseline commit) before that. climb-gate.py pause lets one stop pass, and it takes a reason.

get started

two steps:

1. run /setup-mstack, pick a reasoning budget, and choose which models you want. it then maps this machine (gpu hosts, your containers, PR tool, jira sites, gpu lock) into ~/.cursor/mstack/env.md. it also looks up your local resources and optional modules by what they contain, and asks only for what it did not find. see local resources and optional modules.
2. use /ateam-mode whenever you're doing anything that requires rigor.

new here? the mstack guide walks you through a first real task, from setup and prompting through verification and overnight runs. stuck, or unsure which skill fits? ask /ateam-help.

that's it. the other skills are situational; the mode skill uses them for you as needed. out of the box the mode splits work by model strength. code delegates (feature, refactoring, bug fix, perf, hillclimb) go to sonnet 5.5, while the hardest changes, prose, and judgment go to opus 5.5. each list role defaults to two entries, opus 5.5 and sonnet 5.5. /setup-mstack changes any of it.

local resources and optional modules

setup looks first and asks second. it finds each thing by what it contains, never by its name or location. it asks only when it finds nothing, finds several, or cannot verify what it found.

/setup-mstack env
   │
   ▼
read-only search of your home  (bounded depth, time limit, no .git internals)
   │
   ├── one match ────────► recorded, listed in the report
   ├── several matches ──► asks which one
   ├── no match ─────────► required: asks     optional: asks once, may skip
   └── check fails ──────► shows the failing test, asks again
   │
   ▼
~/.cursor/mstack/env.md   (outside the plugin, an update never overwrites it)

the knowledge base and wavescope are independent, optional modules. mstack works without them.

if setup missed one, answer its question with a path, or rerun /setup-mstack env. for the skills dir, you can also set $MSTACK_SKILLS_DIR. the report at the end lists every resource, its value, and how it was identified, so you can correct any of them.

pushing works over ssh or https with the credentials you already have. setup reads each repo's remote scheme, tests it read-only, and never changes a remote or stores a token.

usage

use /ateam-mode at the start of a task. it reads your request, picks from a set of playbooks, and runs the other skills as the steps need them.

just use /ateam-mode

this skill is the main shortcut. i use it whenever i need the agent to do rigorous engineering work. it comes with twenty-six playbooks:

/ateam-mode this flydsl kernel returns nan at T=4096 on gfx950. repro first, then fix and
verify.

/ateam-mode i'm going to bed. land the stack even if ci flakes. i want everything merged by
morning.

the twenty-six playbooks

when invoked it:

1. matches your task to a playbook and opens a todo list whose first items are its steps, copied in verbatim.
2. routes to the other skills as the steps fire.
3. writes replies diagram-first in short asd-ste100-lite sentences, with a one-line number, unit, and run count for each measurement, and an html page when a diagram alone is not enough.

the full rules and playbooks live in skills/ateam-mode/SKILL.md.

to keep /ateam-mode on across turns, pick it from the / menu and press option+enter (mac) or alt+enter (windows) instead of enter. that makes it a custom mode, which cursor offers in the agents window and the cli. it stays in context every turn, applies itself when a playbook matches or the task needs rigor, and does nothing otherwise. plain enter attaches it to one message only. say so to opt out, or exit the mode to turn it off.

/ateam-mode works well with cursor's /loop command. cursor can then work for many hours without sacrificing rigor.

skills

/ateam-mode runs most of these for you when a step needs them (how, why, architect, arena, interrogate, unslop, no-comments, technical-writing, tdd, and the principles). the table below is for when you want one directly:

/how does aiter pick between the hip and triton kernels for this gemm? where does the M threshold live?

/interrogate review this branch.

all skills

examples

mostly i type /ateam-mode at the start of a task and let it route to a playbook. the other skills fire as the steps need them. a few i reach for directly.

all the examples

bug fix:           /ateam-mode this flydsl kernel returns nan at T=4096 on gfx950. repro first,
                   then fix and verify.
perf:              /ateam-mode close the 1.4x gap to the triton reference for this gemm on
                   gfx950. run a counter pass and tell me what limits it.
feature:           /ateam-mode add an fp8 path to this aiter op behind a dtype flag. verify it
                   against the torch reference on a locked gpu.
prototype:         /ateam-mode build two prototypes of the lds layout for this kernel so we can
                   compare. spawn an agent for each.
multi-phase:       /ateam-mode open source these skills as a plugin. nothing internal leaks, work
                   in a temp dir, show me the dependency graph first.
overnight run:     /ateam-mode i'm going to bed. get the stack green even if ci flakes. i want
                   every pr verified and ready for my review by morning.
pr review:         /ateam-mode review ROCm/aiter#123. draft it, i'll approve before it posts.
babysit:           /ateam-mode check on pr 123. anything outstanding?
figure it out:     /ateam-mode i'm stepping away. migrate every op test from the old timing helper
                   to run_perftest, keeping the reported numbers identical. i want to trust it
                   was done right when i'm back.
how:               /how does aiter pick between the hip and triton kernels for this gemm? where
                   does the M threshold live?
why:               /why does this dispatch threshold route M<=64 to the hip kernel?
architect:         design the shape dispatch for this kernel family so it never routes a shape to
                   a slower path. /architect this first.
bound probe:       /ateam-mode bound the ceiling of a fused redesign before we build it.
repro audit:       /ateam-mode reproduce the numbers claimed in this pr.
ticket:            /ateam-mode resume PROJ-123.
trace:             /ateam-mode here is an att trace of the slow kernel. where does the time go?
refactor:          /ateam-mode clean up this aiter kernel without changing its isa.
arena:             /arena take my prompt to the arena verbatim. i want to compare their proposals
                   with yours.
fan-out:           /ateam-mode check every kernel under aiter/ops/flydsl/ with the isa.diff skill function.
                   one worker per kernel. one report.
interrogate:       /interrogate review this branch.
tdd:               /tdd implement
unslop:            can we unslop and tighten the new changes?
reflect:           /reflect that took too long. capture what we learned so the next run doesn't
                   repeat it.
correct:           /correct
show-me-your-work: /show-me-your-work keep a decision trail i can review when i'm back.
automate-me:       /automate-me
help:              /ateam-help which skill should i use to review this branch?

the ateam-agent and Comment Sicko subagents

/ateam-mode runs in the chat that receives it. that chat owns the playbook, the todo list, and every subagent spawn.

mstack also ships subagent_type: "ateam-agent" as the wrapper for delegates spawned during a run. it reads ateam-mode in full, including its inline principles index, before doing any work. substituting generalPurpose skips that read and drifts. do not spawn ateam-agent to run the playbook itself.

/ateam-mode and subagent_type: "ateam-agent" route through the same wrapper.

mstack also ships Comment Sicko, a read-only comment reviewer available as subagent_type: "comment-sicko". usually invoke it through /no-comments, not directly.

principles

twenty short skills, one principle each. ateam-mode indexes them inline and reads that index at task start. the standalone files are there so other skills can reference a principle by name, and so the index can point at the full rule for each.

all twenty principles

pr review caveats

• pr review needs gh 2.24 or later, signed in. the review's fetch step reads the pr through gh, and git or the github mcp cannot replace it in a script. a distro package can be too old (ubuntu 22.04 ships 2.4.0), so install a release binary if needed. sign in with gh auth login, or set GH_TOKEN to a token that can read pull requests. if you want mstack to post reviews, the token needs write access to pull requests too.
• nda model names are optional. before a review posts, scripts/post-review.py blocks local paths and internal ticket keys. it can also block nda model names, but mstack ships no list, because a list in this repo would leak the names. to add one, prompt your agent: "add these model names to ~/.cursor/mstack/leak-patterns.txt, one case-insensitive regex per line." the file stays on your machine, and a plugin update never overwrites it.
• the review-group steps need local cursor transcripts. scripts/review-group-gate.py reads each reviewer's reply from its own subagent transcript under the workspace's agent-transcripts/ directory, so a pr review runs in a local chat, not a cloud agent.
• the merge gate depends on the review skill's layout. the gate re-runs the bash block under that skill's ## Step 8 heading. if upstream changes the layout of that section, the gate fails closed and reviews stop until you update mstack.
• triton is not fully compatible yet. a triton pr gets the same rule set, gates, review group, and conventions check as aiter and flydsl, in a snapshot of your triton checkout. two gaps remain:
  • the skill bound to the pr.validate skill function does not recognize triton's repo layout, so the gpu base-vs-head check always reports INCONCLUSIVE. runtime evidence comes from the pr's own tests through the bench.run skill function, and this evidence is advisory.
  • the review rules come from aiter's review history. the triton rule families target triton kernels (tl.load masks, launch configs, accumulator precision). they do not target the compiler's c++ and mlir passes, and those passes get only the generic rules.

not shipped here

a few things ateam-mode references but doesn't bundle:

• the kernel skills bound to its skill functions (listed in skill-functions.md) live in your skills dir (the skills resource), not in this plugin. python3 scripts/check.py checks that each one resolves. it reads the dir from $MSTACK_SKILLS_DIR, else from the skills table of ~/.cursor/mstack/env.md, and skips the check with a note when neither is set. --no-skills skips it on purpose.
• ponytail is optional and separate. when you install it and it is on, ateam-mode passes its level to each code delegate, since a cursor subagent does not receive it from the hook. ponytail cuts code, never a playbook step or a verification gate. /ponytail off turns it off for mstack too.
• /create-skill is a cursor built-in. cursor also ships a built-in /babysit; inside ateam-mode, the babysit playbook supersedes it for pr-status requests.

why are there no planning skills?

cursor already has a plan mode, and it works with mstack. but personally, i don't believe in planning. the best spec is code. if you do want to make a plan, /ateam-mode covers it, but it's not a default.

make it yours

ateam-mode is one engineer's style. you may not want exactly that.

type /automate-me. it mines your recent transcripts, drafts a <your-name>-mode skill from how you've worked, and routes through mstack underneath. you keep mstack as the base and end up with your own routing skill alongside ateam-mode.

models are configurable too. type /setup-mstack. it detects the models you have access to and writes a small always-applied rule mapping each role (code, judgment, the list roles) to a model. every skill reads it and falls back to sensible defaults when the rule is absent, so you override only what you want.

when a default changes, a rule written before the change still pins the old default. delete those role lines, or delete the file, then run /setup-mstack again. a rerun keeps any role whose model differs from the default.

Upstream

mstack is a fork of pstack 0.15.20 by poteto (Lauren Tan), MIT licensed. The pristine import is commit 1491916. LICENSE keeps the upstream copyright notice.

To sync with upstream:

git clone https://github.com/cursor/plugins /tmp/cursor-plugins
mkdir /tmp/mstack-import && git archive 1491916 | tar -x -C /tmp/mstack-import
diff -ru /tmp/mstack-import /tmp/cursor-plugins/pstack

Port the changes you want by hand. Upstream paths use pstack, poteto-mode, poteto-agent, poteto-help, and setup-pstack. Map them to mstack, ateam-mode, ateam-agent, ateam-help, and setup-mstack.

license

MIT