Mega-Mind Skills System v1.0.1

The most powerful skill system for AI coding assistants — 53 Gold Standard skills, 11 agents, 9 workflows.

This is a comprehensive skill-based workflow system that combines the disciplined development workflows of Superpowers with the domain expertise of Virtual Company and Everything-Claude-Code. Upgraded to Gold Standard v2.0 — every skill meets a rigorous 12-section specification with blocking violations, verification gates, performance/cost models, anti-patterns, and structured examples, and the whole system is machine-validated in CI. It provides structured, reliable behavior for AI coding assistants across the entire software development lifecycle.

Compatible with: Any AI coding agent (Antigravity · GitHub Copilot (VS Code) · Claude Code · Cursor · OpenCode · Codex · pi · and all tools supporting the Agent Skills open standard)

Overview

Mega-Mind v1.0 brings together 53 Gold Standard skills, 11 agent personas, and 9 workflows organized across the full software development lifecycle — from planning through production operations. All skills meet the Gold Standard SKILL.md v2.0 specification, verified machine-checkable in CI.

New in v1.0.1 (2026-08-11): The routing matrix, skills listing, and every skill catalog table are now generated artifacts — rendered from .agent/shared/skills-manifest.json (inventory) and .agent/shared/routing.json (routing) by scripts/render-skills.py, and validated by a manifest-driven validator (scripts/validate-skill-system.py), an end-to-end mmo check gate, and a CI workflow. Counts, membership, and version claims can no longer drift from the skills themselves. See CHANGELOG.md for details.

Versioning

Three distinct version numbers are in play — don't conflate them:

Dimension	Version	Where it lives
Package release	1.0.1	pyproject.toml / mmo --version — the pip package
Gold Standard spec	2.0	.agent/shared/GOLD-STANDARD-SKILL.md — the SKILL.md template
Skill versions	2.0.0 (mega-mind: 2.1.0)	each skill's frontmatter version: — must equal its latest ## Changelog row (validator-enforced)

Skills are at Gold Standard v2.0 and each skill carries its own 2.0.0 frontmatter version; the mmo package that ships them is at 1.0.1.

The Mega-Mind Orchestrator

The master controller that routes requests and coordinates skill chains (counted in Core Workflow below):

• mega-mind - Primary entry point via /mega-mind command

Core Workflow (12)

Skill	Description
brainstorming	Structured exploration before committing to an approach.
executing-plans	Disciplined plan execution with dependency graph resolution, review gates, progress tracking, and quality cleanup.
finishing-a-development-branch	Clean branch wrap-up with final verification, rebase, PR creation, merge options, and post-merge cleanup.
mega-mind	Master orchestrator for the Mega-Mind skill system — analyzes requests, coordinates multiple skills, and manages complex workflows.
multi-execute	Orchestrated multi-agent implementation workflow that translates an approved multi-plan artifact into production code.
multi-plan	Multi-model collaborative planning for high-complexity tasks using parallel Technical and UX analysis backends.
receiving-code-review	Systematic handling of code review feedback — categorize, respond, fix, and follow up.
requesting-code-review	Structured review flow with pre-review checklists, review templates, and PR size discipline.
test-driven-development	Write tests first, implement second, refactor third — the RED-GREEN-REFACTOR cycle.
using-git-worktrees	Parallel branch management with Git worktrees — work on multiple features simultaneously without stashing or switching.
verification-loop	Scope-aware tiered verification system (Tier 1 Surface / Tier 2 Standard / Tier 3 Deep) with continuous quick-check mode.
writing-plans	Create detailed, step-by-step implementation plans with dependency annotations and verification checkpoints.

Domain Expert (29)

Skill	Description
backend-architect	Designs server-side architecture, API contracts, and data models for production-grade services.
ci-config-helper	Designs and configures CI/CD pipelines for GitHub Actions and GitLab CI with caching, matrix builds, security scanning, and deployment gating.
code-polisher	Refactors and improves code quality with measurable before/after improvements in readability, complexity, and duplication.
data-analyst	Senior data analyst skill for extracting statistically rigorous insights from structured and semi-structured data.
data-engineer	Senior data engineering skill for designing, building, and operating reliable data pipelines at scale.
database-migrations	Zero-downtime database migration patterns for Prisma, Drizzle, Django, and Go.
debugging	Unified debugging skill with two modes — Rapid Fix for pattern-matching known bug types, and Systematic for hypothesis-driven root cause analysis.
doc-writer	Generate comprehensive documentation including READMEs, API docs, inline comments, architecture docs, and user guides.
docker-expert	Container architecture and optimization specialist for writing production-grade Dockerfiles, composing multi-service stacks, and hardening container security.
e2e-test-specialist	Creates comprehensive end-to-end test suites with Playwright and Cypress using Page Object Model and data-testid selectors.
eval-harness	Automated evaluation harness for measuring agent and LLM performance, preventing regressions, and enabling eval-driven development.
frontend-architect	Designs component architecture, state management strategy, and UI patterns for React/Vue/Next.js applications.
infra-architect	Designs and implements cloud infrastructure using Infrastructure as Code with Terraform and Pulumi.
k8s-orchestrator	Designs and deploys Kubernetes manifests, Helm charts, and production-grade cluster configurations with deployment strategies, health probes, and rollback planning.
legacy-archaeologist	Safely understands, documents, and modernises legacy codebases through systematic archaeology and characterisation.
migration-upgrader	Executes safe, systematic version upgrades and framework migrations with rollback planning and automated breaking change detection.
ml-engineer	End-to-end machine learning engineering covering classical pipelines, LLM/GenAI systems, experiment tracking, hyperparameter tuning, model serving, and production monitoring.
mobile-architect	Designs cross-platform and native mobile application architectures with React Native and Flutter.
observability-specialist	Builds comprehensive observability systems covering metrics, structured logging, distributed tracing, and actionable alerting.
performance-profiler	Optimization and performance tuning covering frontend, backend, database, and infrastructure profiling.
product-manager	Task breakdown and user story creation for product planning and backlog management.
python-patterns	Production-grade Python design patterns, modern tooling, and idiomatic code standards for Python 3.10+.
regex-vs-llm-structured-text	Decision framework and hybrid implementation for regex vs LLM text parsing.
search-vector-architect	Design and implement production-grade semantic search and RAG systems.
security-reviewer	Comprehensive security audits and vulnerability checks covering OWASP Top 10 (2025), CWE mappings, threat modeling, supply chain security, and code-level vulnerability detection.
tech-lead	Drives project architecture, technical decisions, and team coordination across the full software delivery lifecycle.
test-genius	Writes comprehensive unit and integration tests using AAA pattern, mocking, and coverage-driven quality gates.
ux-designer	UI/UX flows and design systems covering user research, design tokens, component libraries, accessibility (WCAG 2.1 AA), and user flow design.
workflow-orchestrator	Complex task scheduling and orchestration for multi-step workflow automation.

Meta & Learning (8)

Skill	Description
autonomous-loops	Autonomous loop patterns for multi-step AI workflows without human intervention.
autoresearch-loop	Karpathy-style automated self-improvement loop for the .agent/ skill system.
continuous-learning-v2	Instinct-based learning system that automatically extracts and evolves patterns from AI sessions.
cost-aware-llm-pipeline	LLM cost optimization patterns for model routing, budget tracking, and prompt caching.
iterative-retrieval	Progressive context refinement pattern for subagents and RAG pipelines.
search-first	Research-before-coding discipline that always searches for existing solutions before writing code.
skill-generator	Create, debug, and evolve SKILL.md files for any AI coding agent skill system.
skill-stocktake	Quality audit and library maintenance for the skill system.

Token Optimization (4)

Skill	Description
content-hash-cache-pattern	SHA-256 content hash caching for file processing to avoid redundant work and reduce LLM costs.
context-optimizer	Context window preservation and session continuity skill for AI coding agents.
plankton-code-quality	Write-time code quality enforcement using the Plankton methodology — a three-phase PostToolUse hook pipeline.
rtk	RTK (Rust Token Killer) CLI proxy that reduces LLM token consumption by 60-90% on common development commands.

Agent Personas (11)

Deep-dive specialized personas for complex tasks. Invoked via routing matrix or /mega-mind route:

Development: tech-lead, planner, architect Quality & Testing: code-reviewer, qa-engineer, accessibility-auditor, adversarial-tester Security & Compliance: security-reviewer, data-privacy-officer Operations & Releases: incident-commander, release-manager

Executable Workflows (9)

Pre-defined chains covering the full lifecycle:

Workflow	Purpose
brainstorm	Structured exploration
write-plan	Create implementation plans
execute-plan	Execute with disciplined tracking
high-complexity-dev	Multi-agent orchestration
review	Structured code review
debug	Root cause analysis
ship	Merge, deploy, branch cleanup
incident-response	Production incident lifecycle
release	Versioning, rollout, monitoring

---

Quick Start

1. Install the CLI

# pip
pip install mmo

# pipx (recommended — isolated, globally available)
pipx install mmo

# uv
uv tool install mmo

# Or run directly without installation
uvx mmo

2. Install the hook prerequisite: context-mode

mmo init writes hooks.json files for supported environments. Those hooks call the context-mode CLI, so hook integration will not work unless context-mode is installed first.

Prerequisites: Node.js 18+

npm install -g context-mode
context-mode doctor

If context-mode doctor fails, fix that before relying on the generated hooks.

3. Initialize skills in your project

# From your project root
cd /path/to/your/project

# Standard install (.agent/ only)
uvx mmo init

# Install only for Claude Code (no .agent/)
uvx mmo init --claude

# Install only for GitHub Copilot (no .agent/)
uvx mmo init --copilot

# Install only for OpenCode (no .agent/)
uvx mmo init --opencode

# Install only for Codex (no .agent/)
uvx mmo init --codex

# Install only for pi-coding-agent (no .agent/)
uvx mmo init --pi

# Overwrite an existing installation
uvx mmo init --force
uvx mmo init --copilot --claude --opencode --codex --pi --force

Behavior summary:

• mmo init → creates .agent/
• mmo init --claude → creates CLAUDE.md and .claude/, not .agent/
• mmo init --copilot --claude → creates .github/, CLAUDE.md, and .claude/, not .agent/
• Only GitHub Copilot agent personas use the .agent.md suffix

The --claude flag adds:

• CLAUDE.md — project rules (mirrors AGENTS.md)
• .claude/skills/ — all 53 skills in the Agent Skills standard directory
• .claude/commands/ — Mega-Mind workflow files exposed as Claude slash commands
• .claude/hooks/hooks.json — context-mode hook integration

The --copilot flag adds a .github/ directory with:

• copilot-instructions.md — global instructions loaded automatically
• skills/<name>/SKILL.md — all 53 skills available as / slash commands
• agents/<name>.agent.md — custom agent personas for VS Code
• hooks/hooks.json — context-mode hook integration

The --opencode flag adds:

• AGENTS.md and CLAUDE.md at project root
• .opencode/skills/ — all skills
• .opencode/commands/ — Mega-Mind workflow files exposed as OpenCode slash commands
• .opencode/hooks/hooks.json — context-mode hook integration

The --codex flag adds:

• AGENTS.md at project root
• .codex/skills/ — all skills
• .codex/hooks/hooks.json — context-mode hook integration

The --pi flag adds:

• AGENTS.md and CLAUDE.md at project root
• .pi/skills/ — all 53 skills in pi's project skill directory
• .pi/prompts/ — Mega-Mind workflow files exposed as pi prompt templates
• .pi/agents/ — agent personas as prompt templates
• .pi/shared/ — shared reference docs
• .pi/hooks/hooks.json — context-mode hook integration
• .agents/skills/ — cross-tool Agent Skills standard path (pi scans this)

The generated hooks.json files call commands such as:

{
  "command": "context-mode hook claude-code pretooluse"
}

If context-mode is not installed and available on your PATH, those hooks will fail.

📖 For full details see USAGE.md

4. Verify the installation

Once initialized:

1. Run context-mode doctor to verify the hook dependency is installed correctly
2. Use the /verify command (triggered by the verification-loop skill) to ensure the Mega-Mind files are correctly installed

📖 For full installation details see USAGE.md

---

Using Mega-Mind

The /mega-mind Command

The /mega-mind command is your primary entry point to the skill system. It acts as an intelligent orchestrator that:

1. Analyzes your request to understand intent
2. Routes to the appropriate skill(s)
3. Coordinates skill chains for complex tasks
4. Tracks progress throughout

Available Commands

/mega-mind status             - Show current session state
/mega-mind skills             - List all available skills
/mega-mind workflows          - List available workflows
/mega-mind route <request>    - Analyze and route a request
/mega-mind execute <workflow> - Execute a named workflow
/mega-mind help               - Show help message

Direct Skill Commands

Command	Skill	Purpose
/brainstorm	brainstorming	Explore approaches before deciding
/plan	writing-plans	Create implementation plan
/execute	executing-plans	Execute plan with tracking
/debug	debugging	Debug systematically
/review	requesting-code-review	Request code review
/ship	finishing-a-development-branch	Deploy to production
/tdd	test-driven-development	Test-first development
/verify	verification-loop	Verify before marking done

Example Usage

User: /mega-mind I need to add user authentication with OAuth

🧠 Mega-Mind Orchestration
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📋 Request Analyzed: New feature - User Authentication with OAuth

🔄 Routed to skill chain:
   1. tech-lead                        → Define architecture
   2. brainstorming                    → Explore OAuth providers
   3. backend-architect                → Design auth API
   4. writing-plans                    → Create implementation plan
   5. test-driven-development          → Write auth tests
   6. backend-architect                → Implement auth service
   7. frontend-architect               → Implement login UI
   8. security-reviewer                → Security audit
   9. verification-loop                → Verify

📍 Starting with: tech-lead

---

File Structure

mega-mind-skills/
├── README.md                    # Main documentation (this file)
├── USAGE.md                     # Installation guide
├── CHANGELOG.md                 # Release history
├── pyproject.toml               # Python package config
│
├── scripts/
│   ├── build-manifest.py        # Generates .agent/shared/skills-manifest.json
│   ├── render-skills.py         # Renders generated docs regions (matrix, listings)
│   ├── validate-skill-system.py # Manifest-driven skill system validator
│   ├── sync-assets.py           # Syncs .agent/ → src/mega_mind/assets/ (hash-verified)
│   ├── backup-task-state.sh     # Timestamped task.md backups
│   └── fix-*.py                 # Portability & normalization fixers
│
├── src/mega_mind/
│   ├── cli.py                   # CLI entry point (mmo init / doctor / check)
│   ├── installer.py             # Multi-platform installer (checksum-verified)
│   └── assets/                  # Distribution copies of .agent/
│
└── .agent/
    ├── AGENTS.md                # Master contract and rules
    ├── hooks/
    │   └── hooks.json           # context-mode hooks registry
    ├── instincts/               # Learned patterns & observations
    ├── skills/                  # 53 SKILL.md files (one per skill)
    ├── shared/                  # DE-SLOPPIFY.md, RTK_GUIDE.md, VERIFICATION-GATE.md
    │
    ├── workflows/               # 9 executable workflow chains
    │   ├── brainstorm.md        # Structured exploration
    │   ├── write-plan.md        # Implementation planning
    │   ├── execute-plan.md      # Disciplined execution
    │   ├── high-complexity-dev.md # Multi-agent orchestration
    │   ├── review.md            # Code review
    │   ├── debug.md             # Root cause analysis
    │   ├── ship.md              # Merge and deploy
    │   ├── incident-response.md # Production incidents
    │   └── release.md           # Versioning and rollout
    │
    └── agents/                  # 11 specialized agent personas
        ├── architect.md         # System design and ADRs
        ├── planner.md           # Task decomposition
        ├── tech-lead.md         # Technical leadership
        ├── code-reviewer.md     # Code quality review
        ├── qa-engineer.md       # Testing and verification
        ├── security-reviewer.md # Security vulnerability audit
        ├── accessibility-auditor.md  # WCAG compliance
        ├── adversarial-tester.md     # Chaos and fuzz testing
        ├── data-privacy-officer.md   # GDPR/CCPA/SOC2
        ├── incident-commander.md     # Incident response
        └── release-manager.md        # Release coordination

---

Full Routing Matrix

The request-type mapping is curated as machine-readable data in .agent/shared/routing.json (54 routes, 11 chains) and rendered into the routing matrix diagram in .agent/skills/mega-mind/SKILL.md by scripts/render-skills.py. The manifest-driven validator (scripts/validate-skill-system.py) verifies that every route target resolves to a real skill or agent and that no skill is left unrouted — the matrix can never silently drift from the library again. Use /mega-mind route <request> to let the orchestrator dispatch automatically.

---

Workflows

Standard Development Chain (The Z-Pattern)

search-first → tech-lead → brainstorming → writing-plans → test-driven-development →
executing-plans → verification-loop → requesting-code-review →
finishing-a-development-branch → continuous-learning-v2

High-Complexity Chain (Phase 3 Orchestration)

search-first → architect → multi-plan → [Approval] → multi-execute →
verification-loop → security-reviewer → finishing-a-development-branch

Autonomous Loop Chain

writing-plans → autonomous-loops → [Loop Execution] → verification-loop →
continuous-learning-v2

Incident Response Chain

incident-commander → [Mitigation] → debugging → test-driven-development →
verification-loop → finishing-a-development-branch

Release Chain

release-manager → verification-loop → finishing-a-development-branch →
observability-specialist → continuous-learning-v2

Bug Fix

debugging → test-driven-development →
verification-loop → finishing-a-development-branch → continuous-learning-v2

Accessibility Audit Chain

accessibility-auditor → [Fixes] → verification-loop → requesting-code-review →
finishing-a-development-branch

Adversarial Test Chain

adversarial-tester → [Chaos/Fuzz] → debugging → executing-plans →
verification-loop → finishing-a-development-branch

---

Key Concepts

Task Tracking

All tasks are tracked in <project-root>/docs/plans/task.md:

Task ID	Description	Status	Priority	Dependencies
1	Example task	pending	high	-

Status values: pending, in_progress, completed, blocked

Verification Before Completion

Never mark a task as complete without:

1. Running tests
2. Running linting
3. Building successfully
4. Manual verification
5. Checking for regressions

Execution Model

1. Session loads .agent/AGENTS.md rules
2. /mega-mind analyzes and routes requests
3. Design work flows through brainstorming → planning → execution
4. All work tracked in task tracker
5. Nothing marked done without verification

RTK Token Optimization

When RTK is installed, CLI commands are automatically optimized:

Original	RTK-Optimized	Savings
git log	rtk git log	85%
cargo test	rtk cargo test	90%
npm test	rtk npm test	90%
pytest	rtk pytest	90%

Install RTK:

cargo install rtk
# or
curl -sSL https://github.com/rtk-ai/rtk/releases/latest/download/rtk-$(uname -s)-$(uname -m) -o /usr/local/bin/rtk
chmod +x /usr/local/bin/rtk

---

Installation

See USAGE.md for the full installation guide.

CLI Reference

# Install skills into current directory (.agent/ only when no platform flags are used)
uvx mmo init

# Also install for GitHub Copilot (VS Code)
uvx mmo init --copilot

# Also install for Claude Code
uvx mmo init --claude

# Also install for OpenCode
uvx mmo init --opencode

# Also install for Codex
uvx mmo init --codex

# Also install for pi-coding-agent
uvx mmo init --pi

# Install into a specific path
uvx mmo init /path/to/project
uvx mmo init /path/to/project --copilot

# Overwrite existing installation
uvx mmo init --force
uvx mmo init --copilot --claude --opencode --codex --pi --force

# Diagnose the environment + verify an installed tree against the manifest
uvx mmo doctor
uvx mmo doctor /path/to/project

# Maintainer gate: manifest, generated docs, validator, sync, sandboxed install
uvx mmo check        # (run from the repo root)

# Show CLI version
uvx mmo --version

mmo doctor checks two things and exits non-zero if either fails:

1. context-mode is on PATH (the hook dependency)
2. every installed platform's skills match the hashes in skills-manifest.json

mmo check is the repository-side quality gate used by CI: it verifies the manifest is fresh, all generated doc regions match their source data, the skill system passes validation, .agent/ and the packaged assets/ are byte-identical, and a sandboxed install of all six platform layouts succeeds.

Hook prerequisite

The installer writes hooks.json files for .agent/, .github/, .claude/, .opencode/, and .codex/. Those hooks invoke context-mode, so install it first:

npm install -g context-mode
context-mode doctor

If context-mode is missing from your PATH, the installed hooks will not work.

Validate Installation

Two complementary checks after mmo init:

# 1. CLI-level: hook dependency + installed-tree integrity vs the manifest
mmo doctor

# 2. Assistant-level: run /verify (verification-loop skill) in your AI assistant

mmo doctor verifies:

• Core workflow / domain expert / meta / token skill existence (against skills-manifest.json hashes)
• Workflows and agent personas presence
• context-mode hook dependency on PATH
• Content integrity of every installed SKILL.md

The repository itself is gated by mmo check and the validate.yml CI workflow (manifest freshness, generated-docs freshness, validator, sync parity, sandboxed install, and the pytest suite under tests/).

---

Contributing

To add new skills:

1. Create a new directory in .agent/skills/

2. Add a SKILL.md file with proper frontmatter:

   ---
   name: skill-name
   description: What this skill does
   triggers:
     - "/trigger"
     - "keyword"
   ---
   

3. Include instructions and examples

4. Run tests to verify

---

Credits

This project combines and adapts:

• Superpowers by obra - Core workflow philosophy
• antigravity-superpowers by skainguyen1412 - Antigravity adaptation
• virtual-company by k1lgor - Domain expertise skills
• Everything-Claude-Code by affaan-m - Claude Code adaptation
• RTK - Token optimization CLI

---

License

MIT License - Free to use and modify.