godmode

Turn on Godmode for Claude Code. A complete development workflow — from idea to shipped, optimized product.

Accessibility testing and auditing using WCAG 2.1 AA/AAA compliance checks, automated scanners (Axe, Pa11y, Lighthouse), color contrast analysis, keyboard navigation audit, and screen reader compatibility testing. Every finding includes WCAG criterion, code evidence, and concrete remediation.

Design, build, and evaluate AI agents. Covers agent architecture patterns (ReAct, plan-and-execute, multi-agent), tool design and integration, memory systems (short-term, long-term, episodic), guardrails and safety, orchestration, and evaluation.

Analytics implementation for product teams. Designs event taxonomies, implements tracking with Segment, Amplitude, Mixpanel, or PostHog, sets up funnel analysis, instruments A/B tests, and configures privacy-respecting analytics with Plausible or Umami. Full GDPR/CCPA compliance.

Angular architecture mastery — standalone components vs NgModules, RxJS patterns, state management (NgRx, Signals), dependency injection, lazy loading, Angular CLI optimization, and testing with Jasmine/Karma and Jest. Build production-grade Angular applications with best practices.

Design, specify, and validate REST, GraphQL, or gRPC APIs. Generates OpenAPI specs, enforces versioning strategies, designs rate limiting and pagination, and produces standardized error responses.

Generate, validate, and publish API documentation from OpenAPI/Swagger specs. Supports spec-first and code-first workflows, interactive doc renderers, CI validation, SDK generation, and changelog tracking.

Design system architecture with pattern evaluation, trade-off analysis, C4 diagrams, and Architecture Decision Records. Covers monolith, microservices, serverless, event-driven, CQRS, and hexagonal architectures.

Design and implement authentication and authorization architecture. Covers auth strategy selection (JWT, OAuth2, OIDC, SAML, API keys, mTLS), session management, multi-factor authentication, passwordless auth, token lifecycle, and social login integration.

Automate repetitive workflows. Designs cron jobs, webhook handlers, GitHub Actions workflows, automation scripts, and Makefiles/Taskfiles. Detects existing automation tooling and generates idiomatic configurations with error handling, logging, retry logic, and monitoring.

Backup strategy design and disaster recovery planning. Inventories data assets, defines RPO/RTO targets, designs tiered backup strategies, automates verification, tests recovery procedures, and generates comprehensive DR runbooks.

Execute an implementation plan using TDD (RED-GREEN-REFACTOR), parallel agent dispatch for independent tasks, and 2-stage code review gates.

Design and implement caching strategies. Configures multi-layer caches (CDN, application, database), cache invalidation (TTL, event-based, write-through, write-behind), Redis/Memcached/Varnish, and cache stampede prevention.

Changelog and release notes management — Keep a Changelog format, Conventional Commits auto-generation, audience-specific release notes, breaking change communication, and migration guide generation.

Chaos engineering and resilience testing. Designs controlled failure injection experiments, validates circuit breakers, plans game days, and generates resilience scorecards.

Data visualization design and implementation. Selects optimal chart types for data communication goals, integrates with D3.js, Chart.js, Recharts, and Plotly, builds responsive and accessible charts, and designs multi-chart dashboard layouts.

Design, create, and optimize CI/CD pipelines. Supports GitHub Actions, GitLab CI, CircleCI, and Jenkins with caching, sharding, matrix builds, and deployment gates.

CLI tool development — argument parsing design (Commander, Clap, Cobra, Click), interactive prompts and TUI frameworks (Ink, Ratatui, Bubbletea, Rich), configuration management (config files, env vars, XDG), shell completion generation, and distribution via package managers (npm, Homebrew, cargo, pip).

Compliance and governance auditing against GDPR, HIPAA, SOC2, PCI-DSS, and other regulatory frameworks. Examines actual code and data flows, produces findings with regulation references and concrete remediation, and audits license compliance across dependencies.

Concurrency and parallelism engineering. Performs thread safety analysis, detects race conditions, designs async/await patterns, implements lock-free data structures, applies actor model patterns, prevents deadlocks, and creates concurrent testing strategies.

Environment and configuration management. Audits dev/staging/prod parity, validates config schemas, manages feature flags, and designs A/B test rollout strategies.

Cloud cost optimization using evidence-based analysis of resource utilization, waste detection, right-sizing, pricing optimization, and cost governance. Every recommendation includes projected dollar savings and risk level.

Design, build, and debug scheduled tasks and recurring job systems. Covers cron expression syntax, scheduler selection (node-cron, BullMQ, Celery Beat, Sidekiq-Cron, APScheduler, Hangfire, Quartz), idempotency, distributed locking, job monitoring, dead letter handling, priority queues, job chaining, rate-limited execution, and timezone handling.

Implement cryptography correctly: encryption at rest and in transit, key management, password hashing (Argon2, bcrypt), digital signatures, JWT security, and TLS hardening.

Apply Domain-Driven Design to your domain. Covers strategic design (bounded contexts, context mapping, ubiquitous language), tactical design (aggregates, entities, value objects, domain events, repositories), and event storming facilitation.

Scientific bug investigation using 7 systematic techniques. Reproduces the bug, gathers evidence, isolates the root cause, and produces a root cause analysis document.

Advanced deployment strategy design and orchestration. Supports blue-green deployments, canary releases, progressive rollouts, automated rollback, feature flag coordination, and zero-downtime migrations. Every plan includes rollback procedures and monitoring criteria.

Design system architecture covering token systems (colors, spacing, typography, shadows), component API standards, theme systems (light/dark, custom, multi-brand), design-to-code pipelines (Figma tokens to CSS variables via Style Dictionary), versioning and distribution, and Storybook documentation.

Build secure CI/CD pipelines with SAST, DAST, SCA, container scanning, secret scanning, IaC security, and deployment security gates.

Distributed systems design and analysis. Performs CAP theorem trade-off analysis, selects consensus protocols (Raft, Paxos), designs distributed locking (Redlock, ZooKeeper), plans sharding and partitioning strategies, implements eventual consistency patterns, and configures leader election.

Build Python web applications with Django and FastAPI. Covers Django project structure, Django REST Framework serializers and viewsets, FastAPI dependency injection and Pydantic models, async Django with ASGI, admin customization, and database optimization.

Docker mastery skill for creating, optimizing, and securing containerized applications. Covers Dockerfile best practices (multi-stage builds, layer caching), Docker Compose for local development, image size optimization, security scanning (Trivy, Snyk), networking, volumes, and BuildKit features.

Generate and maintain project documentation. Produces API docs (OpenAPI/Swagger), code docs (JSDoc/docstrings), READMEs, runbooks, and audits existing documentation for staleness.

End-to-end browser testing. Sets up Playwright, Cypress, or Selenium test architecture with page object models, cross-browser testing, test data management, and flakiness remediation.

Design, build, deploy, and optimize edge functions and serverless applications. Covers edge platforms (Cloudflare Workers, Vercel Edge, Deno Deploy), serverless (AWS Lambda, GCP Cloud Functions), cold start optimization, edge caching, and distributed state.

Build email delivery and multi-channel notification systems. Integrates email providers, designs responsive templates, architects notification routing across email, push, SMS, and in-app channels with deliverability monitoring and bounce handling.

Evaluate, benchmark, and regression-test AI/LLM systems. Covers evaluation framework design, benchmark creation, human evaluation protocols, automated evaluation (LLM-as-judge), regression testing, statistical significance, and continuous evaluation pipelines.

Design event-driven architectures. Implements event sourcing, CQRS, message broker topologies (Kafka, RabbitMQ, SQS, NATS), event schema design with versioning, dead letter queues, retry policies, and idempotency patterns.

A/B testing and experimentation for product teams. Designs rigorous experiments with hypothesis-driven methodology, calculates sample sizes with power analysis, implements assignment via Optimizely, Statsig, GrowthBook, VWO, LaunchDarkly, or custom solutions, applies correct statistical methods (frequentist, Bayesian, sequential), and enforces guardrail metrics. Covers the full experiment lifecycle from ideation to cleanup.

Build, configure, and optimize FastAPI applications. Covers Pydantic model design, dependency injection patterns, async database access (SQLAlchemy async, Tortoise ORM), background tasks, WebSocket support, and testing with pytest and HTTPX.

Design and implement feature flag strategies. Covers flag types (release, experiment, ops, permission), SDK integration (LaunchDarkly, Unleash, Flagsmith, Split.io, homegrown), targeting rules, gradual rollouts, kill switches, A/B testing, and flag lifecycle management.

Autonomous error remediation loop. Inventories all errors (tests, lint, types), fixes them one at a time with minimum changes, adds regression tests, and repeats until zero errors remain.

Form architecture covering state management (React Hook Form, Formik, native), multi-step wizard forms, validation patterns (client + server, async with debounce), file upload handling with drag-and-drop, and accessible form design with labels, error messages, and focus management.

GitHub Actions expert — create, optimize, secure, and debug workflows. Handles triggers, jobs, matrix builds, reusable workflows, composite actions, caching, environments, secrets, OIDC, and security hardening.

Advanced Git workflow mastery. Recommends branching strategies, merge/rebase decisions, interactive rebase guidance, git bisect for regression hunting, cherry-picking, stashing, worktree management, and commit message conventions.

Design, build, optimize, and test GraphQL APIs. Covers schema design (SDL-first and code-first), resolver architecture, N+1 query detection with DataLoader patterns, subscriptions, federation, and performance hardening.

Design, build, and optimize gRPC services with Protocol Buffers. Covers proto file design, code generation with buf, streaming patterns, gRPC-web for browsers, load balancing, and service mesh integration.

Internationalization & localization — string extraction, pluralization, date/number formatting, RTL support, and character set validation. Every recommendation includes concrete code changes and locale-aware test plans.

Incident response and blameless post-mortem management. Classifies incidents by severity (SEV1-4), constructs precise timelines, performs root cause analysis, and produces actionable post-mortem documents with tracked action items.

Validate, plan, and deploy infrastructure using Infrastructure as Code. Supports Terraform, CloudFormation, Pulumi, and CDK with policy enforcement, cost estimation, and drift detection.

Integration testing with real dependencies using Testcontainers, proper database seeding/cleanup, API endpoint testing, and service-level integration patterns.

Manage Kubernetes deployments, generate Helm charts, configure deployment strategies, and troubleshoot pod issues.

Build, configure, and optimize Laravel applications. Covers Eloquent ORM patterns, service container, facades, contracts, queue system, events, broadcasting, Sanctum/Passport authentication, and testing with PHPUnit and Pest.

Modernize legacy codebases safely. Characterizes legacy code, adds tests to untested code (characterization tests, golden master, approval testing), plans incremental modernization, audits dependency health, assesses technology obsolescence, and removes dead code.

Linting and code standards setup covering ESLint, Prettier, Biome, Ruff, golangci-lint configuration, custom rule creation, auto-fix strategies, pre-commit hooks with Husky and lint-staged, and style guide enforcement. Every rule is justified and every configuration choice is explained.

Load testing and performance testing. Generates test scenarios for k6, Artillery, Locust, and JMeter. Establishes baselines, finds bottlenecks, and validates capacity through stress, spike, and soak testing.

Structured logging implementation. Defines log level strategies, implements JSON structured logging, sets up log aggregation pipelines, adds request tracing with correlation IDs, handles PII redaction, and configures log retention and rotation policies.

Design and manage microservice architectures. Decomposes monoliths into bounded contexts, designs inter-service communication (REST, gRPC, events), configures service mesh (Istio, Linkerd), implements service discovery and load balancing, and manages distributed transactions with the Saga pattern.

Database migration and schema management. Auto-detects your ORM/migration tool, generates idiomatic migrations with backward compatibility checks, validates rollback safety, and estimates lock duration on large tables.

Plan and execute large-scale system migrations. Handles language/framework transitions (JS to TS, REST to GraphQL), architecture evolution (monolith to microservices), data migration with zero downtime, strangler fig pattern, parallel run verification, and rollback planning. Distinct from `/godmode:migrate` (database schema changes).

ML development and experimentation management. Tracks experiments with full reproducibility, manages hyperparameters, validates datasets for quality and bias, evaluates models with rigorous metrics, and compares experiments to select the best model.

MLOps and model deployment management. Handles model serving infrastructure, inference optimization, model versioning, A/B testing, drift detection, and automated retraining. Supports TensorFlow Serving, Triton Inference Server, SageMaker, and custom serving solutions.

Mobile app development — iOS and Android architecture patterns, cross-platform frameworks (React Native, Flutter), native development (Swift, Kotlin), app signing and provisioning, app store submission workflows, and mobile-specific performance optimization.

Monorepo architecture and management covering tool selection (Turborepo, Nx, Lerna, Bazel, Rush), package boundary enforcement, selective builds and testing, dependency graph management, shared configuration patterns, and CI optimization with remote caching.

Configure, troubleshoot, and secure networking infrastructure. Covers DNS, SSL/TLS certificates, CDN configuration, load balancers, VPC design, and network security with defense-in-depth.

Master Next.js application architecture. Covers App Router, Server Components vs Client Components, data fetching patterns, middleware, rendering strategies, and asset optimization.

Build production-grade Node.js backends. Covers framework selection (Express, Fastify, Hono, NestJS), middleware design, stream processing, worker threads, cluster mode, memory management, and event loop optimization.

NoSQL database design. MongoDB document modeling and aggregation pipeline, DynamoDB single-table design with GSI/LSI strategies, Cassandra partition key design, Neo4j graph modeling and Cypher queries, time-series databases, and database selection guidance.

Build multi-channel notification systems with push, SMS, email, in-app, and webhook delivery. Integrates FCM, APNs, Twilio, OneSignal, and WebSocket for real-time notifications with user preference management, quiet hours, digest batching, and delivery tracking.

Package management skill for JavaScript/TypeScript projects. Covers npm, yarn, pnpm, and bun comparison and selection, lock file management, workspace/monorepo configuration, package publishing, security auditing (npm audit), and version resolution strategies.

Set up full observability: metrics, structured logging, distributed tracing, alert rules, SLO/SLI definitions, and dashboards.

Codebase onboarding and architecture discovery. Generates architecture walkthroughs, identifies key files, analyzes naming conventions, visualizes dependencies, and creates guided code tours.

Open source project management — repository scaffolding, community health files, issue/PR templates, GitHub Actions automation, maintainer workflows, and governance models. Everything needed to run a healthy open source project.

The core autonomous iteration loop. Measures a baseline, then runs a disciplined cycle: hypothesize, modify one thing, verify mechanically, keep if better or revert if worse, repeat until the target is reached.

ORM and data access optimization. Covers ORM selection (Prisma, Drizzle, TypeORM, SQLAlchemy, GORM, ActiveRecord), N+1 query detection, connection pooling, transaction management, and query builder patterns.

Recommend the right design pattern for your problem. Covers Gang of Four patterns, modern distributed system patterns (Repository, CQRS, Saga, Circuit Breaker, Outbox, Strangler Fig), anti-pattern detection, and language-specific implementations.

Implement payment processing, subscription billing, invoicing, and tax calculation. Integrates payment gateways with PCI-DSS compliance and reliable webhook handling for all payment events.

Authorized penetration testing with structured reconnaissance, OWASP-methodology vulnerability assessment, proof-of-concept exploitation, API security testing, and formal report writing with evidence.

Performance profiling & optimization — CPU profiling with flame graph analysis, memory leak detection, concurrency bug detection (race conditions, deadlocks), and benchmarking with statistical significance. Every finding includes profiling evidence and measured remediation.

Data pipeline and ETL design, implementation, testing, and debugging. Covers extraction, transformation, loading, data quality validation, schema contracts, observability, and error handling. Works with any orchestrator (Airflow, dbt, Dagster, Prefect, Luigi, custom scripts) and any data store.

Decompose a specification into small, implementable tasks. Each task is 2-5 minutes, has exact file paths, code sketches, tests, and dependencies.

PostgreSQL mastery. Advanced features (CTEs, window functions, JSONB, full-text search), extension management (pgvector, PostGIS, TimescaleDB), replication setup, partitioning strategies, VACUUM/ANALYZE tuning, and connection pooling configuration.

Pull request excellence. Optimizes PR size, generates description templates, manages stacked PRs for large features, configures auto-labeling and auto-assignment, and tracks PR cycle time metrics.

Engineer, test, version, and optimize prompts for LLMs. Covers prompt design patterns (few-shot, chain-of-thought, ReAct, tree-of-thought), structured output, system prompt design, prompt injection prevention, A/B testing, and evaluation.

Query optimization and data analysis. Interprets EXPLAIN plans, recommends indexes, rewrites queries for performance, detects N+1 problems, and profiles slow queries across SQL databases, MongoDB, Redis, and any ORM.

Design, build, and debug message queue and job processing systems. Covers queue architecture (Kafka, RabbitMQ, SQS, BullMQ, Celery), retry strategies, dead letter handling, delivery guarantees, priority queues, worker pool design, and backpressure handling.

Build, optimize, and evaluate RAG (Retrieval-Augmented Generation) systems. Covers embedding model selection, vector store design, chunking strategies, retrieval optimization (hybrid search, reranking), context assembly, and evaluation metrics (faithfulness, relevance, hallucination rate).

Build, configure, and optimize Ruby on Rails applications. Covers Rails conventions, ActiveRecord patterns, query optimization, Hotwire (Turbo and Stimulus), background jobs (Sidekiq, Solid Queue), and testing with RSpec and FactoryBot.

Design and implement rate limiting strategies. Configures algorithms (token bucket, sliding window), distributed rate limiting with Redis, user-tier-based limits, API key quotas, response headers, graceful degradation, and framework middleware (Express, FastAPI, Django, Go).

Design and implement permission and access control systems. Covers RBAC, ABAC, and ReBAC permission models, role hierarchies, resource-based access control, permission inheritance and delegation, policy engines, and audit logging for every access decision.

Build excellent React applications with proper architecture. Covers component composition, state management selection, performance optimization, Server Components, concurrent features, and testing with React Testing Library.

Design, build, and scale real-time communication features. Covers WebSocket architecture, Server-Sent Events, pub/sub patterns (Socket.io, Pusher, Ably), real-time collaboration (CRDT, OT), presence systems, typing indicators, and scaling with Redis pub/sub.

Redis architecture and system design. Data structure selection, caching strategies, queues, pub/sub, session stores, rate limiters, Redis Cluster and Sentinel, memory optimization, eviction policies, Lua scripting, and Redis Functions.

Safely transform codebases using proven refactoring patterns. Performs impact analysis, ensures test coverage, executes transformations in atomic steps, and verifies correctness after every change.

Site reliability engineering practices. Defines SLOs/SLIs/SLAs with error budget tracking, configures multi-window burn rate alerts, identifies and eliminates toil, designs sustainable on-call rotations, creates automated runbooks, and establishes incident management processes.

System resilience engineering with circuit breakers, retry strategies, bulkheads, rate limiting, graceful degradation, and health checks. Designs fault-tolerant systems that handle failures gracefully and recover automatically.

Responsive and adaptive design covering layout strategies (fluid, adaptive, intrinsic), CSS Grid and Flexbox mastery, container queries, mobile-first and desktop-first breakpoint systems, fluid typography, responsive images with art direction, print stylesheets, and touch vs pointer interactions.

Write and manage technical proposals (RFCs) with structured templates, stakeholder review tracking, and decision timeline management.

Scalability engineering and capacity planning. Analyzes horizontal vs vertical scaling decisions, configures auto-scaling, designs database read replicas and write splitting, optimizes connection pooling, implements rate limiting and backpressure, and plans capacity for growth.

Data modeling and schema design. Covers relational schemas (normalization, denormalization), NoSQL modeling (document, key-value, graph, time-series), schema evolution, entity-relationship modeling, and validation schemas (Zod, JSON Schema, Avro, Protobuf).

Design, build, and optimize full-text search functionality. Covers engine selection (Elasticsearch, Algolia, Meilisearch, PostgreSQL FTS), index design, relevance tuning, faceted search, autocomplete, fuzzy matching, and synonym handling.

Manage secrets safely: scan for leaks, set up secret stores, enforce rotation policies, audit access, and prevent future exposure.

Security audit using STRIDE threat modeling, OWASP Top 10 checklist, and 4 red-team adversarial personas. Every finding includes code evidence, severity rating, and concrete remediation.

Database seeding, test fixtures, factory patterns, and fake data generation. Covers factory libraries (FactoryBot, fishery, factory_boy, Bogus), Faker integration, idempotent seed scripts, environment-aware seeding, large dataset optimization, and production data anonymization.

SEO optimization and technical auditing covering meta tags, structured data (Schema.org JSON-LD), Core Web Vitals, Open Graph social meta, sitemap/robots.txt validation, and Lighthouse SEO scoring. Every finding includes severity, impact on search ranking, and concrete remediation code.

Structured 8-phase shipping workflow. Inventories changes, runs pre-ship checklist, prepares artifacts, performs dry-run, executes the ship (PR/deploy/release), verifies, logs, and monitors post-ship.

Service level objectives, SLIs, error budgets, and reliability targets. Defines measurable SLIs, sets SLO targets with rolling windows, calculates error budgets, configures multi-window multi-burn-rate alerts, establishes error budget policies, gates releases on budget health, builds SLO dashboards, and sets up review cadence.

Build, configure, and optimize Spring Boot applications. Covers auto-configuration, starter selection, Spring Security, Spring Data JPA, Actuator monitoring, Spring Cloud microservices, and testing with MockMvc and TestContainers.

State management design and implementation. Classifies state by category, selects the right tools (Redux, Zustand, Jotai, MobX, React Query, SWR, XState), designs store architecture, implements optimistic updates, cache synchronization, persistence, and SSR hydration.

Design and implement file storage systems with object storage, upload architecture, media processing, cost optimization, and backup strategies. Handles everything from presigned URL flows to video transcoding pipelines.

Svelte and SvelteKit mastery — Svelte 5 runes reactivity, stores, SvelteKit routing with load functions and form actions, server-side rendering, prerendering, adapter configuration for different deployment platforms, and testing. Build production-grade Svelte applications with best practices.

Tailwind CSS mastery — configuration and customization, custom plugin creation, responsive design patterns, dark mode implementation, performance optimization (purging, JIT), and component patterns that avoid class soup. Master utility-first CSS for production applications.

Collaborative brainstorming and design sessions. Explores 2-3 approaches, facilitates a decision, and produces a written specification.

Type system and schema validation covering TypeScript strict mode configuration, gradual typing strategies, Zod/Yup/Joi runtime validation, type narrowing and discriminated unions, branded types, and schema-first development. Every type improvement is justified by the bugs it prevents.

UI component architecture analysis covering component library design, design system consistency, Storybook integration, CSS architecture decisions, and component documentation. Identifies violations and enforces patterns across the UI codebase.

Handle file uploads, image optimization, video processing, and media pipelines. Covers presigned URLs, multipart/chunked uploads, resumable uploads (tus), Sharp/Cloudinary/imgproxy image processing, FFmpeg video transcoding, file validation, virus scanning, and orphaned upload cleanup.

Vue.js mastery — Composition API and Options API decision guidance, Pinia state management, Vue Router configuration, Nuxt.js SSR/SSG patterns, Vite optimization, and testing with Vitest and Vue Test Utils. Build production-grade Vue applications with best practices.

Design, implement, and secure webhook systems — inbound handling, outbound delivery, retry strategies, HMAC verification, event subscriptions, and dead letter queues.

Web performance optimization covering Lighthouse auditing, bundle analysis, code splitting, image optimization (WebP/AVIF, lazy loading, responsive images), critical CSS extraction, font optimization, service worker caching, and CDN configuration. Measures before/after with Core Web Vitals and bundle size metrics.

Executes implementation tasks following a Godmode skill workflow exactly

You are a senior code reviewer dispatched by Godmode's review skill. Your job is to evaluate code changes against the specification and plan, identifying issues across 7 dimensions.

Read-only codebase exploration — maps structure, traces code paths, gathers context

Runs the autonomous optimization loop — measure, modify, verify, keep/revert

Decomposes goals into parallel tasks, maps each to a Godmode skill, builds dependency graph

Reviews code for correctness, security, and skill adherence

Security auditor — STRIDE, OWASP Top 10, red-team analysis

You are a specification reviewer dispatched by Godmode's think skill. Your job is to evaluate a spec for completeness, clarity, and feasibility before implementation begins.

Test writer — TDD, unit/integration/e2e test generation

Accessibility testing and auditing skill. Activates when user needs to verify WCAG 2.1 AA/AAA compliance, audit color contrast, keyboard navigation, screen reader compatibility, or fix accessibility issues. Integrates with Axe, Pa11y, and Lighthouse. Combines automated scanning with manual checklist review. Triggers on: /godmode:a11y, "check accessibility", "WCAG audit", "a11y review", or as pre-ship quality gate.

AI agent development skill. Activates when users need to design, build, or evaluate AI agents. Covers agent architecture patterns (ReAct, plan-and-execute, multi-agent), tool design and integration, memory systems (short-term, long-term, episodic), guardrails and safety, orchestration, and evaluation. Every agent gets a structured architecture spec, tool inventory, safety guardrails, and test suite. Triggers on: /godmode:agent, "build an AI agent", "design agent tools", "add memory to agent", or when the orchestrator detects agent-related work.

Analytics implementation skill. Activates when users need to design and implement product analytics, event tracking, funnel analysis, A/B test instrumentation, or privacy-respecting analytics. Supports Segment, Amplitude, Mixpanel, PostHog, Plausible, and Umami. Provides structured event taxonomies, data modeling, funnel design, and experiment instrumentation with full privacy compliance. Triggers on: /godmode:analytics, "add analytics", "track events", "set up A/B testing", "implement funnels", or when the orchestrator detects analytics-related work.

Angular architecture skill. Activates when user needs to build, architect, or optimize Angular applications. Covers module architecture vs standalone components, RxJS patterns, state management (NgRx, Signals), dependency injection, lazy loading, Angular CLI optimization, and testing with Jasmine/Karma and Jest. Triggers on: /godmode:angular, "build an Angular app", "Angular component", "NgRx store", "Angular signals", or when the orchestrator detects Angular-related work.

API design and specification skill. Activates when user needs to design, document, or validate REST, GraphQL, or gRPC APIs. Generates OpenAPI/Swagger specs, enforces versioning strategies, designs rate limiting and pagination, and produces standardized error responses. Every API endpoint gets a spec, example request/response, and validation. Triggers on: /godmode:api, "design an API", "create API spec", "validate my API", or when the orchestrator detects API-related work.

API documentation generation, OpenAPI/Swagger specs, contract-first development, interactive docs. Use when user mentions API docs, Swagger, OpenAPI, API reference, Redoc, API specification.

Software architecture skill. Activates when user needs to design system architecture, select architecture patterns, create C4 diagrams, or apply domain-driven design at the strategic level. Evaluates trade-offs across monolith, microservices, serverless, event-driven, CQRS, and hexagonal architectures. Produces architecture decision records, C4 diagrams, and bounded context maps. Triggers on: /godmode:architect, "design the architecture", "system design", "how should I structure this", or when the orchestrator detects architecture-level decisions.

Authentication and authorization skill. Activates when user needs to design or implement authentication flows (JWT, OAuth2, OIDC, SAML, API keys, mTLS), session management, multi-factor authentication, passwordless auth, token lifecycle management, or social login integration. Produces architecture decisions, implementation code, security configuration, and integration tests for the full identity stack. Triggers on: /godmode:auth, "authentication", "login flow", "OAuth setup", "JWT tokens", "session management", "MFA", or when building features that require user identity.

Task automation skill. Activates when a developer needs to automate repetitive workflows, create scheduled jobs, set up webhooks, design GitHub Actions workflows, write automation scripts, or build Makefiles/Taskfiles. Triggers on: /godmode:automate, "automate this", "create a cron job", "set up webhook", "write a Makefile", "create GitHub Action", or when repetitive manual processes are identified.

Backup and disaster recovery skill. Activates when user needs to design backup strategies, define RPO/RTO targets, test recovery procedures, verify data integrity, or generate disaster recovery runbooks. Produces comprehensive backup plans with automated verification and tested recovery procedures. Triggers on: /godmode:backup, "backup strategy", "disaster recovery", "what's our RPO?", "can we recover from", or when designing critical data infrastructure.

Implementation engine. Parallel agents in worktrees from plan.

Caching strategy skill. Activates when user needs to design cache layers (CDN, application, database, session), implement cache invalidation strategies (TTL, event-based, write-through, write-behind), configure Redis/Memcached/Varnish, or prevent cache stampedes. Triggers on: /godmode:cache, "add caching", "cache invalidation", "Redis setup", "cache strategy", "CDN configuration", "cache stampede", or when the orchestrator detects caching opportunities.

Changelog and release notes management skill. Activates when user needs to create, maintain, or auto-generate changelogs and release notes. Supports Keep a Changelog format, Conventional Commits for auto-generation, audience-specific release notes (developers vs end users), breaking change communication, and migration guide generation. Triggers on: /godmode:changelog, "update changelog", "write release notes", "generate migration guide", or when preparing a release.

Chaos engineering skill. Activates when user needs to test system resilience through controlled failure injection, validate circuit breakers, plan game days, or verify disaster recovery procedures. Covers network failures, disk pressure, process crashes, dependency outages, and data corruption scenarios. Triggers on: /godmode:chaos, "chaos test", "resilience test", "failure injection", "game day", or when ship skill needs resilience validation.

Data visualization skill. Activates when users need to create charts, graphs, dashboards, or any visual representation of data. Supports chart type selection (bar, line, scatter, heatmap, treemap, sankey), integrates with D3.js, Chart.js, Recharts, and Plotly, enforces dashboard design principles, responsive layouts, and accessibility standards for data visualizations. Triggers on: /godmode:chart, "create a chart", "visualize this data", "build a dashboard", or when the orchestrator detects data visualization work.

CI/CD pipeline design skill. Activates when user needs to create, optimize, or troubleshoot continuous integration and delivery pipelines. Supports GitHub Actions, GitLab CI, CircleCI, and Jenkins. Handles stage optimization, caching strategies, artifact management, pipeline templating, and matrix builds. Triggers on: /godmode:cicd, "create pipeline", "optimize CI", "add GitHub Actions", "fix pipeline", or when shipping requires CI/CD configuration.

CLI tool development skill. Activates when building, polishing, or distributing command-line interfaces and terminal user interfaces. Covers argument parsing design (Commander, Clap, Cobra, Click), interactive prompts and TUI frameworks (Ink, Ratatui, Bubbletea, Rich), configuration management (config files, environment variables, XDG), shell completion generation, distribution strategies (npm, Homebrew, cargo, pip), and CLI UX best practices. Every recommendation includes concrete implementation and cross-platform considerations. Triggers on: /godmode:cli, "CLI tool", "command line", "terminal app", "TUI", "argument parser", "shell completion".

Compliance and governance skill. Activates when user needs to verify regulatory compliance (GDPR, HIPAA, SOC2, PCI-DSS), design audit trails, implement privacy controls, manage data retention policies, or audit license compliance across dependencies. Systematically evaluates codebase against regulatory frameworks, produces findings with evidence and remediation, and generates compliance documentation. Triggers on: /godmode:comply, "GDPR compliance", "audit trail", "are we compliant?", "privacy review", or when shipping features that handle personal data.

Concurrency and parallelism skill. Activates when user needs thread safety analysis, race condition detection, async/await pattern guidance, lock-free data structures, actor model design, deadlock detection and prevention, or concurrent testing strategies. Triggers on: /godmode:concurrent, "thread safety", "race condition", "async await", "deadlock", "lock-free", "actor model", "concurrent", "parallelism", or when the orchestrator detects concurrency work.

Environment and configuration management skill. Activates when user needs to manage dev/staging/prod configs, validate environment parity, design feature flags, or plan A/B test rollouts. Ensures config consistency, secret safety, and environment drift detection. Triggers on: /godmode:config, "manage environments", "feature flags", "config validation", "A/B test setup", or when ship skill needs environment verification.

Cloud cost optimization skill. Activates when user needs to analyze, reduce, or govern cloud spending across AWS, GCP, and Azure. Performs resource utilization analysis, right-sizing recommendations, waste detection, cost allocation tagging, and budget alerting. Uses evidence-based analysis of actual usage data to produce actionable savings recommendations with projected dollar impact. Triggers on: /godmode:cost, "reduce cloud costs", "optimize spending", "why is our bill so high?", or when infrastructure costs need governance.

Scheduled tasks, cron jobs, background job queues, recurring work. Use when user mentions cron, scheduler, background jobs, recurring tasks, Bull, BullMQ, Celery, Sidekiq, node-cron, APScheduler.

Cryptography implementation skill. Activates when user needs to implement encryption (at rest or in transit), key management, password hashing (Argon2, bcrypt), digital signatures, JWT security, TLS hardening, or any cryptographic operation. Triggers on: /godmode:crypto, "encryption", "hashing", "key management", "TLS setup", "digital signature", "JWT signing", or when code handles sensitive data.

Domain-Driven Design skill. Activates when user needs to model a complex domain, define bounded contexts, design aggregates, or facilitate event storming. Covers strategic design (bounded contexts, context mapping, ubiquitous language) and tactical design (aggregates, entities, value objects, domain events, repositories). Produces bounded context maps, aggregate boundary diagrams, domain event catalogs, and implementation scaffolds. Triggers on: /godmode:ddd, "model the domain", "bounded context", "aggregate design", "event storming", or when the orchestrator detects domain modeling needs.

Scientific debugging. Reproduce → investigate → prove root cause. Finds all bugs.

Advanced deployment strategies skill. Activates when user needs sophisticated deployment orchestration including blue-green deployments, canary releases, progressive rollouts, automated rollback, feature flag coordination, and zero-downtime migrations. Designs and validates deployment plans with risk mitigation at every stage. Triggers on: /godmode:deploy, "deploy with zero downtime", "canary release", "blue-green deployment", "rollback strategy", or when shipping critical changes that require controlled rollout.

Design system architecture skill. Activates when user needs to build, maintain, or audit a design system including token architecture (colors, spacing, typography, shadows), component API standards, theme systems (light/dark, custom), design-to-code pipelines (Figma tokens to CSS variables), versioning and distribution, and Storybook documentation. Triggers on: /godmode:designsystem, "design system", "design tokens", "theme architecture", "Figma to code", or when building a shared component library.

DevSecOps pipeline skill. Activates when user needs to integrate security into CI/CD pipelines, configure static analysis (SAST), dynamic analysis (DAST), software composition analysis (SCA), container scanning, secret scanning, or establish security gates in deployment workflows. Supports Semgrep, CodeQL, SonarQube, OWASP ZAP, Burp Suite, Trivy, Snyk, and other industry-standard tools. Produces pipeline configurations, security gate definitions, and remediation workflows. Triggers on: /godmode:devsecops, "secure pipeline", "add SAST", "security gate", "container scan", "shift left", or when building CI/CD that needs security controls.

Distributed systems design skill. Activates when user needs CAP theorem trade-off analysis, consensus protocol selection (Raft, Paxos), distributed locking (Redlock, ZooKeeper), sharding and partitioning strategies, eventual consistency patterns, leader election, or distributed architecture design. Triggers on: /godmode:distributed, "distributed system", "CAP theorem", "consensus", "Raft", "Paxos", "sharding", "partitioning", "eventual consistency", "leader election", or when the orchestrator detects distributed systems work.

Django and FastAPI development skill. Activates when building, architecting, or optimizing Python web applications. Covers Django project structure and app architecture, Django REST Framework with serializers and viewsets, FastAPI dependency injection and Pydantic models, async Django with ASGI configuration, admin customization, database optimization with the Django ORM, and production deployment. Every recommendation includes concrete code and architectural rationale. Triggers on: /godmode:django, "Django", "FastAPI", "DRF", "Django REST Framework", "Pydantic", "ASGI", "Django admin", "Python web", "viewsets", "serializers".

Docker mastery skill. Activates when user needs to create, optimize, or troubleshoot Docker configurations. Covers Dockerfile best practices (multi-stage builds, layer caching, minimal images), Docker Compose for local development, image size optimization, security scanning (Trivy, Snyk), networking, volumes, BuildKit features, and build arguments. Triggers on: /godmode:docker, "Dockerfile", "docker compose", "container image", "multi-stage build", "image size", "docker security", or when containerizing an application.

Documentation generation and maintenance skill. Activates when the project needs API docs (OpenAPI/Swagger), code docs (JSDoc, docstrings), README generation, runbook creation, or documentation quality audits. Detects stale docs, missing coverage, and obsolescence. Triggers on: /godmode:docs, "generate docs", "update documentation", "write a README", "create runbook", or when shipping reveals undocumented public APIs.

End-to-end testing skill. Activates for browser-based E2E tests, cross-browser testing, flaky test fixes, or page object models. Supports Playwright, Cypress, Selenium. Triggers on: /godmode:e2e, "E2E test", "browser test", "Playwright test", "Cypress test".

Edge computing and serverless skill. Covers Cloudflare Workers, Vercel Edge, Deno Deploy, AWS Lambda, cold start optimization, edge caching, distributed state. Triggers on: /godmode:edge, "edge function", "serverless API", "optimize Lambda cold start".

Email and notification systems skill. SendGrid, SES, Postmark, Resend. Templates (MJML, React Email). Bounce handling, delivery tracking, DNS auth, stream separation. Triggers on: /godmode:email, "send emails", "notification system", "email templates".

AI/LLM evaluation skill. Covers benchmark creation, LLM-as-judge, regression testing, statistical significance. Triggers on: /godmode:eval, "evaluate my model", "benchmark this", "run evals".

Event-driven architecture skill. Covers event sourcing, CQRS, message brokers (Kafka, RabbitMQ, SQS, NATS), schema versioning, DLQ, retry policies, idempotency. Triggers on: /godmode:event, "event sourcing", "CQRS", "Kafka", "dead letter queue", "idempotency".

A/B testing, experimentation, statistical analysis. Triggers on: /godmode:experiment, "A/B test", "split test", "statistical significance", "Optimizely", "Statsig", "GrowthBook".

FastAPI mastery skill. Covers Pydantic models, DI, async DB access, background tasks, WebSocket, testing. Triggers on: /godmode:fastapi, "fastapi", "pydantic", "async api", "python api".

Feature flag design, gradual rollouts, A/B testing, kill switches. LaunchDarkly, Unleash, Flagsmith. Triggers on: /godmode:feature, "feature flag", "gradual rollout", "kill switch", "A/B test".

Branch finalization. Validate, squash-merge, PR, keep, or discard. Clean state enforced. Triggers on: /godmode:finish, "done with branch", "merge this", "finalize", "wrap up".

Fix loop. One fix per commit, auto-revert on regression, until zero errors. Max 3 attempts per error. Triggers on: /godmode:fix, "fix this", "tests failing", "broken build", "lint errors".

Form architecture skill. Multi-step wizards, validation (client + server, async), file uploads, accessible form design. Triggers on: /godmode:forms, "form validation", "multi-step form", "wizard", "file upload", "form accessibility".

GitHub Actions workflows, custom actions, CI/CD. Matrix builds, reusable workflows, composite actions, caching, security hardening. Triggers on: /godmode:ghactions, "GitHub Actions", "workflow", ".github/workflows", "matrix build".

Advanced Git workflows skill. Branching models, merge vs rebase, interactive rebase, git bisect, cherry-pick, worktrees, commit conventions. Triggers on: /godmode:git, "branching strategy", "rebase vs merge", "git bisect", "cherry-pick".

Orchestrator. Routes to skills, detects stack/phase, dispatches multi-agent worktrees. Triggers on: /godmode, /godmode:<skill>.

GraphQL API development skill. Schema design, resolver architecture, N+1 detection with DataLoader, subscriptions, federation, performance hardening. Triggers on: /godmode:graphql, "GraphQL schema", "fix N+1 queries", "set up subscriptions".

gRPC and Protocol Buffers skill. Proto design, code generation, streaming patterns, gRPC-web, load balancing, service mesh integration. Triggers on: /godmode:grpc, "gRPC service", "proto file", "streaming RPC", "gRPC-web".

Internationalization & localization skill. String extraction, translation workflows, pluralization, date/number/currency formatting, RTL support, character set validation. Triggers on: /godmode:i18n, "internationalize", "translate", "RTL support".

Incident response and post-mortem skill. Severity classification (SEV1-4), timeline construction, blameless post-mortems, action item tracking. Triggers on: /godmode:incident, "production is down", "post-mortem", "incident report".

Infrastructure as Code skill. Terraform, CloudFormation, Pulumi, CDK. IaC testing, cost estimation, drift detection, policy enforcement. Triggers on: /godmode:infra, "terraform plan", "provision infrastructure", "infrastructure review".

Integration testing skill. Tests across real boundaries — databases, APIs, message queues. Covers Testcontainers, DB seeding/cleanup, API integration. Triggers on: /godmode:integration, "test with real database", "testcontainers".

Kubernetes and container orchestration skill. Helm charts, deployment strategies (rolling, canary, blue-green), pod health, resource limits, scaling. Triggers on: /godmode:k8s, "deploy to kubernetes", "helm chart", "pod crashing", "OOMKilled".

Laravel mastery skill. Eloquent ORM, service container, queues, events, Sanctum/Passport auth, Pest testing. Triggers on: /godmode:laravel, "laravel app", "eloquent", "artisan", "blade".

Legacy code modernization skill. Characterization tests, golden master, incremental modernization, dependency upgrades, dead code removal. Triggers on: /godmode:legacy, "legacy code", "modernize", "tech debt", "dead code".

Linting and code standards skill. ESLint, Prettier, Biome, Ruff, golangci-lint. Custom rules, auto-fix, pre-commit hooks, style enforcement. Triggers on: /godmode:lint, "linting", "code style", "prettier", "eslint", "formatter", "pre-commit hooks".

Load testing and performance testing skill. k6, Artillery, Locust, JMeter. Stress, spike, soak testing. Statistical significance checking. Triggers on: /godmode:loadtest, "load test", "stress test", "performance test", "benchmark".

Structured logging skill. JSON logs, log levels, correlation IDs, PII redaction, log aggregation, retention policies. ELK/Loki/CloudWatch pipelines. Triggers on: /godmode:logging, "structured logging", "log levels", "correlation ID", "PII redaction".

Microservices design and management.

Database migration and schema management.

System migration and technology transition.

ML development and experimentation.

MLOps and model deployment.

Mobile app development (iOS/Android/cross-platform).

Monorepo architecture and management -- Turborepo, Nx, Lerna, Bazel, boundaries, caching.

Network, DNS, SSL/TLS, CDN, load balancers.

Next.js mastery -- App Router, Server Components, data fetching, rendering strategies, optimization.

Node.js backend development.

NoSQL database design (Mongo, DynamoDB, etc).

Push notifications, SMS, in-app notifications, notification preferences, multi-channel delivery.

Package management (npm/yarn/pnpm/bun).

Monitoring and observability (metrics/logs/traces).

Codebase onboarding and architecture walkthrough.

Open source project management.

Autonomous optimization loop. 3 parallel agents per round, mechanical metrics only.

ORM and data access optimization.

Design pattern recommendation and anti-pattern detection.

Payment and billing integration -- Stripe, subscriptions, invoicing, tax, PCI compliance.

Penetration testing (OWASP methodology).

Performance profiling -- CPU, memory, concurrency, benchmarking with statistical rigor.

Data pipeline and ETL -- extraction, transformation, loading, data quality, orchestration.

Task decomposition and dependency planning. Reads spec and outputs ordered implementation tasks.

PostgreSQL mastery -- advanced features, replication, partitioning, tuning, connection pooling.

Pull request excellence and review optimization.

3-persona + meta-expert evaluation. Independent assessment then synthesis. Gate before build.

Prompt engineering -- design, test, version, and optimize prompts for LLMs.

Query optimization and EXPLAIN analysis.

Message queue and job processing -- Kafka, RabbitMQ, SQS, BullMQ, Celery, Sidekiq.

RAG (Retrieval-Augmented Generation) systems.

Ruby on Rails mastery.

Rate limiting algorithms, quota management, throttling, API protection.

Permission and access control (RBAC/ABAC/ReBAC).

React architecture -- components, state, performance, Server Components, testing.

Real-time communication -- WebSocket, SSE, pub/sub, collaboration, presence systems.

Redis architecture and system design.

Large-scale code refactoring and transformation.

Site reliability engineering -- SLO/SLI/SLA, error budgets, toil, on-call, runbooks, incidents.

System resilience -- circuit breakers, retries, bulkheads, graceful degradation, health checks.

Responsive and adaptive design with CSS Grid, Flexbox, container queries, and fluid typography.

4-agent code review. Correctness, security, performance, style. Auto-fixes NITs.

RFC and technical proposal writing.

Scalability engineering. Horizontal/vertical decisions, auto-scaling, read replicas, connection pooling, rate limiting, capacity planning.

Edge case exploration. 12 dimensions, scored by likelihood x impact. Runnable tests for HIGH+.

Data modeling and schema design. Relational, NoSQL, migrations, ER modeling, validation schemas.

Search implementation. Full-text search, relevance tuning, facets, autocomplete, fuzzy matching.

Secrets management. Leak detection, rotation, vault setup, .env management, access auditing.

Security audit. STRIDE + OWASP Top 10 + 4 red-team personas. Code evidence required.

Database seeding, test fixtures, factory patterns, fake data generation. Idempotent seed scripts.

SEO optimization. Meta tags, structured data, Core Web Vitals, sitemap, robots.txt, Open Graph.

Configuration wizard. Auto-detects project stack, validates commands, saves .godmode/config.yaml.

Ship workflow. Checklist, dry-run, ship, verify. PR, deploy, or release.

SLOs, SLIs, error budgets, burn rate alerts, reliability targets, service level management.

Spring Boot mastery. Auto-configuration, security, Data JPA, Actuator, testing with TestContainers.

State management design. Frontend state, server state, state machines, optimistic updates, caching.

File storage and CDN. Object storage, presigned URLs, image/video processing, lifecycle policies.

Svelte/SvelteKit mastery. Runes reactivity, stores, routing, form actions, SSR, adapter configuration.

Tailwind CSS mastery. Configuration, custom plugins, responsive design, dark mode, performance, CVA.

TDD loop. RED-GREEN-REFACTOR until coverage target met.

Design session. Explore problem, scan codebase, generate 2-3 approaches, recommend one, produce .godmode/spec.md.

Type system and schema validation. Strict TypeScript, runtime validation (Zod), type narrowing, schema-first development.

UI component architecture. Design systems, Storybook, CSS architecture, design tokens, component patterns.

File upload handling, image optimization, media processing, signed URLs, multipart, virus scanning.

Evidence gate. Run command, read full output, confirm or deny claim. No trust, only proof.

Vue.js mastery. Composition API, Pinia, Vue Router, Nuxt SSR/SSG, Vite optimization, testing.

Webhook design, delivery, retry, HMAC verification, event subscriptions, dead letter queues.

Web performance optimization. Lighthouse, bundle analysis, code splitting, image optimization, critical CSS, fonts, service workers, CDN.