10 Best OpenAI Codex Skills in 2026 (Tested, With Install Commands)

Install this first. Everything else is sharper once you do.

Superpowers is not a single skill. It's a complete software-development methodology built on composable skills, created by Jesse Vincent. It ships skills for test-driven development (real RED-GREEN-REFACTOR), systematic debugging with root-cause analysis, planning, code review, git worktree management and subagent coordination.

Codex's default behaviour is "jump straight into code." Superpowers forces a structured flow instead: design refinement through conversation, a plan you approve in digestible chunks, then execution with built-in review by fresh subagents. On anything bigger than a one-file change, the difference in output is large.

Does it actually run better on Codex? Its author thinks it might. In his porting writeup, Jesse Vincent notes that "GPT5-Codex may actually be better at using skills than Claude" because the model is exceptionally literal about following instructions.

Install on Codex: paste this into a Codex CLI window, Fetch https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md and follow the instructions. It's a self-installing prompt, not the Claude plugin flow, so don't follow a /plugins guide for Codex.

Verdict: the one non-negotiable install. Just know what it is, a self-installing agent that edits your AGENTS.md (more on that risk below).

mcp-builder is the skill I install the day I build any MCP (Model Context Protocol) server. Its SKILL.md is a full guide to designing high-quality tools: research and planning, implementation, review, and, the part most people skip, writing an evaluation for the server. It scaffolds both Python (FastMCP) and TypeScript/Node servers.

If you have ever shipped an MCP server with tools the agent can't figure out how to call, this is the fix. It bakes in the "write the eval first" discipline that keeps tools actually usable.

Verdict: essential the moment you touch MCP. Skip it and your server's tools will be a guessing game.

figma-implement-design is in OpenAI's curated catalog. It converts a Figma design into production frontend code with real fidelity, because it reads the design through the Figma MCP server, not a screenshot.

Pasting a Figma screenshot into a chat works, badly. You lose spacing tokens, colour variables and component structure. Because this skill talks to Figma through MCP, it has the underlying tokens, so the output respects your design system instead of guessing pixel values. You connect the Figma MCP server and pass a design URL in the form https://figma.com/design/:fileKey/:fileName?node-id=1-2.

Pair it with figma-code-connect-components in the same catalog if you already maintain a Code Connect mapping, Codex respects those mappings cleanly.

Verdict: the honest bridge from design to code. The MCP connection is the whole reason it beats screenshot-to-code.

codebase-migrate is the right pattern for large migrations. Instead of one unreviewable mega-PR, it runs the refactor in CI-verified batches. Codex drives the local edits with jscodeshift, ts-morph, comby or ast-grep; the Composio CLI handles the ceremony, a tracking issue, per-batch PRs, and waiting for green CI between each batch.

A 200-file migration in one PR is unreviewable. The same migration in 20 PRs of 10 files each, CI running on every step, is exactly how senior engineers do it by hand. This skill just automates that discipline. Good for framework upgrades (React 17 → 19, Django 4 → 5), API renames across a monorepo, and tool swaps (webpack → vite, jest → vitest).

Prereqs: install the Composio CLI with curl -fsSL https://composio.dev/install | bash, then composio login, composio link github, and optionally composio link linear or composio link jira for tracking.

Verdict: the skill that stops "refactor everything in one PR" disasters. Worth the CLI setup the day you face a big migration.

create-plan drafts a plan before Codex writes a line. It runs read-only, scans your README, docs/, CONTRIBUTING.md and ARCHITECTURE.md, asks at most one or two blocking questions, and outputs intent, scope (in and out), and a concrete next-steps checklist.

Codex is fast. Speed without alignment gives you beautiful code that solves the wrong problem. create-plan forces a short pause where Codex states what it thinks you want, so you catch the misread before rework piles up. It composes cleanly inside Superpowers' planning phase too.

Verdict: the cheapest insurance policy here. This is what fixes "Codex did the wrong thing, fast."

gh-fix-ci is the highest-ROI skill for anyone shipping through GitHub. It uses the gh CLI to find your failing PR checks, pulls the GitHub Actions logs, summarises the real failure in plain English, and proposes a fix, implementing only after you approve. No surprise pushes.

Most CI failures are dumb, a wrong path in a YAML file, a missing env var, a flaky test. gh-fix-ci does that triage in ten seconds instead of you spelunking the Actions UI for five minutes. Authenticate once with gh auth login and confirm gh auth status; the skill needs repo and workflow scopes.

Verdict: install it before your next red build. It pays for itself the first time.

gh-address-comments is the natural pair to gh-fix-ci. It uses gh to pull the review comments on your current branch's PR, groups them by file, and walks Codex through addressing each one, replying or committing per resolved comment so the thread stays clean.

Review feedback is the most context-switch-heavy part of shipping. You open a PR, lose the mental model, come back tomorrow, then re-page fifteen comments. This skill removes that, Codex has the comments and the codebase open in one session, walks them in order, and leaves you to approve the batch.

Verdict: gh-fix-ci covers the CI side, this covers the human side. Run both.

playwright is OpenAI's official curated skill for driving a real browser via playwright-cli, navigation, form filling, snapshots, screenshots, data extraction, UI-flow debugging. It ships a wrapper script so the CLI works even when it isn't globally installed. The companion playwright-interactive skill drops you into a live loop where Codex drives the browser and watches outputs in real time.

Where it shines: regression testing on a deploy, reproducing a customer's UI bug, verifying a form flow after a refactor. Codex writes the command, runs it, captures screenshots and console output, and tells you what broke, no separate test runner open. It stays CLI-first and won't pivot to @playwright/test files unless you ask.

Verdict: the cleanest E2E flow I've used inside any agent. Pair with the catalog's screenshot skill for fast visual diffs.

stop-slop by Hardik Pandya is, in its own words, "a skill file for removing AI tells from prose." It strips em-dashes, throat-clearing openers, over-used verbs like "delve" and "leverage", "moreover/furthermore" filler, and the generic adjective stacking that screams machine-written.

If you draft README files, release notes or PR descriptions with Codex, the default output reads recognisably AI-written. This is a single-pass cleaner that pushes it closer to a human voice.

One honest note: the repo documents Claude-style installs, but it's a portable SKILL.md, so dropping it into ~/.codex/skills/stop-slop/ works fine, then ask Codex to run it after drafting prose.

Verdict: install it the day you ask Codex to write docs. Ironic that a tool needs a tool to sound human, but here we are.

skill-creator is the meta-skill, a guide for creating skills that extend Codex with your own workflows and knowledge. Once you've used four or five skills, you start spotting gaps: your team's exact deploy ritual, your debugging conventions, your publishing checklist.

The hard part of a skill isn't the instructions, it's writing a description: discoverable enough that Codex actually triggers it. skill-creator handles exactly that: proper frontmatter, useful descriptions, progressive disclosure, helper scripts in the right structure. Pair it with template-skill from the same repo as a scaffold, together they cut authoring a new skill from a few hours to about thirty minutes.

Verdict: the skill that pays back fastest, once you know what a good skill feels like. Install it after a few others.