Medium Powers ships as both a Codex plugin and a Claude Code plugin from the same repository. Pick the section that matches your environment.
Medium Powers is not in the official Claude Code plugin marketplace yet. Install it as a local plugin.
Clone the repository:
git clone https://github.com/Lixuhang987/medium-powers.git ~/plugins/medium-powersInside Claude Code, register the repository as a local marketplace and install the plugin:
/plugin marketplace add ~/plugins/medium-powers
/plugin install medium-powers@medium-powers
The marketplace entry is defined in .claude-plugin/marketplace.json and the plugin manifest in .claude-plugin/plugin.json, so Claude Code resolves both from the cloned directory.
To update later:
/plugin marketplace update medium-powers
/plugin update medium-powers@medium-powers
If you already have superpowers installed, several skill names overlap (brainstorming, writing-plans, executing-plans, etc.). Use /plugin to disable one before enabling the other, or pick the one that matches the workflow you want.
Medium Powers is not in the official Codex plugin marketplace yet. Install it as a local plugin.
Clone the repository into the current directory:
mkdir medium-powers
cd medium-powers
git clone https://github.com/Lixuhang987/medium-powers.git .Copy the plugin into Codex's local plugin directory:
mkdir -p ~/plugins/medium-powers
rsync -a --delete --exclude '.git' ./ ~/plugins/medium-powers/Register the local plugin marketplace entry:
python3 - <<'PY'
import json
from pathlib import Path
marketplace = Path.home() / '.agents/plugins/marketplace.json'
marketplace.parent.mkdir(parents=True, exist_ok=True)
if marketplace.exists():
data = json.loads(marketplace.read_text())
else:
data = {
'name': 'local',
'interface': {'displayName': 'Local Plugins'},
'plugins': [],
}
entry = {
'name': 'medium-powers',
'source': {
'source': 'local',
'path': './plugins/medium-powers',
},
'policy': {
'installation': 'AVAILABLE',
'authentication': 'ON_INSTALL',
},
'category': 'Developer Tools',
}
plugins = data.setdefault('plugins', [])
plugins[:] = [plugin for plugin in plugins if plugin.get('name') != 'medium-powers']
plugins.append(entry)
marketplace.write_text(json.dumps(data, indent=2) + '\n')
print(f'Updated {marketplace}')
PYRestart Codex, open the plugin picker, and install Medium Powers from the local marketplace.
The local marketplace path ./plugins/medium-powers resolves from your home directory, so the actual plugin files live at ~/plugins/medium-powers.
Medium Powers is an experimental Codex plugin for use-case-driven development.
It started as a response to a pattern I kept seeing in agent workflows: as models get stronger, strict TDD templates can become procedural latency instead of engineering leverage. They often push the agent toward scattered, function-level tests, fragmented implementation steps, and too little meaningful review of whether the real user flow works.
Medium Powers keeps the useful discipline of planning, tests, verification, and review, but changes the center of gravity:
Define the use case, control the core data structures and interface contracts, write a use-case-level integration test, then implement the smallest amount of code needed to make that flow work.
This is not anti-testing. It is a narrower testing strategy for coding agents: test the real flow first, avoid over-mocking business logic, and review the work against the approved use case instead of celebrating isolated green tests.
Medium Powers is built as a set of agent skills (compatible with both Codex and Claude Code). The main development loop is:
- Brainstorming - clarify the intent and produce a reviewed design.
- Writing plans - map existing flows, define use cases, data structures, interfaces, and the integration test target.
- Use-case-driven development - start from the approved plan, write the use-case-level integration test first, then implement.
- Subagent-driven development or executing plans - execute the plan with review checkpoints.
- Requesting code review - review against the plan and use case, not just against local implementation details.
- Verification before completion - verify the observable behavior before claiming the task is done.
Classic red/green/refactor TDD can still be valuable, especially for small pure functions, reused infrastructure, and hard-to-reproduce edge cases.
For coding agents, though, a rigid TDD template can create the wrong default behavior:
- Tests become distributed across many tiny internal functions.
- Mocks prove that calls happened, not that the product flow works.
- Agents spend time satisfying ceremony instead of clarifying contracts.
- Review becomes rare or shallow because each step appears locally green.
- The final system can pass tests while the use case remains incoherent.
Medium Powers tries a different default: one integration test group per use case, with explicit data structures, interface boundaries, and review gates.
using-medium-powers- entry skill that tells the agent how to use the workflow.brainstorming- turns rough intent into a reviewed design.writing-plans- writes implementation plans around use-case flows and integration tests.use-case-driven-development- plan-gated integration-test-first implementation.executing-plans- executes approved plans in batches with checkpoints.subagent-driven-development- dispatches implementation work with review stages.
requesting-code-review- asks for focused review before issues compound.receiving-code-review- handles review feedback with technical judgment.verification-before-completion- requires evidence before completion claims.systematic-debugging- traces failures to root causes before fixing.
dispatching-parallel-agents- coordinates independent parallel work.using-git-worktrees- isolates feature work.writing-skills- helps create and revise skills.
- Use cases are the unit of delivery.
- Integration tests should prove real flow coherence.
- Core data structures and interface contracts should be explicit before implementation.
- Mocks belong at external system boundaries, not around the business flow itself.
- Review should happen before local choices compound into architecture.
- Verification should produce evidence, not confidence theater.
Medium Powers is experimental. The workflow is intended to be used, criticized, and revised against real agent development sessions.
Medium Powers is based on and adapted from Superpowers, created by Jesse Vincent and licensed under the MIT License.
The original Superpowers copyright and MIT license notice are preserved in NOTICE.
Medium Powers is licensed under the Apache License 2.0. Portions adapted from Superpowers remain attributed under the original MIT license notice in NOTICE.