Microsoft + Open Source
Amplifier
+ Superpowers
Structurally enforced disciplined development
for AI coding agents
Active
February 2026
The Problem
AI agents are powerful
but undisciplined.
They skip design. Bypass TDD. Write code before tests. Claim "it works" without evidence. And rationalize every shortcut with confident, plausible explanations.
The Problem
The five failure modes
✘ Skip Design
"Let me just start coding this up" — jumps straight to implementation without understanding requirements.
✘ Bypass TDD
"I'll add tests after" — writes implementation first, then retrofits tests that pass by definition.
✘ Claim Without Evidence
"This should work correctly" — asserts correctness without running a single test.
✘ Rationalize Shortcuts
"In this case, a simpler approach is better" — articulate justification for cutting every corner.
✘ Context Collapse
Long sessions degrade quality. The agent forgets constraints, repeats mistakes, drifts from the plan.
The more capable the agent,
the more convincingly it justifies cutting corners.
Prompt engineering alone can't solve this.
You need structural enforcement.
Component One
Superpowers
Jesse Vincent's open-source methodology for disciplined AI development.
A complete development methodology that enforces design-first, test-driven, verification-based development — with anti-rationalization safeguards baked in.
43k+ GitHub stars
github.com/obra/superpowers (per project README)
Core Principles
●  Design before code
●  No code without a failing test
●  Fresh agent per task
●  Two-stage code review
●  No claims without evidence
●  Anti-rationalization tables
Component Two
Amplifier
Microsoft's modular AI agent framework. Linux kernel philosophy applied to AI development tooling.
■  Tiny Kernel
Stable core, replaceable modules at the edges. Provider-agnostic: Anthropic, OpenAI, Azure, local models.
■  Bundles
Composable configuration packages. Agents, behaviors, modes, recipes — mix and match.
■  Delegate Tool
Multi-agent orchestration. Spawn specialist sub-agents with isolated context and focused capabilities.
■  Modes
Runtime behavior modification with tool policies. Control exactly which tools are available — and which are blocked.
■  Recipes
Declarative multi-step workflows with approval gates, checkpointing, and human-in-the-loop control.
■  Skills
Domain knowledge modules loaded on demand. Auto-fetched from upstream, always current.
The Innovation
What if the agent literally can't skip the process?
Not "should not." Not "please don't."
Structurally impossible.
How It Works
Tool policies make it structural
Amplifier's mode system controls which tools are available at each phase. During design phases, write_file and edit_file are blocked at the framework level. The agent can't rationalize past a blocked tool call.
/brainstorm
✓ read_file, grep, glob, web_search, delegate
✘ write_file — BLOCKED
✘ edit_file — BLOCKED
Agent facilitates design conversation.
Delegates to brainstormer for artifacts.
/execute-plan
✓ read_file, grep, glob, delegate, recipes
✘ write_file — BLOCKED
✘ edit_file — BLOCKED
Agent is orchestrator only.
Must delegate all implementation to specialists.
The Mode System
Six modes. Six sets of constraints.
/brainstorm
Socratic design exploration. Agent facilitates, delegates artifact creation.
write blocked
/write-plan
Create implementation plan with bite-sized TDD tasks.
write blocked
/execute-plan
Orchestrator dispatches 3-agent pipeline per task. Never writes code directly.
write blocked
/debug
Investigate failures with bash. Delegates fixes to specialists.
write blocked bash safe
/verify
Evidence-based verification. Run tests, check behavior, confirm edge cases.
write warn bash safe
/finish
Four options: MERGE, PR, KEEP, or DISCARD. Requires passing tests for merge.
write warn bash safe
All modes use default_action: block — unlisted tools are denied by default.
Architecture
The Hybrid Orchestrator Pattern
The main agent operates in two modes depending on the phase:
Design Phases
Main agent handles conversation directly.
Interactive quality — Socratic questioning, iterative refinement, human dialogue.
Execution Phases
Main agent delegates to specialists.
Clean context — each sub-agent gets a fresh context window with just its task.
Conversation Flow
Main Agent (constrained by mode)
↓
delegates via tool call
↓
brainstormer
plan-writer
implementer
spec-reviewer
quality-reviewer
Specialists have write tools.
Main agent does not.
Specialist Agents
Five agents. One job each.
💡
Brainstormer
Explores requirements through Socratic dialogue. Proposes approaches. Saves design docs.
📋
Plan Writer
Creates bite-sized TDD tasks. Assumes zero context. Each task: 2–5 minutes.
🔨
Implementer
Strict TDD: RED-GREEN-REFACTOR. Will delete code written before tests. Atomic commits.
🔍
Spec Reviewer
Binary verdict: APPROVED or NEEDS CHANGES. Does NOT trust the implementer's report.
✨
Quality Reviewer
Post-compliance quality review. Clarity, error handling, security, maintainability.
Workflow
The development flow
/brainstorm
→
/write-plan
→
/execute-plan
→
/verify
→
/finish
/debug available as an off-ramp at any point
Interactive Track
You drive. Switch modes manually with slash commands. Full control over pacing and decisions. Best for: learning the methodology, complex features, exploratory work.
Recipe Track
Autopilot. The full-development-cycle recipe runs all phases with approval gates. You approve at checkpoints. Best for: well-understood features, batch work.
Execution
Per-task: three agents, zero trust
Every task from the plan runs through a three-agent pipeline. Each agent gets a fresh context window. None trusts the others' claims.
1
Implementer
Writes failing test first
Implements minimal code
RED → GREEN → REFACTOR
Atomic commit
→
2
Spec Reviewer
Reads spec independently
Checks implementation
Nothing missing, nothing extra
APPROVED or FAIL
→
3
Quality Reviewer
Code quality assessment
Error handling, security
Maintainability review
Critical / Important / Suggestion
Failure at any stage → back to implementer with specific feedback
Defense In Depth
Three layers of enforcement
Layer 1
Structural
Tool policies block write operations during design phases. The agent physically cannot call write_file. No amount of reasoning can bypass a blocked tool.
Layer 2
Prompt
Anti-rationalization tables preemptively address every known LLM excuse. "This is a simple change" → "Simple changes still need tests." No wiggle room in the instructions.
Layer 3
Workflow
Recipes with approval gates require human sign-off before proceeding to the next phase. The full development cycle has checkpoints you must approve.
Any single layer can fail. All three failing simultaneously? Vanishingly unlikely.
Comparison
What makes this different
Original Superpowers Amplifier + Superpowers
Enforcement Prompt engineering
(agent can rationalize past it)		 Tool policies — write tools blocked at framework level
Agent Isolation Instructions say "fresh context"
(relies on agent compliance)		 Delegate tool — actually spawns new agent with clean context
Human Checkpoints Instructions say "wait for approval"
(agent may continue anyway)		 Approval gates — recipe execution pauses until human approves
Phase Transitions Agent self-manages phases
(may skip or blur phases)		 Mode switching — explicit tool set changes per phase
Skills Updates Manual copy/paste
(version drift risk)		 Auto-fetch from upstream on bundle install
Composability All-or-nothing rules file
(hard to mix with other tools)		 Behavior YAML — include in any existing bundle
By The Numbers
What ships in the bundle
5
Specialist Agents
6
Modes
7
Recipes
7
Skills
5
Context Files
Includes a full-development-cycle meta-recipe that composes all workflows end-to-end.
Plus upstream skills auto-fetched from obra/superpowers — ~7,197 lines of content across 50 files.
Sources
Research Methodology

Data as of: February 20, 2026

Feature status: Active

Repository: microsoft/amplifier-bundle-superpowers (MIT-adjacent, open source)

Research performed:

  • Bundle cache inspection: find ~/.amplifier/cache -path "*superpowers*" (50 files found)
  • Agent count: find ... -path "*agents*" -name "*.md" (5 agents verified)
  • Mode count: find ... -path "*modes*" -name "*.md" (6 modes verified)
  • Recipe count: find ... -path "*recipes*" -name "*.yaml" (7 recipes verified)
  • Skill count: find ... -path "*skills*" -type d -mindepth 2 (7 bundle skills verified)
  • Context count: find ... -path "./context/*" -name "*.md" (5 files verified)
  • Line counts: wc -l on all content files (7,197 lines total)
  • Git log: git log --oneline (shallow clone, 1 commit visible)
  • Contributors: git log --format="%an" | sort | uniq -c (Brian Krabach: 1 visible commit)
  • Git remote: git remote -v confirmed github.com/microsoft/amplifier-bundle-superpowers

Gaps and caveats:

  • Git history is shallow (1 commit). Full commit history unavailable for velocity metrics.
  • "43k+ stars" for obra/superpowers is sourced from the bundle's README, not independently verified via GitHub API.
  • Upstream skill count ("14 original skills" per README) not independently counted.
  • Approval gate count in full-development-cycle recipe not independently inspected.

Primary contributor (bundle): Brian Krabach (100% of visible commits)

Original methodology: Jesse Vincent (obra/superpowers)

Get Started
Install once. Works with any bundle.
# Install (once) amplifier bundle add --app \ git+https://github.com/microsoft/amplifier-bundle-superpowers@main#subdirectory=behaviors/superpowers-methodology.yaml # Use it (any session, any bundle) amplifier /brainstorm # Design before code /write-plan # Create implementation plan /execute-plan # Build with subagent-driven development /debug # Systematic 4-phase debugging /verify # Evidence-based completion verification /finish # Branch completion (merge/PR/keep/discard) # Or run the full automated pipeline: "run the superpowers full development cycle recipe for [feature]"
Works with any bundle
Installs at the app level as a behavior. Layers the 5 specialist agents and methodology on top of your existing setup. No bundle switching required.
Full bundle available
Want modes, recipes, and skills too? Install the full bundle with amplifier bundle add --app ...@main.
Stop asking agents
to be disciplined.
Make it structural.
Bundle: github.com/microsoft/amplifier-bundle-superpowers
Original: github.com/obra/superpowers
Framework: github.com/microsoft/amplifier
More Amplifier Stories