Skip to main content
plugin CX Codex

req-tpm — Claude Code plugin for requirements and setup

req-tpm is a Claude Code plugin that tracks requirements from intake through outcome review. Its skills capture a measurable goal, record design decisions, and follow progress.

MIT ★ 741 updated 2026-11-11

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add MiniMax-AI/mcode-stack
/plugin install req-tpm@mcode-stack
Open on GitHub

What req-tpm does

req-tpm connects a requirement document in Feishu with its work status in Meegle. Six skills cover intake, priority recommendation, design, tracking, release readiness, and outcome review against the original measures. The requester recommends a priority; the owner decides it.

The setup needs an authenticated meegle CLI, lark-cli to read and write Feishu docs as the user, and templates/requirement-doc.md. Fields and states marked as assumptions must be replaced before the first real write to Meegle. Comments, mentions, and status changes wait for the requester’s confirmation.

What it helps with

  • record a measurable expected outcome for a requirement
  • send the owner a priority recommendation
  • capture design options and decision checkpoints
  • surface stale work items in the report
  • compare shipped work with its expected outcome using evidence

Example prompts for the agent

  • Start intake for this requirement and define a measurable outcome: reduce response time.
  • Record the design options and decision for this requirement.
  • Check the requirement’s progress, blockers, and next step.

How to install req-tpm

Plugin marketplace

/plugin marketplace add MiniMax-AI/mcode-stack
/plugin install req-tpm@mcode-stack

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about req-tpm

How do I install req-tpm in Claude Code?

Run these commands in order: /plugin marketplace add MiniMax-AI/mcode-stack, then /plugin install req-tpm@mcode-stack.

What does req-tpm do?

It tracks a requirement from intake through priority, design, and release to an evidence-based outcome review. The requirement document lives in Feishu, while its status is managed in Meegle.

What does req-tpm need to run?

It needs an authenticated meegle CLI, lark-cli for Feishu document access as the user, and templates/requirement-doc.md. Assumed fields and states must be replaced before the first real write.

Source text

req-tpm · MIT
# req-tpm

English | [中文](README_ZH.md)

`req-tpm` lets the person who raises a requirement act as its TPM, together
with their own agent. Every product or technical requirement gets a doc, a
work item and someone following it, from intake to the outcome review, so
nothing gets dropped quietly.

The requirement body lives in a Feishu doc. Status and flow live in Meegle
(Feishu Project). Each skill installs and runs on its own, and keeps both
sides in step.

> **v0, optional.** This stack has not yet been run against a real Meegle
> space. The field mapping separates keys confirmed in the `meegle` CLI's own
> docs from project-specific fields, roles and states, which are assumptions
> until you look them up in your space.

## Lifecycle

```mermaid
flowchart LR
  A[req-intake<br/>worth doing?<br/>expected outcome] --> B[req-prioritize<br/>cost / impact / risk<br/>owner decides]
  B --> C[req-design<br/>options and decision<br/>blast radius / checkpoints]
  C --> D[req-track<br/>progress / blockers / next step<br/>flag stale items]
  D --> E[req-ship<br/>rollback / observability / DoD<br/>move status]
  E --> F[req-outcome<br/>compare with expected outcome<br/>close only with evidence]
  F -- not met --> C
  A -- recommend not doing --> X[close and record why]
  D -. stale .-> D
```

| Phase | Skill | Writes to doc sections |
| --- | --- | --- |
| Intake | [`req-intake`](skills/req-intake/SKILL.md) | 1–3 |
| Prioritize | [`req-prioritize`](skills/req-prioritize/SKILL.md) | 4 |
| Design | [`req-design`](skills/req-design/SKILL.md) | 5–6 |
| Track | [`req-track`](skills/req-track/SKILL.md) | 7 |
| Ship | [`req-ship`](skills/req-ship/SKILL.md) | 8 |
| Outcome | [`req-outcome`](skills/req-outcome/SKILL.md) | 9 |

## Rules we follow

- The expected outcome is fixed at intake: metric, baseline, target, how we
  measure it, and the observation window. The requirement is judged against it
  at the end.
- The requester recommends; the owner decides priority. The agent does not
  change the priority of someone else's requirement.
- A stale item is information. It goes to the top of the report. We don't
  nudge people automatically, and we don't stay silent either.
- Shipping is not done. A requirement closes only with evidence of the
  outcome.
- Anything visible to others (comments, @-mentions, status transitions) is
  shown to the requester first and runs only after they confirm.

## Dependencies

- The `meegle` CLI (Feishu Project), logged in. Fields and states are in
  [`templates/meegle-field-mapping.md`](templates/meegle-field-mapping.md);
  replace every entry marked as an assumption before the first real write.
- `lark-cli`, reading and writing Feishu docs as the user (`--as user`).
- The requirement doc template:
  [`templates/requirement-doc.md`](templates/requirement-doc.md).

## Usage

Install the whole stack:

```bash
claude plugin install req-tpm --marketplace MiniMax-AI/mcode-stack
codex plugin add req-tpm@mcode-stack     # after: codex plugin marketplace add MiniMax-AI/mcode-stack
scripts/install.sh req-tpm               # from a clone of this repository
```

Or copy one skill, such as `stacks/req-tpm/skills/req-intake`, into
`~/.agents/skills/`. Start with `/req-intake` when someone raises a
requirement. [`WORKFLOW.md`](WORKFLOW.md) lists which skill fits which moment.

© MiniMax Code team · MIT · MiniMax-AI/mcode-stack

Similar plugins

All plugins for Notes, tasks and projects →

From the same set27

The whole set →
verify verify is a Claude Code prompt that checks another model’s pull request findings. It traces each claim through the changed code and returns a reasoned status. CX Codex GP ChatGPT ★ 741repo stars quiz.en quiz.en is a Claude Code prompt that builds an author quiz for pull requests inside the MCode Review pipeline. It evaluates design choices and failure modes directly from git diffs. CX Codex GP ChatGPT ★ 741repo stars lens lens is a Claude Code prompt that reviews a pull request through a selected lens and the MCode Review rules. It returns findings and human questions as JSON. CX Codex GP ChatGPT ★ 741repo stars youfang youfang is a Claude Code plugin that converts architecture diagrams into Keynote-style Magic Move slide decks. Builds a single offline HTML file where shared elements morph between views. CX Codex ★ 741repo stars jiachen jiachen is a Claude Code plugin for evidence-based PR checks with MCode Review. It reviews branches on request or runs in GitHub and GitLab CI, where a script determines the verdict. CX Codex ★ 741repo stars ronny ronny is a Claude Code plugin with skills for code review, agent workflows, and checking agent output. It comes into play for reviewing changes, delegating work, and auditing how agents operate. CX Codex ★ 741repo stars handoff-doc handoff-doc is a Claude Code skill that writes a structured handover file before a session reset or task switch. It preserves critical context without relying on full chat history. CX Codex +1 ★ 741repo stars review-capacity-check review-capacity-check is a Claude Code skill that checks unfinished agent work before another launch. It runs before parallel batches and during weekly reviews. CX Codex +1 ★ 741repo stars

Project sponsors

Companies that keep this analytics open