11 Must-Install Skills for Codex

Preface

Have you ever encountered this scenario: you ask AI to write a feature module, the code is indeed written, "looks fine", but it explodes on launch - boundary conditions not handled, exception handling missing, and even SQL injection risk.

If you are using Codex or other AI programming agents, you must feel these pain points: AI-written code "looks runnable, blows up on launch", in multi-step tasks when context is long it loses memory, token consumption flies fast and you don't know how to optimize, you want AI to learn to call external services but don't know how to start...

That is the root reason Skills emerged.

In 2026, Codex evolved from a pure code completion tool into a programming agent with autonomous execution capability.

Skills, as the core mechanism for Agent capability expansion, decompose complex tasks into reusable atomic capabilities, and their progressive loading mechanism can save 80-95% of token consumption.

Today's article, I will guide you through the 11 most worthwhile Skills to install in Codex, from installation configuration to underlying principles, from practical effects to pros and cons, all in one article.

I hope it helps you.

More real-world projects on Java Commando Network: susan.net.cn/project

1. What are Codex Skills?

Before starting, let's quickly explain what Skills are.

Codex Skills are an instruction pack centered around SKILL.md files.

When Codex starts, it reads the names and descriptions of all installed Skills (roughly 2% of the context budget). When you initiate a task, the system automatically matches and loads the complete instructions of the corresponding Skill.

If there is no match, it does not take up any context, making it very efficient.

More importantly, the Skills format is an open standard - the same SKILL.md can be used in Codex CLI, Claude Code, Gemini CLI, Cursor, and GitHub Copilot and other mainstream AI programming tools without modification.

Skill storage has three scopes:

[image]

Skill triggering has two methods: explicit call (enter $skill name in CLI) and implicit trigger (automatically activated when task description matches Skill description).

2. How to Install Skills?

There are mainly three ways to install Codex Skills:

Method 1: Manual clone installation (suitable for all Skills)

Clone the Skill repository to Codex's Skills directory:

# Create Codex skills directory
mkdir -p ~/.agents/skills

# Clone Skill to that directory (using superpowers as example)
git clone https://github.com/obra/superpowers.git ~/.agents/skills/superpowers

# If using Codex App, some versions may need to sync to .codex/skills
mkdir -p ~/.codex/skills
cp -r ~/.agents/skills/superpowers ~/.codex/skills/

Method 2: Official skill-installer tool (recommended)

OpenAI officially provides a mechanism to install via the $skill-installer command. For Skills in the official Skill library, you can directly install them with this tool:

# Install official skill
$skill-installer <skill-name>

# Install experimental skill
$skill-installer install https://github.com/openai/skills/tree/main/skills/.experimental/<skill-name>

Method 3: Community automation tools

The community offers multiple automated installation tools covering different installation sources and needs:

Tool	Installation method	Applicable scenario
@supercorks/skills-installer	npx @supercorks/skills-installer install	One-click skill installation, supports Git sparse checkout and Codex Agent conversion
@sstar/skill-install	skill-install install [URL or local file] --tool codex	Supports public URLs, Wiki, local files, auto-unzip and verify
@goodpostidea-tech/skills	npx @goodpostidea-tech/skills add [repo-url] --skill [name]	Install from any GitHub repository, interactive tool selection
@bbhxwl/skills	npx @bbhxwl/skills install [name] --target codex	Install from Registry, supports update and uninstall

Using @supercorks/skills-installer as an example, the complete installation process is as follows:

# Run installer
npx @supercorks/skills-installer install

# Interactive selection:
# 1. Select installation type (skills / subagents / both)
# 2. Select installation path (global or local)
# 3. Interactively check the skills to install
#    - Use up/down to navigate
#    - Use SPACE to toggle selection
#    - Use right arrow to expand and load description
#    - Use A to select all
#    - ENTER to confirm

After installation, run codex restart to activate the new skill metadata - this command clears the current session cache and reloads the trigger keywords and prerequisites defined in SKILL.md.

💡 Tip: If you want all AI tools to share the same Skill directory, you can use symbolic links. Codex does not read .claude/skills by default, but you can manage it uniformly with this command: ln -s ~/.claude/skills ~/.agents/skills

3. Where to Find More Skills?

The Codex Skills ecosystem is already quite rich. The following official Registries and resource libraries are the most noteworthy:

Registry	Features	Access address
TokRepo	500+ skills, Chinese support, community vote ranking, one-click install command	https://tokrepo.com
Anthropic official Skills	SKILL.md specification reference implementation	https://github.com/anthropics/skills
VoltAgent/awesome-agent-skills	Community Awesome list, includes official skills	https://github.com/VoltAgent/awesome-agent-skills
OpenAI Codex Skills Catalog	Codex official skill catalog	https://github.com/openai/skills
ComposioHQ/awesome-codex-skills	Composio's curated Codex skills	https://github.com/ComposioHQ/awesome-codex-skills
SkillsMP	700k+ skills, intelligent filtering	https://skillsmp.com

If you just want to get started quickly, try a one-command batch install: npx antigravity-awesome-skills --codex (requires the antigravity-awesome-skills package installed first).

4. 11 Must-Install Skills

The architecture diagram below helps you quickly understand where each Skill sits in the overall development process and their hierarchical relationships:

[image]

Now one by one, each Skill comes with its open-source address and installation command.

Skill 1: create-plan

It says goodbye to "Prompt First random coding".

Open-source address: https://github.com/openai/skills/tree/main/skills/.experimental/create-plan

Installation command:

# Official install
$skill-installer install create-plan

# Or install from LobeHub
# Visit https://lobehub.com/skills and search for create-plan

In one sentence: Forces Codex to first break down the task and output a reviewable execution plan before writing any code.

Many people may encounter this at work: give Codex a complex task like "help me change this monolith's admin module to microservice architecture", and it just starts writing.

Halfway through, you realize the path is wrong, change the prompt, and it starts from scratch again. Change it again, tens of thousands of tokens consumed, task still unfinished...

create-plan fundamentally solves the "prompt-first random coding" problem by forcing the AI to output a reviewable plan before writing code.

After installation, when you describe a requirement to Codex, it first outputs a structured execution plan (formatted as <NAME>_PLAN.md) for you to confirm before it starts writing code.

It is like a real architect's daily work steps: design first, get review approved, then start coding.

Since Codex's January update, create-plan has been partially built into the Codex CLI; Shift+Tab lets you switch freely between Plan and Code modes.

• Pros: Greatly reduces rework, ensures the big direction is right before executing; works for all complex tasks
• Cons: Adds one extra confirmation step, somewhat cumbersome for high-frequency simple tasks
• Applicable scenarios: Medium-to-large tasks spanning multiple files/modules; projects that need collaborative review of plans

Skill 2: Superpowers

It makes AI work like a rigorous engineer.

Open-source address: https://github.com/obra/superpowers

Installation command:

# Method 1: Direct clone
git clone https://github.com/obra/superpowers.git ~/.agents/skills/superpowers

# Method 2: Use npx installer
npx @supercorks/skills-installer install
# Then check superpowers in the interactive interface

# Method 3: Use skill-install tool
skill-install -t codex install https://github.com/obra/superpowers/archive/main.zip

You must restart Codex after installation because Superpowers relies on session startup hooks for skill discovery and injection.

The highest-starred Skills framework in the community (90k+).

Core problem: how to avoid AI writing code that "looks runnable but actually has pitfalls"? Superpowers' core philosophy is forced TDD (test-driven development) + automatic code review.

It contains 14 skills and 1 agent. Before Codex writes any functional code, it requires it to generate test cases; after writing code, it actively performs code review.

This "test first, implement later, check after" flow significantly reduces logic holes and missing boundary conditions.

Superpowers' workflow covers the entire development chain: brainstorming → writing-plans → test-driven-development → subagent-driven-development → requesting-code-review → verification-before-completion → finishing-a-development-branch.

Each stage has a dedicated skill to ensure quality.

• Pros: Significantly improves code quality; proactively catches boundary conditions and exception handling; reduces later debugging costs
• Cons: TDD flow adds some token consumption; not suitable for rapid prototype validation scenarios
• Applicable scenarios: Production-grade business code development; projects requiring test coverage; core feature module development

Skill 3: gh-fix-ci

It compresses 20 minutes of CI debugging into seconds.

Open-source address:

Official Skill - https://github.com/openai/skills/tree/main/skills/gh-fix-ci

Community version - https://github.com/davila7/claude-code-templates

Installation command:

# Official install
$skill-installer install gh-fix-ci

# Install from LobeHub
# curl https://lobehub.com/skills/composiohq-awesome-codex-skills-gh-fix-ci/skill.md
# Then follow the prompts to complete installation configuration

# Install from Community Registry
npx @bbhxwl/skills install gh-fix-ci --target codex

Problem solved: Debugging GitHub Actions failures is time-consuming. Many backend and DevOps engineers may spend several hours each week debugging CI failures.

gh-fix-ci automatically reads failed GitHub Actions run logs, summarizes error causes, and gives concrete fix suggestions.

This is a very clever Skill that fully automates the chain of "AI reads error logs → understands failure cause → analyzes relevant code → locates root problem → provides fix plan".

The Skill internally executes an 8-step structured flow: verify gh CLI authentication → identify failed PR checks → extract failure logs → distinguish internal/external scope of GitHub Actions → summarize failure summary → request user approval of fix plan → implement fix → push back for verification.

• Pros: Compresses a 20-minute CI debug to seconds; automatically identifies multiple error types; structured output
• Cons: Must be a GitHub Actions user, needs correct GitHub integration configuration; requires local gh CLI installation
• Applicable scenarios: Backend/full-stack/DevOps development that frequently uses GitHub Actions; multi-person collaboration projects; pre-release quality assurance

Skill 4: frontend-skill

It makes AI design attractive pages for you.

Open-source address: https://github.com/anthropics/skills/tree/main/skills/frontend-design

Installation command:

# Install from official Anthropic repository
git clone https://github.com/anthropics/skills.git ~/.agents/skills/anthropic-skills
# Then navigate to ~/.agents/skills/anthropic-skills/skills/frontend-design and use it

# Or use TokRepo one-click install
npx tokrepo install frontend-design

Pure frontend or full-stack developers should feel this most: the frontend pages Codex generates by default can run but the styling is straight out of the "retro" era.

frontend-skill encodes design principles and component styles into instructions, letting Codex generate more designed frontend pages.

The core solves the "understands function but not design" problem. The Skill encapsulates common design principles (spacing, color, typography, border radius, shadow) and modern UI framework component patterns, allowing AI to apply them automatically when generating pages.

The Skill's core goal is to avoid generating the same monotonous "AI-style" interfaces, but instead by deliberately choosing bold, clear aesthetic directions (e.g., minimalism, retro, futuristic, brutalism, etc.) and paying attention to typography, color, motion, spatial layout, and other details, to create impressive, artistic frontend pages.

• Pros: Significant visual quality improvement; works seamlessly with other design Skills
• Cons: Some complex custom designs still need human intervention
• Applicable scenarios: Frontend/indie developers quickly building dashboards, marketing pages; resource-constrained teams without professional designers

Skill 5: webapp-testing

It enables automated web application testing.

Open-source address: https://github.com/openai/skills/tree/main/skills/webapp-testing

Installation command:

$skill-installer install webapp-testing

Core value: Performs automated testing for web applications and aggregates result reports.

webapp-testing is based on the Playwright browser automation framework, able to simulate user interaction behaviors, including clicking buttons, filling forms, verifying login/logout flows, and capturing console errors.

Its core advantage lies in letting developers describe test scenarios in natural language, and the system automatically generates scripts and executes tests, finally returning results with screenshots as evidence.

The Skill automatically identifies the project's testing framework (Jest, Mocha, Playwright, Cypress), generating test cases that match existing test style, requiring no extra cleanup.

Specific workflow: The Skill first scans the project root and package.json, detects installed test frameworks, reads existing test file naming patterns and code style, then generates new test cases with consistent style.

Finally it executes tests and aggregates a report, showing pass/fail status, failure reasons, and suggested fixes in a structured way.

• Pros: Keeps consistency with existing project test style; works with any web tech stack
• Cons: Project needs an already-configured test framework; complex integration tests still require manual additions
• Applicable scenarios: Daily work for QA engineers and full-stack developers; CI flows with test coverage requirements

Skill 6: mcp-builder

It is a high-quality MCP Server construction guide.

Open-source address: https://github.com/openai/skills/tree/main/skills/mcp-builder

Installation command:

$skill-installer install mcp-builder

MCP (Model Context Protocol) is an open standard released in 2024. Its core value is establishing a standardized communication channel between models and external systems, solving the M×N integration problem.

mcp-builder guides the construction of MCP Servers that follow best practices through a four-stage workflow (plan → implement → evaluate → optimize), ensuring every MCP Server gets high-quality tool definitions, reasonable error handling, and a good user experience.

Four stages explained:

• Plan: Understand the data source/API, determine which Tools, Resources, and Templates need to be exposed
• Implement: Build the Server based on MCP SDK, supporting Python (FastMCP) or Node/TypeScript (MCP SDK)
• Evaluate: Test whether tools work as expected and response formats are correct
• Optimize: Iteratively improve performance and processing logic

The quality standard for an MCP Server is: how much it can help a large model accomplish real-world tasks.

• Pros: Standardized process prevents omissions; code quality and maintainability are ensured
• Cons: Four-stage process may be heavy for simple Servers
• Applicable scenarios: Developers building AI Agents that connect to external APIs; projects needing standardized tool sets

Skill 7: brooks-lint

It performs automated code-standards auditing.

Open-source address: https://github.com/hyhmrright/brooks-lint

Installation command:

# Method 1: Direct clone
git clone https://github.com/hyhmrright/brooks-lint.git ~/.agents/skills/brooks-lint

# Method 2: Use CLI install
npx @bbhxwl/skills install brooks-lint --target codex

A community audit-type Skill from hyhmrright/brooks-lint. Unlike typical code review tools, brooks-lint distills 6 decay-risk dimensions from six classic software engineering books to produce structured diagnoses of code:

Book	Review dimension
The Mythical Man-Month (Brooks)	Conceptual integrity, communication overhead
Code Complete (McConnell)	Code readability, construction practices
Refactoring (Fowler)	Code smells, design decay
Clean Architecture (Martin)	Architectural boundaries, dependency principles
The Pragmatic Programmer (Hunt & Thomas)	Pragmatic programming, separation of concerns
Domain-Driven Design (Evans)	Domain model integrity

It integrates code-standard checking for multiple languages, can scan pull request changes, detect code formatting, naming, comment compliance issues based on project rules, and directly give the specific violation location and fix guidance.

Triggering is flexible: it can run automatically as a CI Job in GitHub Actions, or as a pre-commit quality gate in local Git Hooks.

• Pros: Efficient automated code-standard gatekeeping; embeddable in CI/Hook flows; deep authority-book-driven diagnosis
• Cons: Requires correct project rule-set configuration for ideal results
• Applicable scenarios: Teams needing uniform code style; standard part of code review processes

Skill 8: pr-review

It is AI-driven automated PR review.

Open-source address: https://github.com/openai/skills (official Skill directory)

Installation command:

$skill-installer install pr-review

When code is submitted as a PR, Codex automatically scans changed files and outputs a structured issue report without human intervention. It supports multi-dimensional analysis: functional correctness, architectural soundness, security vulnerabilities, and can combine multiple AIs (Claude, Codex, Gemini) for a comprehensive PR review.

Trigger method: Usually via GitHub Actions (on: pull_request: types: [opened, synchronize, reopened]), Codex reads the diff of changed files, checks for null pointers, resource leaks, API compatibility, security vulnerabilities, and other dimensions, then outputs a structured review report.

The report can be presented directly as a PR comment.

• Pros: Greatly reduces manual code review workload; available 24/7
• Cons: Needs correct automated trigger configuration; complex business logic may need human intervention
• Applicable scenarios: Daily PR flows in multi-person collaboration projects; team code review efficiency optimization

Skill 9: Planning-with-Files

It turns Markdown into an external memory bank.

Open-source address: https://github.com/OthmanAdi/planning-with-files

Installation command:

# Method 1: Use plugin marketplace (if using Claude Code, Codex likewise maps to .agents/skills)
/plugin marketplace add OthmanAdi/planning-with-files
/plugin install planning-with-files@planning-with-files

# Method 2: Manual install
mkdir -p ~/.agents/skills/planning-with-files
curl -L -o skill.zip "https://mcp.directory/api/skills/download/593"
unzip -o skill.zip -d ~/.agents/skills/planning-with-files
rm skill.zip

One major advantage of the Skill system is the progressive loading mechanism.

The AI main context only uses a 2% budget to read Skill summaries; real domain knowledge loads on demand, never blowing up the context window.

Planning-with-Files takes this mechanism to its fullest, using Markdown files as an "external memory bank" for the AI.

The AI can write intermediate results, decision records, and to-do items into Markdown files during execution, and read them at any later step.

The deeper value of this mechanism: when a task chain grows too long for a single conversation's Token budget, Markdown files serve as a persistent, readable/writable external memory.

The Skill creates and maintains three files:

• task_plan.md — task decomposition and overall planning, recording stage progress and decisions
• findings.md — investigation findings and intermediate conclusions, recording each session's actions and errors
• progress.md — current progress and completed steps

The most practical part: after executing /clear to clear context, Codex can fully restore state from these files without losing previous progress.

This feature is critical for large feature development spanning multiple sessions.

• Pros: Breaks the context limit of single conversations; greatly improves execution of long-process tasks
• Cons: File read/write operations incur some I/O overhead
• Applicable scenarios: Large refactoring/development tasks requiring multiple rounds of interaction; scenarios with high traceability requirements for AI execution progress

Skill 10: DocumentSkills

It has strong document parsing capability.

Open-source address: https://github.com/anthropics/skills (Anthropic official Skills repository)

Installation command:

# Clone official repository
git clone https://github.com/anthropics/skills.git ~/.agents/skills/anthropic-skills

# Then use PDF, Word, Excel, PPT parsing in skills/document-skills directory

# Or install via /plugin marketplace
/plugin marketplace add anthropics/skills/plugin
/plugin install document-skills@anthropic-agent-skills

Supports opening PDF, Word, Excel, and other documents directly in the Codex sidebar for preview.

The underlying technology relies on large models' document parsing ability to convert unstructured document content into structured data AI can understand.

When you need Codex to understand a product requirements document, API documentation, or technical design specification, DocumentSkills lets the AI "read" it and execute tasks based on the document content.

This Skill comes from the Anthropic official repository and is designed for developers handling large volumes of technical or requirement documents.

• Pros: Expands AI's knowledge sources beyond just the codebase; enables document-driven development workflow
• Cons: Document format complexity affects parsing accuracy
• Applicable scenarios: Generating code from requirement documents; processing existing project technical documentation

Skill 11: Context-Engineering

It teaches AI to manage its own context.

Open-source address: https://github.com/openai/skills (experimental skill)

Installation command:

$skill-installer install context-engineering

AI is "ignorant" of its own token consumption and context state while working. The Context Engineering Skill solves this, including core capabilities like context monitoring, compression, and priority management.

Technical mechanism: continuously monitors token usage during task execution, actively compresses or summarizes non-core context when approaching the limit; ensures critical context is not squeezed out of the window before high-priority tasks.

For long-running Agents, this Skill helps avoid "dropping the ball".

The Context Engineering Suite in antigravity-awesome-skills contains 7 complete context management tools.

• Pros: Reduces "amnesia" in long conversations; automatically optimizes token usage
• Cons: Compression strategies may cause some information loss
• Applicable scenarios: Long-running AI tasks; AI usage scenarios requiring fine-grained cost control

5. Underlying Principles

The noticeable efficiency gains of the Skills above come from the design of the Skill system behind them.

We can clearly see the complete workflow and technical implementation of a Skill through this flow diagram:

[image]

The most critical technical point in this flow is: the progressive loading mechanism.

The Skill system uses a "2% budget preview + on-demand loading" mode. While ensuring the AI has sufficient context knowledge, it dramatically reduces token consumption.

Here is a real test comparison: using traditional Prompts to process 100,000 customer service inquiries consumes about 15M tokens; the MCP solution drops it to about 12M (including about 1.5M protocol overhead); the Skill solution through knowledge compression can drop token consumption to 2-3M, equivalent to saving 80-90%.

Additionally, the MCP protocol defines the standard for models interacting with external systems — supporting JSON-RPC 2.0 communication and using a client-server model.

When a Skill needs external data, MCP converts database query results or API responses into model-understandable JSON format, greatly simplifying the process of AI calling external services.

The Skill system's loading mechanism is also worth attention: Codex performs a BFS breadth-first traversal at startup, searching up to 6 directory levels, with a global maximum of 2000 directories to find SKILL.md files.

This design controls scanning overhead while ensuring skill discoverability.

6. Pros, Cons, and Usage Suggestions

Advantages:

• Token-efficient, core knowledge progressively loads, saving 80-95% compared to traditional Prompts
• Knowledge can be accumulated; a Skill is essentially "executable domain knowledge", with reusable experience and version control
• Skills are composable; any number can be invoked together to execute complex tasks
• High output consistency; knowledge consolidation can improve output consistency by 300%
• Cross-platform universal; the same SKILL.md works with Codex, Claude Code, Cursor, and other tools

Disadvantages:

• Requires learning and setup; initial time to understand Skill configuration and recommended lists
• Quality varies; it is recommended to start with high-community-traffic/official Skills to avoid "Skill stacking"
• Some scenarios are less flexible than direct Prompts; for highly customized tasks, it may add extra steps

Applicable scenario recommendations:

[image]

Remember two key principles:

• Not about having more, but having the "right" ones.
• Skills don't replace human thinking; they amplify your thinking efficiency.

More real-world projects on Java Commando Network: susan.net.cn/project

Summary

If 2024 was the "protocol founding year" for MCP, then 2026 is the "application explosion year" for Skills.

Through the design philosophy of "expert knowledge encapsulation + progressive loading", the Skill system provides a powerful capability extension mechanism for AI Agents.

From initial custom Skills to today's community ecosystem with thousands of Skills indexed by awesome-agent-skills.

The 11 Skills above are my "truly must-install" list after more than half a year of practical screening.

Suggested installation path: first install create-plan to experience task decomposition, then install Superpowers to make TDD and code review new habits for AI, then add targeted Skills like gh-fix-ci, frontend-skill as needed.

Pair with planning-with-files and Context-Engineering as the dynamic duo, and even large refactoring tasks spanning days can be done efficiently by AI without dropping the ball.

One sentence to share: With Skills used well, AI goes from an intern who "can answer anything" to a senior architect who "understands everything" in an instant.

If today's sharing is helpful to you, click "like" and forward it to more friends who need to improve their efficiency!

Finally, a question for everyone:

Which is better: Codex or Claude Code?