Best Codex Skills to Try in 2026

Codex is a capable coding agent. What limits it is not reasoning ability but context. Out of the box, Codex does not know your preferences, cannot browse the live web, and has no awareness of the workflows your team actually follows. Skills fix this. They activate when the task matches, stay dormant when it does not, and load progressively so they never waste context on unrelated work.

The community around the openai/skills repository (19.3k stars) has grown quickly since the Agent Skills spec went cross-platform. One developer on the Codex subreddit captured it directly: "With the right skills, Codex is honestly better than Claude Code for me." That is not a universal claim, but it points at something real. The right skills reshape the experience more than prompt tuning ever will.

These are the nine I would install first.

Codex skills are directories containing a SKILL.md file and optional supporting scripts. The SKILL.md file opens with YAML frontmatter (name, description, trigger conditions) followed by markdown instructions Codex follows when the skill activates.

At startup, Codex reads only the name and description from every installed skill using a capped budget (roughly 2% of context). When you give Codex a task, it checks whether any installed skills match. If one does, the full instructions load. If nothing matches, nothing loads and context stays clean.

The format is an open standard. The same SKILL.md file works across Codex CLI, Claude Code, Gemini CLI, Cursor, and GitHub Copilot without modification. Codex can activate a skill two ways: explicit invocation (type $skill-name or /skills in the CLI) and implicit invocation when the task description matches.

Skill locations:

Codex ships with a set of system skills automatically available to every user:

• skill-creator: Builds new skills interactively through a Q&A session
• plugin-creator: Scaffolds plugin packages that bundle skills, agents, and hooks
• skill-installer: Installs curated skills from the openai/skills repository
• imagegen: Image generation inside Codex
• openai-docs: Access to OpenAI documentation as a tool

System skills are maintained by the OpenAI team alongside Codex itself. The full curated skills library lives at github.com/openai/skills. skills.sh (maintained by Vercel) is the searchable directory for the broader ecosystem across all AI coding tools.

An agent is only as smart as the context it has. The Firecrawl skill gives Codex live web context.

Codex's built-in web search queries a stale pre-scraped cache by default, silently fabricates results when network access is restricted, and returns snippets with no full-page content. The Firecrawl skill solves all of this by teaching Codex how to install and use the Firecrawl CLI automatically, giving it access to live web data without any manual configuration.

The Firecrawl CLI is built for AI agents. Results write to files rather than flooding the context window. JavaScript rendering is handled automatically. Commands map directly to how agents think about web tasks: search to find sources, scrape to read them, crawl to index an entire site, interact to control a live browser session.

If Codex is doing research, documentation lookups, or any task that requires knowing what is true today, this skill is the difference between confident answers and confident hallucinations.

Install:

npx -y firecrawl-cli@latest init --all --browser

The --all flag installs the Firecrawl skill to every detected AI coding agent on your machine. The --browser flag opens browser authentication to connect your API key. Get a free API key at firecrawl.dev/app/api-keys.

Commands Codex gets access to:

• firecrawl search: Live web search with real-time results, not a cached index
• firecrawl scrape: Clean markdown from any page, including JavaScript-heavy sites
• firecrawl crawl: Recursively follow links across an entire site
• firecrawl map: Discover all URLs on a domain
• firecrawl interact: Scrape a page, then interact with it via natural language or Playwright code

Example:

"Check the React 19 migration guide and list any breaking changes from this month"
"Crawl the Prisma docs and find every page that mentions connection pooling"
"Research the top three competitors to our product and extract their pricing structures"

Pros: JavaScript rendering is automatic. File-based output keeps context efficient. Live results replace Codex's stale cache for documentation lookups, research, and competitor analysis.

Cons: Requires an API key and consumes credits on heavy usage. The free tier (1,000 credits per month) covers substantial testing, but production research workflows may need a paid plan.

Full reference at skills.sh/firecrawl/cli. Also read: Codex web search guide for a deeper look at why the default cache falls short.

CLI Creator builds a composable CLI that future Codex threads can run by command name from any working directory.

The output is a durable tool that Codex can call repeatedly: read/write subcommands with stable JSON output, clean auth handling, and a doctor command for health checks.

The typical starting point is an API, an existing SDK, or a set of curl examples. CLI Creator wraps them into a proper CLI with discovery/resolve/read/write subcommands and a companion skill so future Codex sessions immediately know how to invoke it. This is the scaffolding pattern for extending Codex's own toolset beyond what ships by default.

Install (inside Codex):

$skill-installer cli-creator

Example:

"Build a CLI for our internal search API from this OpenAPI spec"
"Turn these curl examples into a composable CLI with a doctor command and JSON output"
"Create a CLI that wraps the Stripe API for reading customer and subscription data"

Pros: Produces CLIs with the contract Codex expects: PATH-installable, stable JSON output, doctor for health checks. The companion skill handoff means every CLI gets a skill that teaches future Codex threads how to use it. This is the right pattern for reusable tooling, not ad-hoc scripts.

Cons: Explicitly scoped to durable, reusable tools. If a short script in the current repo solves the task, the skill will steer you toward a more structured approach than you need. Not a general-purpose script generator.

Full reference: github.com/openai/skills/tree/main/skills/.curated/cli-creator.

gh-address-comments reads open review comments on a GitHub PR, presents them for selection, then applies the chosen fixes.

The skill is more structured than a fully automatic pass. It fetches all review threads and comments, numbers them with a short summary of what each fix requires, then asks you which ones to address. This matters: some review comments require judgment calls you want to make yourself. The skill handles the mechanical ones you select, and leaves the rest for you.

Install (inside Codex):

$skill-installer gh-address-comments

Example:

"Address the open review comments on this PR"
"Go through the code review and fix the comments I select"
"Help me address PR #247's review feedback"

Pros: Turns review comment resolution from a context-switching chore into a structured agent task. The numbered selection step protects against automatically applying feedback that needs your judgment. Requires gh installed and authenticated, which most developers already have.

Cons: Not fully automatic by design. The confirmation step is a feature, but it does mean you need to be present rather than walking away and letting Codex handle everything.

Full reference: github.com/openai/skills/tree/main/skills/.curated/gh-address-comments.

Yeet stages, commits, pushes, and opens a GitHub PR in one flow using gh.

Once work is done, the PR creation loop is mechanical: stage, commit with a good message, push, create the PR with a proper title and description. Yeet encodes this entire sequence, including PR template discovery (it checks .github/pull_request_template.md before creating the PR), branch reuse if a PR already exists, and draft/ready-for-review state handling.

The trigger condition is deliberately narrow: it only activates when you explicitly ask to stage, commit, push, and open a PR. It won't fire on every commit, only when you're ready to ship.

Install (inside Codex):

$skill-installer yeet

Example:

"Yeet this work"
"Stage, commit, and open a PR for everything I've built"
"Commit and create a PR for the auth refactor"

Pros: Handles the complete publish workflow in one agent task. Template-aware PR bodies mean your PRs conform to your team's format automatically. Branch reuse prevents duplicate PRs on multiple runs.

Cons: Requires gh installed and authenticated. Scoped to GitHub; does not support GitLab or Bitbucket. The commit message and PR title are generated by Codex, so review them before finalizing if your repo has strict conventions.

Full reference: github.com/openai/skills/tree/main/skills/.curated/yeet.

gh-fix-ci diagnoses failing GitHub Actions PR checks, summarizes the failure, and implements a fix after explicit approval.

The workflow is structured: verify gh auth, resolve the PR, fetch GitHub Actions logs for failing checks, extract the relevant failure snippet, draft a fix plan, and wait for your approval before touching any code. Nothing gets changed until you confirm the plan.

External CI providers (Buildkite, CircleCI, etc.) are explicitly out of scope. The skill surfaces the details URL for those and stops there, which is more honest than guessing at a fix across a provider it cannot query.

Install (inside Codex):

$skill-installer gh-fix-ci

Example:

"Fix the failing CI on this PR"
"Debug the GitHub Actions failure on PR #183"
"Why is the test check failing on this branch?"

Pros: Fetches actual GitHub Actions logs rather than asking you to paste them. The approval gate before implementation means you see the proposed fix before anything changes. Bundled Python script handles gh field drift and job-log fallbacks automatically.

Cons: Scoped to GitHub Actions only. External CI providers get a URL and nothing else. Requires gh authenticated with repo and workflow scopes.

Full reference: github.com/openai/skills/tree/main/skills/.curated/gh-fix-ci.

migrate-to-codex migrates Claude Code skills, agents, hooks, and MCP config into Codex project and user files.

If you have been using Claude Code and want to move a project or personal setup to Codex, this skill handles the full translation. It reads your Claude Code artifacts (.claude/ commands, CLAUDE.md, .mcp.json, agents, hooks, slash commands) and converts them to the equivalent Codex formats: AGENTS.md, .agents/skills/, .codex/config.toml, .codex/hooks.json, .codex/agents/.

The migration runs in a self-healing loop: scan, dry-run, run for real, fix any MANUAL MIGRATION REQUIRED blocks in the output, validate, and re-run until clean. Items that require judgment get explicit guidance rather than a broken conversion that silently misbehaves later.

Install (inside Codex):

$skill-installer migrate-to-codex

Example:

"Migrate my Claude Code setup to Codex"
"Convert my .claude/ skills and agents to Codex format"
"Migrate the MCP servers from my Claude config to Codex"

Pros: Handles the full migration scope: instructions, skills, agents, hooks, and MCP in one pass. The report table shows exactly what was converted, what needs manual review, and what could not be migrated with a reason. Does not touch source Claude Code files, so you keep a clean rollback.

Cons: Claude-specific plugin marketplaces and some hook types have no direct Codex equivalent and appear as Not Added in the report. Complex custom hooks may need review after migration. Source files are read-only during the run, so the migrated output is a separate artifact.

Full reference: github.com/openai/skills/tree/main/skills/.curated/migrate-to-codex.

Obra's finishing-a-development-branch skill runs test verification on your current branch and presents exactly four merge options.

Before presenting any options, it verifies that all tests pass. Once they do, it shows four choices: merge locally, create a pull request, keep the branch as-is, or discard with confirmation. After you choose, it handles base branch detection, git operations, and worktree cleanup. The test gate is not optional and cannot be skipped.

This skill is part of Obra's Superpowers collection (196.7K GitHub stars), the most complete multi-agent development framework available as a skill set. Within that collection, this one handles the final step: wrapping a branch cleanly before it merges.

Install:

npx skills add https://github.com/obra/superpowers --skill finishing-a-development-branch

Example:

"Finish up this branch and get it ready to merge"
"Run the finishing skill on the feature/auth-refactor branch"
"Clean up and merge this branch"

Pros: The test gate before merge options prevents shipping broken branches. Integrates cleanly with other Superpowers skills: subagent-driven-development and executing-plans both call this skill to finalize completed work. 67.1K installs.

Cons: Requires the Superpowers collection. The discard option is destructive and requires confirmation, but review what that means in your workflow before relying on it.

Full reference at skills.sh/obra/superpowers/finishing-a-development-branch.

Anthropic's mcp-builder skill walks you through building a production-quality MCP server in four structured phases.

The four phases are: deep research and planning (understanding the API and what modern MCP design actually requires), implementation (TypeScript is recommended; Python is also supported), testing, and evaluation. The evaluation phase is the one most generators skip: 10 independent, read-only questions with verifiable answers in XML format that confirm the model can actually use your server before you ship it.

This is not a one-shot generator. It is a structured guide that enforces the design principles that make MCP servers genuinely useful: API coverage over workflow tools, consistent tool naming prefixes, actionable error messages that guide the agent rather than blocking it, correct tool annotations (readOnly, destructive, idempotent), and proper pagination handling.

Install:

npx skills add https://github.com/anthropics/skills --skill mcp-builder

Example:

"Build an MCP server that exposes our internal search API"
"Create an MCP server wrapping the Stripe API for reading customer data"
"Build an MCP tool that lets agents query our Postgres database"

Pros: Produces MCP servers built to spec rather than guessed at from the protocol docs. The evaluation framework surfaces whether the model can actually use your server before you deploy it. 56.9K installs. TypeScript path is well-defined and includes code examples.

Cons: The four-phase workflow takes longer than a quick scaffold. The evaluation step requires effort: 10 questions with verifiable XML answers is a real investment. Worth it for production MCP servers; overkill for a quick internal experiment.

Full reference at skills.sh/anthropics/skills/mcp-builder.

Matt Pocock's grill-me skill interviews you relentlessly about every aspect of a plan until you reach shared understanding.

The SKILL.md instruction is direct: "Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer." If a question can be answered by reading the codebase, Codex reads it and moves on rather than asking you.

This is a design review tool. Use it before you write code, not after. The questions surface implicit assumptions, dependency chains between decisions, and gaps in your plan that seem obvious until you try to articulate them. Codex's recommended answers move the session forward rather than leaving you stuck at each question with no direction.

Install:

npx skills add https://github.com/mattpocock/skills --skill grill-me

Example:

"Grill me on this feature spec before I start building"
"Run grill-me on my plan for the auth refactor"
"Walk me through every decision in this architecture before I commit to it"

Pros: Surfaces the assumptions and dependency chains in your plan before they become bugs. Codex's recommended answers move the session forward rather than just blocking you with questions. 156.2K installs. Matt Pocock's skills collection has 87.3K GitHub stars.

Cons: Requires an actual plan or design to stress-test. "I want to build X" is too vague to grill effectively. Prepare a written spec or description before invoking the skill. The session is open-ended by design, not a checklist with a fixed number of questions.

Full reference at skills.sh/mattpocock/skills/grill-me.

These nine are a starting point. Every developer has workflows that repeat, preferences that keep getting explained from scratch, and tasks that could be encoded once and reused indefinitely. Skills are the mechanism for that.

The fastest way to build a custom skill is $skill-creator, the built-in system skill available in every Codex session. Type $skill-creator and Codex walks you through an interactive session that generates a complete SKILL.md from your description. Full reference at developers.openai.com/codex/skills.

The best practices guide from OpenAI is worth reading before building anything with multi-step instructions. It covers how to write trigger descriptions that activate reliably, how to structure inputs and outputs clearly, and when to add scripts versus keeping skills instruction-only.

You can also edit any skill on this list for your specific context. The prebuilt versions cover common patterns. Customizing them, updating the trigger conditions, or adding team-specific context is where the real leverage is.

For discovering what else exists, skills.sh is the searchable directory maintained by Vercel. It indexes published skills across Codex, Claude Code, Gemini CLI, and Cursor, searchable by category and author.

The right combination of pre-built and custom skills is what makes Codex genuinely consistent across sessions rather than starting fresh every time.