What skills are in Codex, which types exist and how to use them

In Codex, a skill is a reusable specialization layer. It gives the agent additional procedural knowledge, reference material and, when needed, helper scripts or templates for a specific class of tasks.

In practice, this means one simple thing: instead of explaining the same workflow again and again in every conversation, you can package that workflow into a skill and let Codex load it whenever the task matches.

Core idea

A skill does not replace Codex. It narrows and sharpens Codex for a specific job so the agent works from a repeatable system rather than from a blank page every time.

What a skill actually does

Skills are useful when the work is repetitive, domain-specific or fragile enough that you want the same high-quality process every time. A strong skill usually adds one or more of these layers:

specialized workflow instructions;
domain-specific rules or business logic;
references that Codex can load when needed;
scripts for deterministic tasks;
assets or templates used in the final output.

What skills are available in this Codex environment

In this environment the most relevant built-in skills include:

skill-creator for creating or improving skills.
imagegen for generating or editing bitmap visuals.
openai-docs for up-to-date official OpenAI documentation workflows.
plugin-creator for scaffolding Codex plugins.
skill-installer for installing skills from a curated source or repository.

What each of them is for

skill-creator

Use this when you want to build a new custom skill for Codex: define the trigger, decide whether scripts or references are needed, generate the folder structure and keep the skill concise enough to be useful.

imagegen

Use this when the task benefits from actual raster assets: article covers, textured backgrounds, mockups or bitmap editing.

openai-docs

Use this when the task depends on current official OpenAI docs: models, SDK changes, Responses API, agent patterns or migration guidance.

plugin-creator / skill-installer

Use these when you want to scaffold a plugin or install an existing skill instead of creating everything manually.

How to use skills in practice

There are three normal ways to use a skill:

Describe the task normally and let Codex trigger the skill.
Name the skill explicitly in the request.
Ask Codex to build a new custom skill for your workflow.

use imagegen and generate 3 cover variants for the article
use openai-docs and verify the current Responses API flow from the official documentation
use $skill-creator and create a skill for SEO audits of service pages

When a custom skill is worth creating

A custom skill makes sense when your team keeps solving the same class of problem with the same rules. This can be:

SEO audits for service pages and landing pages;
copy polishing for a studio site;
case study packaging for a portfolio;
Telegram delivery workflows;
AI integration checklists;
article formatting in a house editorial style.

If a task keeps repeating, the question is no longer “can Codex do it?”. The better question is “should we package it into a repeatable skill?”.

What a skill is not

A skill is not a giant dump of theory. It should stay concise, focused and operational. The point is not to overwhelm the model with extra context, but to give it exactly the guidance it would not reliably reconstruct on its own every time.

What a strong skill folder usually contains

SKILL.md with frontmatter and actual instructions.
scripts/ when deterministic steps are needed.
references/ when domain docs or policies matter.
assets/ when output files or templates are reused.

How to think about the quality bar

A good skill is not long for the sake of being long. It is useful, compact and specific. It should help Codex move faster with fewer wrong turns, not bury the real task under extra text.

Weak skill

Too much theory and too little action
No clear trigger condition
No distinction between core rules and references
Repeats things Codex already knows

Stronger skill

Clear trigger and scope
Compact process with useful constraints
References loaded only when needed
Reusable scripts or templates where repetition matters

Practical conclusion

If you work with Codex regularly, skills are one of the most useful ways to stop reinventing the same process on every request. They let you turn good repeated practice into a reusable operating layer.