
Architectural decision-making framework. Requirements analysis, trade-off evaluation, ADR documentation. Use when making architecture decisions or analyzing system design.
Generative Engine Optimization for AI search engines (ChatGPT, Claude, Perplexity).
Multi-agent orchestration patterns. Use when multiple independent tasks can run with different domain expertise or when comprehensive analysis requires multiple perspectives.
Production deployment principles and decision-making. Safe deployment workflows, rollback strategies, and verification. Teaches thinking, not scripts.
Game art principles. Visual style selection, asset pipeline, animation workflow.
Game design principles. GDD structure, balancing, player psychology, progression.
Web browser game development principles. Framework selection, WebGPU, optimization, PWA.
Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.
Test-Driven Development workflow principles. RED-GREEN-REFACTOR cycle.
Multiplayer game development principles. Architecture, networking, synchronization.
Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
Tailwind CSS v4 principles. CSS-first configuration, container queries, modern patterns, design token architecture.
Project scaffolding templates for new applications. Use when creating new projects from scratch. Contains 12 templates for various tech stacks.
Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents.
Socratic questioning protocol + user communication. MANDATORY for complex requests, new features, or unclear requirements. Includes progress reporting and error handling.
Game development orchestrator. Routes to platform-specific skills based on project needs.
React and Next.js performance optimization from Vercel Engineering. Use when building React components, optimizing performance, eliminating waterfalls, reducing bundle size, reviewing code for performance issues, or implementing server/client-side optimizations.
SEO fundamentals, E-E-A-T, Core Web Vitals, and Google algorithm principles.
Testing patterns and principles. Unit, integration, mocking strategies.
Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Codex needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks
Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Codex needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.
Presentation creation, editing, and analysis. When Codex needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks
Use AFTER any code changes (feature implementation, bug fix, refactor) to enforce mandatory dual-pass review. First pass reviews unstaged changes for correctness and convention compliance. Second pass ONLY executes if first pass made any corrections. Ensures work follows project conventions, development rules, and best practices before task completion.
Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Codex needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas
Use when the user asks to investigate, understand, explore, or explain how a feature works, asks about existing logic, or wants to understand code flow. Triggers on keywords like "how does", "explain", "investigate", "understand", "what does", "where is", "how works", "logic flow", "trace", "explore feature".
PC and console game development principles. Engine selection, platform features, optimization strategies.
Red team tactics principles based on MITRE ATT&CK. Attack phases, detection evasion, reporting.
Search technical documentation using executable scripts to detect query type, fetch from llms.txt sources (context7.com), and analyze results. Use when user needs: (1) Topic-specific documentation (features/components/concepts), (2) Library/framework documentation, (3) GitHub repository analysis, (4) Documentation discovery with automated agent distribution strategy
Web application testing principles. E2E, Playwright, deep audit strategies.
Performance profiling principles. Measurement, analysis, and optimization techniques.
Mobile-first design thinking and decision-making for iOS and Android apps. Touch interaction, performance patterns, platform conventions. Teaches principles, not fixed values. Use when building React Native, Flutter, or native mobile apps.
--- name: lint-and-validate description: Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Triggers onKeywords: lint, format, check, validate, types, static analysis. allowed-tools: Read, Glob, Grep, Bash --- # Lint and Validate Skill > **MANDATORY:** Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free. ### Procedures by Ecosystem ###
Game audio principles. Sound design, music integration, adaptive audio systems.
Design thinking and decision-making for web UI. Use when designing components, layouts, color schemes, typography, or creating aesthetic interfaces. Teaches principles, not fixed values.
Use when the user asks to implement a new feature, enhancement, add functionality, build something new, or create new capabilities. Triggers on keywords like "implement", "add feature", "build", "create new", "develop", "enhancement".
Use when the user asks to generate comprehensive feature documentation with verified test cases, create feature README with code evidence, or document a complete feature with test verification. Triggers on keywords like "feature documentation", "document feature", "comprehensive docs", "feature README", "test verification", "verified documentation".
Systematic debugging framework ensuring root cause investigation before fixes. Includes four-phase debugging process, backward call stack tracing, multi-layer validation, and verification protocols. Use when encountering bugs, test failures, unexpected behavior, performance issues, or before claiming work complete. Prevents random fixes, masks over symptoms, and false completion claims.
Code review guidelines covering code quality, security, and best practices.
Use when receiving code review feedback (especially if unclear or technically questionable), when completing tasks or major features requiring review before proceeding, or before making any completion/success claims. Covers three practices - receiving feedback with technical rigor over performative agreement, requesting reviews via code-reviewer subagent, and verification gates requiring evidence before any status claims. Essential for subagent-driven development, pull requests, and preventing false completion claims.
Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments
Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems.
Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination.
Write and optimize prompts for AI-generated outcomes across text and image models. Use when crafting prompts for LLMs (Codex, GPT, Gemini), image generators (Midjourney, DALL-E, Stable Diffusion, Imagen, Flux), or video generators (Veo, Runway). Covers prompt structure, style keywords, negative prompts, chain-of-thought, few-shot examples, iterative refinement, and domain-specific patterns for marketing, code, and creative writing.
Use for PLANNING documentation with phased analysis (4 phases), gap identification, and structured knowledge modeling. Best for documentation audits, completeness analysis, and documentation strategy planning. NOT for writing actual docs (use tasks-documentation instead).
2D game development principles. Sprites, tilemaps, physics, camera.
3D game development principles. Rendering, shaders, physics, cameras.
Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.
AI operational modes (brainstorm, implement, debug, review, teach, ship, orchestrate). Use to adapt behavior based on task type.
Use when reviewing code for security vulnerabilities, implementing authorization, or ensuring data protection.
Use when analyzing and improving performance for database queries, API endpoints, or frontend rendering.
Use when the user asks to debug, diagnose, fix a bug, troubleshoot errors, investigate issues, or pastes error messages/stack traces. Triggers on keywords like "bug", "error", "fix", "not working", "broken", "debug", "stack trace", "exception", "crash", "issue".
Database design principles and decision-making. Schema design, indexing strategy, ORM selection, serverless databases.
Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.
Master Rust 1.75+ with modern async patterns, advanced type system features, and production-ready systems programming. Expert in the latest Rust ecosystem including Tokio, axum, and cutting-edge crates. Use PROACTIVELY for Rust development, performance optimization, or systems programming.
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications, OR when they provide screenshots/images/designs to replicate or draw inspiration from. For screenshot inputs, extracts design guidelines first using ai-multimodal analysis, then implements code following those guidelines. Generates creative, polished code that avoids generic AI aesthetics.
MCP (Model Context Protocol) server building principles. Tool design, resource patterns, best practices.
Automatic agent selection and intelligent task routing. Analyzes user requests and automatically selects the best specialist agent(s) without requiring explicit user mentions.
Mobile game development principles. Touch input, battery, performance, app stores.
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling.
Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".
VR/AR development principles. Comfort, interaction, performance requirements.
4-phase systematic debugging methodology with root cause analysis and evidence-based verification. Use when debugging complex issues.
Advanced vulnerability analysis principles. OWASP 2025, Supply Chain Security, attack surface mapping, risk prioritization.
Server management principles and decision-making. Process management, monitoring strategy, and scaling decisions. Teaches thinking, not commands.