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:

Run context-mode doctor to verify the hook dependency is installed correctly
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:

Analyzes your request to understand intent
Routes to the appropriate skill(s)
Coordinates skill chains for complex tasks
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:

Running tests
Running linting
Building successfully
Manual verification
Checking for regressions

Execution Model

Session loads .agent/AGENTS.md rules
/mega-mind analyzes and routes requests
Design work flows through brainstorming → planning → execution
All work tracked in task tracker
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:

context-mode is on PATH (the hook dependency)
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:

Create a new directory in .agent/skills/

Add a SKILL.md file with proper frontmatter:

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

Include instructions and examples
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.

Name		Name	Last commit message	Last commit date
.agent		.agent
.github/workflows		.github/workflows
docs-site		docs-site
scripts		scripts
src/mega_mind		src/mega_mind
tests		tests
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
README.md		README.md
USAGE.md		USAGE.md
mkdocs.yml		mkdocs.yml
pyproject.toml		pyproject.toml

Latest commit

History

Folders and files

Repository files navigation