MCode Stack

# MCode Stack

Installs the skills and workflows the MiniMax Code team uses daily, covering subagent splits, small PRs, context costs, long sessions, long commands and independent review.

Made by MiniMax-AI on GitHub. These notes are Mindket's, written from its README; the project's own files and license are in its repository.

## About

What it is: MCode Stack publishes, as open source, the skills and workflows that the people behind MiniMax Code use every day. Each is a SKILL.md skill or checklist for one situation, such as deciding on a subagent, waiting on a long command or keeping a long session on track. They install into MiniMax Code, and most run in any other agent with skills support.

Who it suits: It suits developers who work with coding agents and want the team's daily habits for big tasks, long commands and long sessions.

```table
Industry | Who uses it | How they use it | Example
Software development | Developers working with coding agents | Run a skill at the right moment, such as before handing work to a subagent | Deciding whether a task stays in the main loop
Engineering teams | Teams reviewing agent-written code | Split large changes into small PRs and write clear change descriptions | A migration broken into small reviewable PRs
Developer tooling | Agent and plugin builders | Measure what tools and injected text cost in context | An audit of what every request carries
Operations | People running long shell jobs | Audit long commands and background tasks | A ten-point audit before a slow command runs
```

Anyone after a general prompt collection can skip it.

Where to use it: The skills install into MiniMax Code, and the plugin routes also cover Claude Code and Codex.

- MiniMax Code: skills install straight in, and the desktop app can add this repository as a marketplace
- Claude Code: plugin install commands add a whole stack
- Codex: plugin commands do the same, and Codex scans the shared skills folder
- Other agents that support skills: most skills work there too, because they use the common SKILL.md format

```table
Use case | Who | What they get back
Decide on a subagent | Developers | A check on whether to hand work to a subagent or keep it in the main loop
Keep PRs small | Engineers | Big features, refactors and migrations split into small PRs that are easy to review
Trim context cost | Agent builders | A measure of what tools cost in context, with ways to cut it
Review from a clean context | Reviewers | A diff review that sees only the diff, the requirement and the test results
```

How to set it up: You need an agent that supports skills and the name of a stack.

- MiniMax Code, Claude Code or Codex
- A stack name: ronny, jiachen or req-tpm
- Git, only if you copy a single skill by hand

1. Pick a stack. The examples below use ronny, and the others work the same way.
2. In Claude Code, run the plugin install command with your stack's name.
3. In Codex, add the marketplace, then add the plugin.
4. Or copy one skill folder into ~/.agents/skills/ so every project sees it.

In a shell, for Claude Code:

```bash
claude plugin install ronny --marketplace MiniMax-AI/mcode-stack
```

Inside a Claude Code session:

```bash
/plugin install ronny --marketplace MiniMax-AI/mcode-stack
```

Older Claude Code versions add the marketplace first, then install:

```bash
/plugin marketplace add MiniMax-AI/mcode-stack
/plugin install ronny@mcode-stack
```

For Codex:

```bash
codex plugin marketplace add MiniMax-AI/mcode-stack
codex plugin add ronny@mcode-stack
```

To copy one skill by hand, clone the repository to ~/mcode-stack first, then run:

```bash
mkdir -p ~/.agents/skills
cp -R ~/mcode-stack/stacks/ronny/skills/long-command-check ~/.agents/skills/
```

To install a whole stack as a local plugin in MiniMax Code, find your plugin directory first:

```bash
mcode plugin marketplace list
```

Then copy the stacks/ronny folder there, open /plugins inside MiniMax Code and hit Ctrl+R to reload.

How to use it: Open a new session in MiniMax Code and type /skills to see what you installed. Call a skill by name, or leave it to the agent to pick it up from the skill's description.

```text
/skills
/long-command-check
```

```table
Tool | What it does
subagent-split-check | Helps you choose between handing work to a subagent and keeping it in the main loop
engineering-small-prs | Breaks big features, refactors and migrations into small PRs that are easy to review
engineering-change-descriptions | Writes PR and commit descriptions that explain what changed and why
tool-budget-audit | Measures what your tools cost in context and offers ways to cut it, such as tool search
context-tax-audit | Shows what is injected into every request and how it affects the prompt cache
long-session-check | Guides choices for a long session, such as summarizing, compacting or starting fresh
handoff-doc | Writes a hand-off document that lets a fresh session continue the work
long-command-check | Audits a long shell command or background task against ten points
independent-review | Reviews a diff in a fresh context, seeing only the diff, the requirement and the test results
```

Example: You copy long-command-check into your skills folder, open a new session and run /long-command-check when a shell command is going to run for a long time. The skill audits that command against its ten points.

For newcomers and experts: If skills are new to you, each one is a folder with a SKILL.md file that tells your coding agent how to handle one situation. Install a single skill, type /skills to see it, and try long-command-check first.

Underneath, a stack is a plugin that bundles several skills, and the marketplace in this repository lets you install and update stacks without copying files. MiniMax Code scans several skill folders, at project level and for all projects. The trade-off is that the mcode plugin add command only draws on the official catalog, and it cannot take a GitHub address or a local path.

```flow
You pick a stack: ronny, jiachen or req-tpm
Installing puts the SKILL.md files in place
The agent scans its skill folders
You run a skill by name, or the agent loads it
```

Good to know:

- License: MIT
- Stacks: ronny, jiachen and req-tpm, with the skills above coming from ronny
- Skill folders: .minimax/skills/, .claude/skills/ or .agents/skills/ for one project, and ~/.agents/skills/ for all of them
- Also read: ~/.claude/skills/ and ~/.codex/skills/ are scanned too
- Marketplace: the Add marketplace option in the MiniMax Code desktop app is reaching people in stages, so you may not see it yet
- Local plugins: a plugin is installed as soon as it sits in the plugin directory, and Space turns it on or off in the panel

## On GitHub, 6 November 2026

- Stars: 543
- Forks: 41
- Open issues and pull requests: 1
- Language: Python
- License: MIT
- Topics: agent-skills, ai-coding, claude-skills, coding-agent, harness-engineering, minimax-code

## Links

- Code: https://github.com/MiniMax-AI/mcode-stack
- Releases: https://github.com/MiniMax-AI/mcode-stack/releases
- Issues: https://github.com/MiniMax-AI/mcode-stack/issues
- Star history: https://www.star-history.com/#MiniMax-AI/mcode-stack&Date

## Get the code

```
git clone https://github.com/MiniMax-AI/mcode-stack.git
```

Then follow the setup in its README. Nothing in this kit runs by itself.

README.md  7 KB