Superpowers for Python microservices.

A Claude Code plugin that gives Claude deep knowledge of the Python ecosystem — Django, FastAPI, pytest, Pydantic, Celery, PostgreSQL, PostGIS — and first-class support for multi-service monorepos. Built on Anthropic's superpowers plugin: superpowers owns the engineering process (brainstorm → plan → execute → review), this plugin supplies the Python domain expertise and microservice orchestration.

Formerly compound-engineering-feat-python. Originally forked from Compound Engineering Plugin by Kieran Klaassen, fully rewritten for the Python ecosystem.

/workflows:brainstorm → /workflows:plan → /workflows:work → /workflows:review

Each step loads relevant skills (Django patterns, pytest conventions, PostgreSQL optimization…), spawns specialized review agents, and enforces quality gates — tests must pass, linting must be clean, pre-commit hooks must succeed — before anything ships.

flowchart LR
    B["/workflows:brainstorm"] -->|spec| P["/workflows:plan"]
    P -->|plan| W["/workflows:work"]
    W -->|branch + commits| R["/workflows:review"]
    R -->|todos| W
    S[superpowers plugin<br/>process primitives] -.-> B & P & W & R
    K[Python skills +<br/>review agents] -.-> B & P & W & R

For monorepos, every command detects your services (*/pyproject.toml), scopes work to the ones you pick, executes plans in dependency order, and propagates a <focus_context> block to every sub-agent so nested delegation never loses track of which service it is working on.

Requires the superpowers plugin (process primitives):

/plugin marketplace add anthropics/claude-plugins-official
/plugin install superpowers@claude-plugins-official

Then add this repo as a marketplace and install:

/plugin marketplace add weorbitant/compound-engineering-feat-python-plugin
/plugin install py-micro-superpowers@py-micro-superpowers

To install from a local clone, use /plugin marketplace add /path/to/checkout instead.

Checked automatically on session start — you'll see warnings for anything missing:

# Brainstorm a feature idea
/workflows:brainstorm add rate limiting to the payment API

# Plan the implementation
/workflows:plan add rate limiting with Redis sliding window

# Execute the plan
/workflows:work docs/superpowers/plans/2026-04-01-rate-limiting.md

# Review the changes
/workflows:review

Brainstorm specs land at docs/superpowers/specs/; plans at docs/superpowers/plans/.

Commands use the workflows: prefix to avoid collisions with Claude Code built-ins (/plan, /review).

Each workflow command:

• Loads project-specific skills from the py-micro-superpowers.local.md configuration
• Auto-detects multi-service monorepos and adjusts behavior accordingly
• Propagates service context to all sub-agents to prevent focus loss

Agents run as sub-processes during workflows, grouped by specialization. A 3-tier model strategy keeps cost proportional to stakes:

• Opus — high-stakes judgment: architecture, security, migrations, data integrity, performance
• Sonnet — domain review and research: framework reviewers, researchers, design agents
• Haiku — mechanical tasks: linting and type-checking

Reviewers work from baked-in checklists with PASS/FAIL code examples, backed by the plugin's skills for deep reference. When a finding hinges on version-specific library behavior they aren't certain of, they verify it against live docs through the bundled context7 MCP server rather than asserting from memory.

Skills provide domain knowledge that agents and workflows load on demand — reference documentation, conventions, and patterns. Process primitives (brainstorming, planning, TDD, git worktrees, parallel agents) come from the superpowers plugin.

• python-style — PEP 8, naming, imports, logging with emoji prefixes
• python-typing — Type hints, Pydantic v2, Protocol, generics

• django-patterns — Models, views, admin, signals, middleware, Django Ninja
• django-drf — DRF serializers, viewsets, permissions, authentication
• django-async — Celery task patterns, Django Channels

• fastapi-patterns — Routes, dependency injection, async patterns, auth
• fastapi-sqlalchemy — SQLAlchemy 2.0 async, Alembic migrations

• pytest-patterns — Fixtures, parametrize, mocking, async testing

• postgresql-patterns — Schema design, indexing, query optimization, monitoring
• postgis-patterns — Spatial queries, GeoDjango, GeoAlchemy2

• agent-native-architecture — Agent-native app patterns (action parity, context injection, shared workspace)
• frontend-design — Production-grade frontend interfaces

• microservice-focus — Service discovery, --services parsing, multi-service prompting, <focus_context> construction

• setup — Interactive project configuration for review agents and workflow skills

• commit — Conventional commits with gitmoji, logical grouping, pre-commit handling
• document-review — Structured document improvement
• file-todos — File-based todo tracking
• resolve-pr-parallel — Parallel PR comment resolution

• rclone — Cloud storage uploads (S3, R2, B2)
• agent-browser — CLI browser automation via Vercel's agent-browser
• gemini-imagegen — Image generation/editing with Google Gemini API

Supports 100+ frameworks including Django, FastAPI, SQLAlchemy, Celery, and more. Starts automatically when the plugin is enabled. If it doesn't, add it manually to .claude/settings.json:

{
  "mcpServers": {
    "context7": { "type": "http", "url": "https://mcp.context7.com/mcp" }
  }
}

Customize which skills load per workflow via py-micro-superpowers.local.md in your project root (a legacy compound-engineering.local.md is still honored):

---
workflow_skills:
  brainstorm: [django-patterns, my-company-domain]
  plan: [django-patterns]
  work: [django-patterns, pytest-patterns]
  review: [django-patterns, pytest-patterns]
---

Skills are additive — loaded alongside each command's built-in skills. Project-local skills in .claude/skills/ can also be referenced by name.

Run /setup — it auto-detects your stack (Django, FastAPI, DRF, Celery, SQLAlchemy, PostgreSQL, PostGIS, Pydantic) and writes the review_agents roster used by /workflows:review into py-micro-superpowers.local.md.

Focus Gate logic lives in the microservice-focus skill, invoked once by each workflow command:

• Auto-detection — discovers services via */pyproject.toml at root level
• Focus Gate — each workflow command prompts for relevant services (or accepts --services)
• Dependency-aware execution — plans with services: YAML frontmatter execute in topological order (wavefront pattern)
• Per-service context — loads each service's README, dependencies, and structure before acting
• Stack-aware routing — Django patterns for Django services, FastAPI for FastAPI, per-service agent rosters

All workflow commands accept --services for automated invocation (skips all interactive prompts):

/workflows:brainstorm --services order-service,payment-service "add cross-service event bus"

/workflows:work is the engine that turns plans into shipped code:

1. Load context — project workflow skills + microservice focus gate (execution order for multi-service plans)
2. Delegate execution — superpowers:subagent-driven-development runs the task loop with per-task commits and reviews
3. Python quality gate (mandatory) — full pytest suite + ruff + mypy + pre-commit hooks must all pass; loops until clean
4. Ship — commit via the commit skill, push, open a PR that includes a Post-Deploy Monitoring & Validation plan

Never ships with failing tests, never skips hooks.

scripts/validate.sh runs the structural checks CI enforces on every push: frontmatter integrity, reference-link resolution, script compilation, stale-reference guards, and component-count consistency.

See CHANGELOG.md for detailed version history.

Current version: 4.0.0 — renamed from compound-engineering-feat-python; the repository URL is unchanged.

Contributions are welcome. The plugin is open source under the MIT license.

1. Fork the repo and create a feature branch
2. Follow the conventions encoded in the plugin's own skills (PEP 8, type hints, pytest, conventional commits)
3. Run ./scripts/validate.sh and the plugin against itself (/workflows:review) before opening a PR
4. Open a PR against main — include a short rationale and any relevant plan/spec docs

Issues, ideas, and discussion: GitHub Issues.

MIT — See LICENSE

Original work copyright (c) 2025 Kieran Klaassen. Modifications copyright (c) 2026 BaronVonSario.