andrewr303

doc-expert

Use when processing PDFs or books for structured JSON extraction, RAG ingestion, source grounding, document quality checks, or source-grounded Codex plugin development.

Ultimate browser-agent QA workflow for web apps. Use when the user asks to test, audit, verify, break, smoke-test, or regression-test UI, navigation, forms, authenticated flows, responsive behavior, accessibility, or AI-powered features using a real browser, Browserbase, Stagehand, agent-browser, browse, Playwright, or AutoBrowse-style iteration.

claude-design-agent-qa

QA Claude Design handoffs after implementation. Use when the user provides a Claude Design .dc.html file, HTML prototype, handoff bundle, screenshot, image, or design export and wants to compare it against a live app, verify 1:1 design fidelity, then test functionality, navigation, responsive behavior, accessibility, and AI features in a real browser.

agent-skills

Discover and apply the Agent Skills engineering workflow collection in Codex. Use when starting a coding session, selecting a software-development workflow skill, or deciding which Agent Skills sub-skill applies to specification, planning, implementation, testing, review, security, performance, documentation, CI/CD, migration, observability, or shipping work.

api-and-interface-design

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.

browser-testing-with-devtools

Tests in real browsers via Chrome DevTools MCP. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data. Requires the chrome-devtools MCP server to be configured.

DevOps & Infrastructure Listed

ci-cd-and-automation

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

code-review-and-quality

Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

code-simplification

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

context-engineering

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

debugging-and-error-recovery

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

deprecation-and-migration

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

documentation-and-adrs

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

doubt-driven-development

Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a confident output would be cheaper to verify now than to debug later.

frontend-ui-engineering

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

git-workflow-and-versioning

Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.

idea-refine

Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan".

incremental-implementation

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

interview-me

Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invokes ("interview me", "grill me", "are we sure?", "stress-test my thinking"), or when you catch yourself silently filling in ambiguous requirements before any plan, spec, or code exists.

observability-and-instrumentation

Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.

planning-and-task-breakdown

Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.

security-and-hardening

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.

DevOps & Infrastructure Listed

shipping-and-launch

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

source-driven-development

Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.

spec-driven-development

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

test-driven-development

Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.

karpathy-guidelines

Behavioral coding-agent guardrails adapted from the Karpathy-inspired Claude/Cursor skill archive. Use when writing, reviewing, refactoring, debugging, or planning code changes where Codex should surface assumptions, avoid overengineering, keep diffs surgical, preserve unrelated user work, and define verifiable success criteria before declaring the task done.

chrome-extension-developer

Ultimate Codex workflow for Google Chrome extension work: Manifest V3, WXT, Plasmo, CRXJS, content scripts, service workers, popup UI, side panel, permissions, testing, security review, payments, assets, and Chrome Web Store publishing.

extension-analyze

Audit Chrome extensions for security issues, best practice violations, performance problems, and CWS compliance. Scans manifest, code, CSP, message handlers, storage, and dependencies.

extension-assets

Generate and manage all Chrome extension assets: icons (16–128px), CWS listing images, promotional tiles, and public/ folder setup. Supports ImageMagick, Gemini API, and manual prompt templates.

extension-backend

Build backend APIs for Chrome extensions. NestJS + MongoDB (Mongoose) recommended stack. Auth, webhooks, license verification, CORS. Use when: backend, API, server, database, license, webhook.

extension-create

Auto-scaffold Chrome extensions with WXT or Plasmo. Ask user for name/features, scaffold, configure entrypoints. Use when: create extension, scaffold, new extension.

extension-dev

Detect Chrome extension framework/stack, find proper docs, implement features, and debug across service worker, content script, and popup contexts.

extension-manifest

Generate and validate manifest.json with optimal permissions for Chrome MV3 extensions. Analyzes code to determine minimum permissions. Use when: manifest, permissions, manifest.json.

extension-migration

Migrate Chrome extensions from MV2 to MV3. Service workers, declarativeNetRequest, API replacements. Use when: migrate, mv2, mv3, manifest v2.

extension-payment

Integrate payment gateways into Chrome extensions. Stripe, Paddle, Lemon Squeezy, Polar, PayPal, and more. Licensing, subscriptions, freemium. Use when: payment, monetize, subscribe, billing, premium.

extension-publish

Prepare, submit, and optimize Chrome Web Store listings. Covers workflow, checklist, rejection reasons, listing optimization, and CI/CD automation.

extension-review

Scan extension source code for Chrome Web Store rejection risks. Generates report with issues, root causes, and fixes. Use when: review, pre-submit, rejection, CWS compliance, store review.

extension-test

Set up and run unit, integration, and E2E tests for Chrome extensions. Covers Jest mocks for chrome.* APIs and Puppeteer E2E with real Chrome.

extension-ui

Build polished Chrome extension UIs (popup/sidepanel/options). Analyze existing UI, suggest improvements, set up design systems, enforce a11y and UX best practices.

claude-design-handoff

Implement designs handed off from Claude Design (claude.ai/design) into a real Next.js/TypeScript/React codebase with 1:1 visual fidelity AND working integration with live data and AI features. Use this whenever the user wants to build, implement, port, or "make real" a design that came from Claude Design: a handoff bundle (a folder whose README starts with "CODING AGENTS: READ THIS FIRST"), an exported .zip or standalone HTML, a set of .jsx prototype files plus a primary .html, or the user says things like "implement this design," "build this 1:1," "pixel-perfect," "I exported this from Claude Design," or "wire this design into the app." Trigger it even when the user only attaches a screenshot or PDF of a Claude Design mockup and asks to build it, and even when they describe a dashboard/report/genome/page design rather than naming Claude Design explicitly. Do not skip this skill in favor of eyeballing a screenshot and free-handing components: the failure mode it exists to prevent is exactly that.

claude-design-production-architect

Production-grade implementation workflow for Claude Design exports, handoff ZIPs, screenshots, or HTML/CSS/JSX prototypes. Use when the user wants to create a Claude Design prompt, convert Claude Design files into React/TypeScript, implement a design into a complex app/backend, wire AI-powered features safely, audit responsive/layout problems, or detect and repair AI-slop/prototype-only design patterns. Builds on claude-design-handoff by adding converter-assisted inventory, backend/AI contract discovery, responsive breakpoint triage, design issue repair, and strict verification gates.

codewiki-builder

Generate, deepen, validate, and incrementally maintain comprehensive codebase wikis with architecture diagrams, source evidence, commit-pinned links, cross-references, and first-run preferences. Use for codebase documentation, architecture onboarding, repository wikis, documentation drift, C4 or Mermaid diagrams, or requests to explain an entire repository.

deep-document-insights

Process books, PDFs, EPUBs, Office files, web exports, and dense long documents into deep AI-ready Markdown insight breakdowns for prompt improvement or knowledge-base use.

worktree

Creates git worktrees for isolated development. Use when user wants to "create a worktree", "start a new feature branch", "work on a fix in isolation", or needs a parallel development environment.

document-chunker

Use this skill when the task involves processing large files or document sets with Codex as the AI coworker: document ingestion, file inventory, parsing, chunking, structured extraction, embeddings preparation, retrieval QA, SEC/Form D processing, HypeStake knowledge ingestion, or auditing .chunks.jsonl outputs. All AI interpretation must be performed by Codex, not by bundled scripts.

beautiful-prose

A hard-edged style contract for prose that cannot be identified as AI-generated. Governs writing and rewriting at four levels (phrase, sentence, structure, idea) so output is clean, exact, concrete, rhythmically alive, and free of AI cadence, filler, hedging, and therapeutic tone. Use for ANY task where prose quality matters or the writing must read as human, including essays, memos, op-eds, letters, speeches, blog posts, newsletters, personal statements, founder or marketing copy, fiction, and rewrites. Also trigger on requests like "make this sound human," "less AI," "remove the AI tone," "punchier," "sharper," "more elegant," "tighten this up," or "no slop," even when the user never names the skill.

canvas-design-codex

Use when Codex needs to build, revise, debug, or verify canvas, SVG, WebGL, Three.js, custom charting, diagram, game, generative visual, or pixel-based browser artwork where screenshot, pixel, animation, or image bounds evidence matters.

documents

Create, edit, redline, and comment on `.docx`, Word, and Google Docs-targeted document artifacts inside the container, with a strict render-and-verify workflow. Use `render_docx.py` to generate page PNGs (and optional PDF) for visual QA, then iterate until layout is flawless before delivering the final document.