mega-mind-skills

Autonomous loop patterns for multi-step AI workflows without human intervention. Use when building CI-style pipelines, parallel agent coordination, or continuous autonomous development cycles. Covers 5 loop architectures (Sequential Pipeline, Infinite Agentic Loop, Continuous PR Loop, De-Sloppify Pass, RFC-Driven DAG) with decision matrix.

Karpathy-style automated self-improvement loop for the .agent/ skill system. Use to measure skill quality, identify weaknesses through structured evals, generate targeted improvements, and verify them. The AI equivalent of gradient descent applied to agent instructions — works through Measure -> Find Weaknesses -> Generate Improvements -> Score -> Regression Check -> Iterate.

Designs server-side architecture, API contracts, and data models for production-grade services. Use for backend architecture decisions, service/repository implementation, and designing REST/GraphQL API contracts. Differentiator: layered architecture with documented ADRs, machine-readable API contracts (OpenAPI/GraphQL), and database patterns with connection management, transactions, and migration strategies.

Structured exploration before committing to an approach. Use when facing ambiguous problems, new features, architectural decisions, or any situation where multiple approaches are possible. Differentiator: Mandatory search-first integration before any idea generation, and a hard user-confirmation gate that prevents premature implementation.

Designs and configures CI/CD pipelines for GitHub Actions and GitLab CI with caching, matrix builds, security scanning, and deployment gating. Use for any continuous integration or deployment pipeline task — from initial setup through production release gating. Distinguishes itself through hardened pipeline patterns with cache optimization, secret management, flaky test detection, and staging-gated deployment.

Refactors and improves code quality with measurable before/after improvements in readability, complexity, and duplication. Use for cleaning up and optimising existing code, reducing cyclomatic complexity, and extracting maintainable patterns. Differentiator: behaviour-preserving refactoring with characterisation tests, before/after code examples for 7+ common code smells, and structured verification gates.

SHA-256 content hash caching for file processing to avoid redundant work and reduce LLM costs. Use when processing files (extraction, transformation) to avoid redundant work and reduce costs. Covers content-hash-based cache key design, frozen dataclass entries, file-based cache storage with O(1) lookup, and service layer wrapper pattern.

Context window preservation and session continuity skill for AI coding agents. Use proactively whenever commands, files, or API responses would produce more than ~20 lines of output, and reactively when context is nearing exhaustion or a session has been compacted. Orchestrates the context-mode MCP plugin (ctx_execute, ctx_index, ctx_search, ctx_batch_execute, ctx_execute_file, ctx_fetch_and_index) to keep raw data out of the LLM context window and retrieve only what's needed on demand.

Instinct-based learning system that automatically extracts and evolves patterns from AI sessions. Use to build a growing library of project-specific preferences and workflows that improve the AI's effectiveness over time. Covers instinct extraction with confidence weighting, conflict detection, instinct decay, and promotion of confirmed patterns to skills/workflows.

LLM cost optimization patterns for model routing, budget tracking, and prompt caching. Use when building AI pipelines where cost matters or when routing tasks to the right model tier. Covers immutable cost tracking, narrow retry logic, prompt caching, and model routing by task complexity with budget enforcement.

Senior data analyst skill for extracting statistically rigorous insights from structured and semi-structured data. Use for analytics, reporting, and decision-support work — A/B tests, cohort analysis, funnel analysis, and insight narratives. Covers EDA, significance testing with effect sizes, bias detection, SQL analysis patterns, and reproducible reporting.

Senior data engineering skill for designing, building, and operating reliable data pipelines at scale. Use when implementing ETL/ELT pipelines, streaming architectures, or data quality frameworks. Covers batch and streaming (Kafka, Flink, dbt), quality (Great Expectations), schema evolution, incremental loading, idempotency, and pipeline observability.

Zero-downtime database migration patterns for Prisma, Drizzle, Django, and Go. Use when altering tables, adding columns, creating indexes, or running data backfills on a live database. Covers Expand-Migrate-Contract strategy, CONCURRENTLY index creation, batched data migrations, and safety protocols for schema changes.

Unified debugging skill with two modes — Rapid Fix for pattern-matching known bug types, and Systematic for hypothesis-driven root cause analysis. Use for any debugging task: crash reports, stack traces, performance issues, race conditions, or multi-system failures. Distinguishes itself through a formal hypothesis-driven loop, reproduction-first discipline, and a regression test requirement that closes the loop.

Generate comprehensive documentation including READMEs, API docs, inline comments, architecture docs, and user guides. Use for all documentation needs — from quick inline comments to full project documentation sets. Covers multiple documentation types with templates, example-driven approach, audience-aware writing, and self-verification with runnable code examples.

Container architecture and optimization specialist for writing production-grade Dockerfiles, composing multi-service stacks, and hardening container security. Use for any Docker or container orchestration work — from initial Dockerfile creation through production hardening. Distinguishes itself through multi-stage build patterns across 3 languages, aggressive layer caching strategies, non-root user hardening, and complete dev+produce Compose stacks.

Creates comprehensive end-to-end test suites with Playwright and Cypress using Page Object Model and data-testid selectors. Use for any browser-level testing — user flows, checkout, authentication, and visual regression. Distinguishes itself through flakiness-elimination patterns, cross-browser matrix enforcement, and zero-tolerance for timing-based waits.

Automated evaluation harness for measuring agent and LLM performance, preventing regressions, and enabling eval-driven development. Use when setting up systematic quality gates for AI-assisted workflows or when you need measurable pass/fail criteria for non-deterministic outputs. Distinguishes itself through pass@k/pass^k metrics, LLM-as-judge patterns, cost tracking per eval run, and CI/CD integration with coverage mapping.

Disciplined plan execution with dependency graph resolution, review gates, progress tracking, and quality cleanup. Use when you have a plan to implement and need to track progress systematically, including complex sequential tasks with ordered dependencies. Differentiator: Includes dependency graph decomposition, context preservation snapshots between steps, interruption recovery protocol, and mandatory De-Sloppify pass after every implementation step.

Clean branch wrap-up with final verification, rebase, PR creation, merge options, and post-merge cleanup. Use when a feature branch is complete, reviewed, and ready to merge into the main branch. Differentiator: Presents 3 merge strategies (squash/merge commit/rebase) with guidance on when to use each, and enforces CI-green-before-merge and review-approval-before-merge gates.

Designs component architecture, state management strategy, and UI patterns for React/Vue/Next.js applications. Use for frontend architecture decisions, component design, responsive layout planning, and state management selection. Differentiator: atomic design methodology with ADR-tracked component decisions, performance budgets, and accessibility-by-default patterns.

Designs and implements cloud infrastructure using Infrastructure as Code with Terraform and Pulumi. Use for cloud architecture design, IaC provisioning, and infrastructure scaling decisions. Differentiator: security-by-default patterns (IAM least privilege, network segmentation, encryption), remote state management, and pre/post-apply verification gates with policy-as-code scanning.

Progressive context refinement pattern for subagents and RAG pipelines. Use when spawning subagents that need codebase context they cannot predict upfront, or when "send everything" exceeds context limits. Covers a 4-phase DISPATCH -> EVALUATE -> REFINE -> LOOP cycle that progressively narrows to exactly the right files in at most 3 cycles.

Designs and deploys Kubernetes manifests, Helm charts, and production-grade cluster configurations with deployment strategies, health probes, and rollback planning. Use for any Kubernetes deployment task — from initial manifests through production readiness. Distinguishes itself through complete deployment strategies (rolling, blue-green, canary), health probe patterns with startup/liveness/readiness, and a comprehensive production readiness checklist.

Safely understands, documents, and modernises legacy codebases through systematic archaeology and characterisation. Use for working with undocumented legacy systems, planning safe refactoring, and gradually modernising old code. Differentiator: produces a System Map (data flow, dependency tree, critical paths) before touching code, then applies characterisation tests (golden master/snapshot) that capture current behaviour including side effects.

Master orchestrator for the Mega-Mind skill system — analyzes requests, coordinates multiple skills, and manages complex workflows. Invoke when the task spans domains, requires a skill chain, or needs multi-agent orchestration. Differentiator: intelligent request routing via a 50+ entry routing matrix, 10+ pre-defined workflow chains, and a structured handoff protocol that makes this the highest-coverage orchestrator skill in the ecosystem.

Executes safe, systematic version upgrades and framework migrations with rollback planning and automated breaking change detection. Use for major version bumps, framework migrations, and broad dependency upgrades that require planning and risk management. Differentiator: phased migration plans with git-tagged rollback points at every phase, automated breaking change detection via codemods/ast-grep, and health check scripts that must produce identical pre/post output.

End-to-end machine learning engineering covering classical pipelines, LLM/GenAI systems, experiment tracking, hyperparameter tuning, model serving, and production monitoring. Use when building, evaluating, or deploying any ML or AI model — from sklearn classifiers to fine-tuned transformers and LLM-powered applications. Emphasizes reproducibility, baselines-first, evaluation harnesses, and production-grade monitoring for both classical ML and GenAI systems.

Designs cross-platform and native mobile application architectures with React Native and Flutter. Use for mobile app architecture, navigation design, state management, and platform-specific optimisation. Differentiator: dual-framework expertise (React Native + Flutter) with Clean Architecture patterns, performance optimisation for low-RAM devices, offline-first data strategies, and platform-specific code organisation.

Orchestrated multi-agent implementation workflow that translates an approved multi-plan artifact into production code. Use when implementing complex features defined by an approved multi-plan artifact, especially full-stack tasks or high-stakes modifications. Generates parallel Technical and UX prototypes, refactors them to project standards, applies De-Sloppify pass, runs self-verification per step, and completes with a parallel multi-model audit.

Multi-model collaborative planning for high-complexity tasks using parallel Technical and UX analysis backends. Use when breaking down highly complex or ambiguous feature requests that span multiple subsystems. Distributes requirements to specialized analysis perspectives, synthesizes outputs into a conflict-resolved unified implementation plan with risk matrix, verification steps, and stop-loss criteria.

Builds comprehensive observability systems covering metrics, structured logging, distributed tracing, and actionable alerting. Use for any monitoring or observability task — from initial instrumentation through production dashboards and on-call runbooks. Distinguishes itself through the three-pillar model (metrics, logs, traces) with concrete code implementations, SLO-based alerting, and zero-PII enforcement in telemetry data.

Optimization and performance tuning covering frontend, backend, database, and infrastructure profiling. Use for performance analysis and optimization when a measurable baseline exists. Covers flame graph profiling, Lighthouse audits, N+1 query detection, caching strategies, and before/after measurement verification.

Write-time code quality enforcement using the Plankton methodology — a three-phase PostToolUse hook pipeline. Use when setting up or operating automated code quality enforcement on a project to auto-format, collect lint violations, and autonomously delegate fixes to a subagent. Enforces zero-tolerance on linter rule suppression and config weakening, with violation budget tracking and language-gated linting across TypeScript, Python, Go, Rust, and more.

Task breakdown and user story creation for product planning and backlog management. Use for product planning tasks — user stories, sprint planning, prioritization, and roadmap definition. Covers user story format with Given/When/Then acceptance criteria, RICE prioritization, sprint planning, and Definition of Done.

Production-grade Python design patterns, modern tooling, and idiomatic code standards for Python 3.10+. Use for any Python-specific development where quality, type safety, and performance matter. Differentiator: strict tooling discipline (uv + ruff + pyright + pytest), decision matrix for dataclass/Pydantic/TypedDict selection, async/await deep-dive with concurrency model decision guide, and exception hierarchy design patterns.

Systematic handling of code review feedback — categorize, respond, fix, and follow up. Use when you receive code review feedback and need to address it methodically without dropping anything. Differentiator: Explicit 4-category feedback classification (must-fix/should-fix/consider/question), response templates with status tracking, and enforced re-review protocol before merging.

Decision framework and hybrid implementation for regex vs LLM text parsing. Use when parsing structured text (forms, logs, tables) to optimize cost and accuracy. Covers a hybrid pipeline that uses Regex for 95% of the work and LLMs strictly for edge cases, with confidence scoring and cost tracking.

Structured review flow with pre-review checklists, review templates, and PR size discipline. Use when your code is ready for review and you need to prepare a thorough, reviewable PR. Differentiator: Mandatory self-review checklist completion before requesting, enforced PR size limit (400 lines), and categorized review prompts (logic/architecture/security/performance/testing).

RTK (Rust Token Killer) CLI proxy that reduces LLM token consumption by 60-90% on common development commands. Use to optimize CLI operations and track token savings — always prefer RTK-wrapped commands when RTK is installed. Covers git, cargo, npm/pnpm/bun, pytest, go, and common utilities with measured savings statistics per command.