OpenAI Quietly Rolls Out Skills: Now Available in ChatGPT and Codex CLI

Summary

OpenAI has introduced a Skills feature to both ChatGPT and Codex CLI, modeled after Anthropic’s Skills mechanism. A “skill” is a folder containing a Markdown file and optional resources/scripts, enabling tasks like PDF processing, document handling, and plugin development. ChatGPT integrates skills via its Code Interpreter, while Codex CLI supports custom skill installation—both delivering practical, scalable AI capabilities.

If you follow AI tool advancements, you may have noticed a subtle but impactful update: OpenAI has quietly added “Skills” to ChatGPT and its open-source Codex CLI. First popularized by Anthropic in October 2025, this feature has quickly been adopted by OpenAI—leaving many users wondering: What exactly are these skills? What can they do? And how do you use them? Let’s break it all down in detail.

What Are “Skills”?

At their core, skills are surprisingly simple: a folder containing a Markdown file, plus optional supplementary resources and scripts.

This lightweight design is genius—any large language model (LLM) tool that can navigate and read file systems can theoretically use them. When Anthropic launched its Skills mechanism in October, industry observers predicted rapid adoption by other platforms. OpenAI has delivered on that expectation, rolling out skill support to both ChatGPT and Codex CLI by early December.

Skills act as “modular playbooks” for LLMs, guiding them through specific tasks with step-by-step instructions, tool preferences, and quality standards. Unlike rigid APIs or complex plugins, they’re flexible, easy to customize, and compatible with most LLM-powered tools—making them a game-changer for task-specific AI workflows.

Skills in ChatGPT: Hidden Power in the Code Interpreter

How to Access ChatGPT’s Built-in Skills

ChatGPT’s Skills are integrated into its Code Interpreter feature. In December 2025, users discovered a dedicated folder: /home/oai/skills.

To explore its contents, simply prompt ChatGPT:

“

Create a zip file of /home/oai/skills

ChatGPT will generate a downloadable zip archive with all available skills. You can also browse the folder’s structure using tools like Simon Willison’s Zip Wheel Explorer (linked in the original research).

Currently, ChatGPT’s skills focus on three high-demand tasks:

  • Spreadsheet processing
  • DOCX document handling
  • PDF reading, creation, and review

The PDF processing skill is particularly comprehensive—let’s dive into its capabilities.

PDF Processing Skill: Beyond Basic Text Extraction

The skills/pdfs/skill.md file outlines detailed guidelines for working with PDFs, covering three key phases: reading, creation, and quality control. Here’s how it works in practice:

Reading PDFs: Preserve Visual Context

The skill prioritizes retaining layout, charts, and diagrams—something plain text extraction often fails to do. The recommended workflow is:

  1. Convert PDFs to page-by-page PNGs using the command:

    pdftoppm -png $OUTDIR/$BASENAME.pdf $OUTDIR/$BASENAME

    This ensures visual elements (tables, figures, diagrams) are preserved.

  2. Use pdfplumber as a complementary tool for text extraction—but not as a replacement for PNG conversion.
  3. Avoid relying solely on Python’s text-printing functions, as they often miss critical visual details.

Creating PDFs: Tools and Best Practices

For PDF generation, the skill emphasizes consistency and reliability:

  • Primary tool: Use reportlab for programmatic PDF creation (recommended for most use cases).
  • Alternative tools: You can use pypdf or pyMuPDF if needed, but you’ll first need to install them via pip.
  • Critical quality check: After every meaningful update (content additions, layout tweaks, style changes), render the PDF to PNGs with:

    pdftoppm -png $INPUT_PDF $OUTPUT_PREFIX

    Inspect each PNG to ensure no errors (e.g., clipped text, overlapping elements). Repeat the “render → inspect” loop until the PDF is visually flawless.

Quality Standards for Professional PDFs

The skill sets clear expectations for polished outputs:

  • Visual consistency: Uniform typography, spacing, margins, color schemes, and section breaks across all pages.
  • No rendering errors: No clipped text, overlapping elements, black squares, broken tables, or unreadable glyphs. The final product should look curated, not like raw template output.
  • Sharp visuals: Charts, tables, diagrams, and images must be high-resolution, well-aligned, and properly labeled. Legends and axes should be readable without zooming.
  • Readable text: Avoid dense blocks of filler text or unstructured bullet lists. Use whitespace to organize ideas, and ensure text is legible at normal viewing sizes.
  • Special character caution: Do not use the U+2011 non-breaking hyphen or other Unicode dashes, as they may cause rendering issues.

Hands-On Test: Generating a PDF About Kakapo Breeding

To put the PDF skill to the test, a user prompted ChatGPT:

“

Create a PDF with a summary of the rimu tree situation right now and what it means for kakapo breeding season

Here’s what happened next:

  1. ChatGPT first acknowledged the skill: Reading skill.md for PDF creation guidelines.
  2. It researched the topic: Searching rimu mast and Kākāpō 2025 breeding status.
  3. It generated the PDF—taking 11 minutes to complete.

Why the delay? ChatGPT was meticulous about quality control. For example, it noticed that the Māori word “kākāpō” (a critically endangered parrot) had broken macrons (long vowels) when using the Helvetica font. It immediately corrected the issue:

“

“Fixing font issues with macrons. The page is showing black squares for words like ‘kākāpō,’ probably because Helvetica can’t handle macrons. I’ll switch to a font that supports them, such as DejaVu Sans or Noto Sans. I’ll register both regular and bold fonts, then apply them to the document. I’ll update the footer to note the issue with Helvetica. Time to rebuild the PDF!”

The final PDF included key, verifiable data:

  • Kākāpō population (DOC official count): 237 birds
  • Breeding trigger (rimu fruiting): >10% of rimu branch tips bearing fruit
  • 2026 rimu fruiting forecast (DOC monitoring): 50–60% fruiting across breeding islands
  • Breeding-age females (DOC 2025 planning): ~87 females (nearly all may nest)

You can view the full PDF using Simon Willison’s custom PDF viewer tool.

Skills in Codex CLI: Supercharge Your Command-Line Workflow

How Codex CLI Supports Skills

OpenAI’s open-source Codex CLI added experimental skill support two weeks prior to ChatGPT’s rollout (via PR #7412, titled “feat: experimental support for skills.md”). According to the official documentation:

“

Any folder placed in ~/.codex/skills will be recognized as a skill.

The skill system is powered by a prompt template (viewable in the Codex repository’s render.rs file), which guides the LLM to use installed skills when relevant.

Step-by-Step Guide to Using Skills in Codex CLI

Let’s walk through a real-world example: creating a Datasette plugin using a custom skill.

1. Find or Create a Skill

First, you’ll need a skill folder. For this test, a user used Claude Opus 4.5’s skill-authoring feature to create a “Datasette Plugin Development” skill, hosted on GitHub (https://github.com/datasette/skill).

2. Install the Skill

Clone the skill folder into Codex CLI’s designated skills directory:

git clone https://github.com/datasette/skill \
  ~/.codex/skills/datasette-plugin

3. Enable Skills in Codex CLI

Navigate to a working directory and run Codex CLI with the --enable skills flag (and specify a model like GPT-5.2):

cd /tmp
mkdir datasette-cowsay
cd datasette-cowsay
codex --enable skills -m gpt-5.2

4. List Installed Skills

To confirm the skill is active, prompt Codex CLI:

“

list skills

The response will show your installed skills:

- datasette-plugins — Writing Datasette plugins using Python + pluggy (file: /Users/simon/.codex/skills/datasette-plugin/SKILL.md)
- Discovery — How to find/identify available skills (no SKILL.md path provided in the list)

5. Use the Skill to Build a Plugin

Prompt Codex CLI to complete a task using the skill:

“

Write a Datasette plugin in this folder adding a /-/cowsay?text=hello page that displays a pre with cowsay from PyPI saying that text

6. Test the Result

The plugin works immediately! To run it, use uvx (a Python package runner):

uvx --with https://github.com/simonw/datasette-cowsay/archive/refs/heads/main.zip \
  datasette

Visit http://127.0.0.1:8001/-/cowsay?text=This+is+pretty+fun in your browser, and you’ll see an ASCII art cow displaying your text—a perfect example of the skill’s practical utility.

Why Skills Are a Game-Changer for AI Tools

When Anthropic launched Skills in October, many experts (including the original author) noted they could be “a bigger deal than MCP” (Anthropic’s Multimodal Coordination Protocol). OpenAI’s rapid adoption reinforces this sentiment—here’s why skills matter:

1. Lightweight and Interoperable

Skills require no complex infrastructure—just folders and Markdown files. This makes them easy to share, modify, and adapt across LLM tools (ChatGPT, Codex CLI, Claude, etc.).

2. Task-Specific Precision

Unlike general-purpose LLM prompts, skills provide granular guidance: tool choices, quality standards, and step-by-step workflows. This reduces errors and ensures consistent, professional outputs.

3. User-Centric Customization

Developers and power users can create custom skills for niche tasks (e.g., data visualization, API integration, technical writing) and share them via GitHub. This turns LLMs into flexible tools for specialized work.

4. Future-Proof Standardization

While skills currently lack a formal specification, their simplicity makes them ripe for industry-wide adoption. The newly launched Agentic AI Foundation (AAIF) has been proposed as a potential steward for standardizing skills—ensuring compatibility across platforms.

Frequently Asked Questions (FAQs) About OpenAI Skills

Can skills handle more than PDFs, documents, and plugins?

Currently, ChatGPT and Codex CLI’s built-in skills focus on these areas, but skills are inherently flexible. Any task that can be broken into step-by-step instructions (e.g., data analysis, image editing, API testing) can be turned into a skill.

Can regular users create their own skills?

Yes! You don’t need advanced coding skills—just a folder with a Markdown file (outlining task instructions) and optional resources. Tools like Claude Opus 4.5 can even help generate skill templates.

Can I modify ChatGPT’s /home/oai/skills folder?

No—regular users cannot edit ChatGPT’s built-in skills folder. You can only prompt ChatGPT to use the pre-installed skills. For custom workflows, use Codex CLI’s skill system.

Is Codex CLI’s skill feature free to use?

Codex CLI itself is open-source and free, but it requires an OpenAI API key to access models like GPT-5.2. Costs depend on OpenAI’s API pricing (no additional fees for skill usage).

How do skills differ from traditional API calls?

APIs require rigid integration with external services, while skills are “instructive playbooks” that guide LLMs through tasks using native tools (e.g., pdftoppm, reportlab). Skills are more flexible and don’t depend on third-party service availability.

Why convert PDFs to PNGs instead of extracting text directly?

Text extraction often loses critical visual information (e.g., table layouts, charts, diagrams). Converting PDFs to PNGs lets vision-enabled models like GPT-5.2 “see” the full document—ensuring no details are missed.

Why does skill execution sometimes take a long time?

Skills prioritize quality over speed. For example, ChatGPT’s PDF skill spends time rendering previews, checking for errors (e.g., font issues), and refining outputs. You can speed up tasks by simplifying skill instructions (e.g., disabling visual previews for text-only PDFs).

Are skills compatible with other LLM tools?

Yes—skills were first popularized by Anthropic’s Claude, and their simple folder/Markdown structure makes them compatible with any LLM tool that can read file systems. Many skills shared on GitHub work with both ChatGPT and Claude.

Final Thoughts

OpenAI’s adoption of skills marks a shift toward more practical, user-controlled AI. By turning complex tasks into modular, shareable playbooks, skills empower users to get more value from LLMs—whether they’re generating professional PDFs in ChatGPT or building custom plugins in Codex CLI.

As skills become more standardized and widely adopted, we can expect to see a thriving ecosystem of user-created skills—turning LLMs from general-purpose chatbots into specialized tools for every industry. Whether you’re a developer, researcher, or power user, now is the time to explore skills and unlock the full potential of OpenAI’s tools.

To get started:

  1. Test ChatGPT’s PDF skill by prompting it to generate a report.
  2. Install Codex CLI and try the Datasette plugin skill.
  3. Create your own skill for a niche task and share it on GitHub.

The future of AI tools is modular—and skills are leading the way.