Metadata-Version: 2.5
Name: mmo
Version: 1.0.3
Summary: The most powerful AI skill system on GitHub — 53 Gold Standard v2.0 skills, 11 agent personas, and 9 executable workflows for any AI coding agent (Antigravity, Claude Code, Copilot, OpenCode, Codex, pi, and Agent Skills-compatible tools).
Author-email: Plamen Ivanov <paco.iwanow@gmail.com>
Requires-Python: >=3.10
Requires-Dist: click>=8.1.0
Description-Content-Type: text/markdown

# 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](https://github.com/obra/superpowers) with the domain expertise of [Virtual Company](https://github.com/k1lgor/virtual-company) and [Everything-Claude-Code](https://github.com/affaan-m/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](https://agentskills.io))

## 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](./.agent/shared/GOLD-STANDARD-SKILL.md)** 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](./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

<!-- BEGIN GENERATED: skill-inventory -->
<!-- Generated by scripts/render-skills.py — DO NOT EDIT BY HAND -->
### 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. |
<!-- END GENERATED: skill-inventory -->
## 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

```bash
# 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+

```bash
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

```bash
# 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:

```json
{
  "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](./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](./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](https://github.com/rtk-ai/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:

```bash
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](./USAGE.md) for the full installation guide.

### CLI Reference

```bash
# 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:

```bash
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`:

```bash
# 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:

   ```markdown
   ---
   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](https://github.com/obra/superpowers) by obra - Core workflow philosophy
- [antigravity-superpowers](https://github.com/skainguyen1412/antigravity-superpowers) by skainguyen1412 - Antigravity adaptation
- [virtual-company](https://github.com/k1lgor/virtual-company) by k1lgor - Domain expertise skills
- [Everything-Claude-Code](https://github.com/affaan-m/everything-claude-code) by affaan-m - Claude Code adaptation
- [RTK](https://github.com/rtk-ai/rtk) - Token optimization CLI

---

## License

MIT License - Free to use and modify.
