OpenAI Skills Now Live: Complete Guide to ChatGPT and Codex CLI Integration

Introduction

In a significant move that's reshaping the AI landscape, OpenAI has quietly rolled out Skills support across both its ChatGPT platform and the open-source Codex CLI tool. This development marks a pivotal moment in the evolution of AI capabilities, creating what many are calling a "Cambrian explosion" in how AI agents can be extended and customized.

Unlike previous attempts at AI extensibility through complex protocols and plugins, Skills represent a refreshingly simple yet powerful approach: just folders containing Markdown files and optional resources. This simplicity belies their transformative potential, as Skills are now becoming universally compatible across different AI platforms and tools.

This comprehensive guide explores how OpenAI's Skills implementation works, what it means for developers and users, and why this approach is fundamentally changing how we think about AI customization.

Understanding the Skills Revolution

What Are Skills?

Skills are a lightweight mechanism for extending AI capabilities through procedural knowledge encapsulation. At their core, Skills are:

• Filesystem-based: Simple folders with organized content
• Progressively disclosed: Load only when needed, saving tokens
• Universal: Work across different AI platforms and tools
• Extensible: Support custom scripts, templates, and resources

This elegant simplicity stands in stark contrast to more complex extensibility frameworks that require significant infrastructure and protocol overhead.

The Universal Skills Ecosystem

What makes OpenAI's implementation particularly exciting is how Skills are becoming a universal standard. A skill created for one platform can often be used in another with minimal or no modification. This portability creates a thriving ecosystem where:

1. Developers create Skills once and deploy them everywhere
2. Users benefit from consistent experiences across platforms
3. Knowledge transfers seamlessly between different AI tools
4. Innovation accelerates as the community builds shared resources

Skills in ChatGPT

Discovery and Implementation

ChatGPT's Skills implementation resides within the Code Interpreter environment at /home/oai/skills. This integration makes ChatGPT a capable coding assistant that can leverage specialized procedures and workflows.

To access these Skills, users can simply prompt ChatGPT to explore the Skills directory:

Please explore the /home/oai/skills directory and show me what capabilities are available

This reveals a growing collection of Skills covering various domains, from document processing to data analysis.

Current Skill Categories

Based on community exploration, ChatGPT's built-in Skills currently include:

1. Document Processing Skills

   • Spreadsheet manipulation and analysis
   • DOCX document handling and generation
   • PDF processing with vision-enabled capabilities

2. Data Analysis Skills

   • Data transformation and cleaning
   • Statistical analysis workflows
   • Visualization generation

3. File Management Skills

   • Batch processing operations
   • Format conversion utilities
   • Archive management

Vision-Enhanced PDF Processing

One particularly innovative aspect of ChatGPT's PDF Skills is the use of vision models. Instead of simple text extraction, PDFs are converted to per-page PNG images, preserving:

• Layout information
• Graphics and charts
• Complex formatting
• Visual relationships between elements

This approach ensures that no valuable information is lost during processing, making it particularly effective for complex documents like financial reports or academic papers.

Skills in Codex CLI

Installation and Setup

The Codex CLI tool has embraced Skills through a recent pull request titled "feat: experimental support for skills.md". The implementation is straightforward:

1. Create the Skills Directory

   bashCopy

   mkdir -p ~/.codex/skills
   

2. Enable Skills in Codex

   bashCopy

   codex --enable skills -m gpt-5.2
   

3. Add Skills Simply copy skill folders to ~/.codex/skills

The Skills Prompt Architecture

Codex CLI uses an innovative prompt-based approach to Skills integration. The system injects a structured prompt that:

• Lists available Skills with names, descriptions, and file paths
• Defines trigger rules for automatic Skill activation
• Specifies usage patterns with progressive disclosure
• Establishes coordination protocols for multiple Skills

Here's how the prompt structure works:

## Skills
These skills are discovered at startup from ~/.codex/skills; each entry shows name, description, and file path so you can open the source for full instructions. Content is not inlined to keep context lean.

- Name of skill 1: Description of skill 1 (file: ~/.codex/skills/skill-1/skill.md)
- Name of skill 2: Description of skill 2 (file: ~/.codex/skills/skill-2/skill.md)
- Name of skill 3: Description of skill 3 (file: ~/.codex/skills/skill-3/skill.md)
- Discovery: Available skills are listed in project docs and may also appear in a runtime "## Skills" section (name + description + file path). These are the sources of truth; skill bodies live on disk at the listed paths.
- Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
- How to use a skill (progressive disclosure):
  1) After deciding to use a skill, open its `SKILL.md`. Read only enough to follow the workflow.
  2) If `SKILL.md` points to extra folders such as `references/`, load only the specific files needed for the request; don't bulk-load everything.
  3) If `scripts/` exist, prefer running or patching them instead of retyping large code blocks.
  4) If `assets/` or templates exist, reuse them instead of recreating from scratch.
- Description as trigger: The YAML `description` in `SKILL.md` is the primary trigger signal; rely on it to decide applicability. If unsure, ask a brief clarification before proceeding.
- Coordination and sequencing:
  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
- Context hygiene:
  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
  - Avoid deeply nested references; prefer one-hop files explicitly linked from `SKILL.md`.
  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.

Skill Activation and Usage

Codex CLI implements intelligent Skill activation based on:

1. Explicit Naming: When users mention a Skill by name
2. Task Matching: When requests clearly match a Skill's description
3. Context Relevance: When Skills are relevant to the current task
4. Multiple Application: Using multiple Skills when appropriate

The system follows a progressive disclosure pattern:

1. Load only the Skill metadata initially
2. Read the SKILL.md file when activated
3. Load additional resources on-demand
4. Execute scripts only when specifically needed

The Coding Environment Dependency

Why Skills Need Execution Environments

Unlike other extensibility mechanisms that work through APIs or web interfaces, Skills fundamentally depend on having access to a coding environment. This includes:

• Filesystem Access: To read and write files
• Command Execution: To run scripts and tools
• Network Capabilities: To fetch resources and data
• Process Management: To coordinate complex workflows

This dependency is actually a strength, as it enables Skills to perform real work rather than just describing how to do work.

Security Considerations

The need for execution environments raises important security questions. OpenAI's approach includes:

1. Sandboxed Environments: Isolated execution spaces
2. Limited Permissions: Restricted access to system resources
3. Audit Trails: Monitoring of Skill activities
4. User Control: Explicit Skill activation and monitoring

Platform Support

The coding environment requirement is supported by:

• ChatGPT Code Interpreter: Cloud-based execution environment
• Codex CLI: Local machine with full capabilities
• Claude Code: Local development environment

Building Your Own Skills

Skill Structure

A typical Skill follows this organization:

skill-folder/
├── SKILL.md              # Main instruction file with YAML metadata
├── scripts/              # Executable scripts and utilities
│   ├── process_data.py
│   └── generate_report.sh
├── templates/            # Reusable templates and forms
│   └── report_template.md
├── examples/             # Usage examples and samples
│   └── sample_input.json
└── resources/            # Supporting documentation
    └── reference_docs/

Creating Effective Skills

1. Clear Descriptions: Write concise, action-oriented descriptions
2. Modular Design: Break complex tasks into smaller, reusable components
3. Error Handling: Include procedures for common failure modes
4. Documentation: Provide clear instructions and examples
5. Resource Optimization: Use progressive disclosure to minimize token usage

Cross-Platform Compatibility

To maximize Skills portability:

1. Standard Formats: Use common file formats and structures
2. Platform-Agnostic Scripts: Write scripts that work across different environments
3. Clear Dependencies: Document all requirements and dependencies
4. Fallback Mechanisms: Provide alternative approaches for different platforms

Skills vs. Other Extensibility Models

Comparison with MCP

While the Model Context Protocol (MCP) focuses on connecting AI to external systems, Skills focus on teaching AI how to perform tasks:

Skills Advantages:

• Token efficiency through progressive loading
• Simplicity of implementation
• Direct procedural knowledge transfer
• Lower infrastructure requirements

MCP Advantages:

• Standardized protocol for system integration
• Enterprise-grade connectivity
• Cross-vendor compatibility
• Robust tool discovery mechanisms

Skills vs. Plugins

Unlike traditional plugins that require complex registration and lifecycle management:

• Skills are passive: Simply exist in the filesystem
• No registration required: Automatically discovered
• Stateless: No persistent state between sessions
• Portable: Work across different platforms

Skills vs. Custom Prompts

While custom prompts have long been used to guide AI behavior:

• Skills are structured: Organized with metadata and resources
• Progressively disclosed: Load only when needed
• Executable: Can include scripts and automation
• Composable: Can be combined and coordinated

Real-World Applications

Data Journalism Workflow

Imagine a Skills collection for data journalism:

1. Data Acquisition Skills

   • Census data retrieval and parsing
   • API data collection and normalization
   • Public records processing

2. Analysis Skills

   • Statistical analysis procedures
   • Data visualization techniques
   • Story identification algorithms

3. Publication Skills

   • Report generation templates
   • Web publishing workflows
   • Social media distribution

This creates a complete "data journalism agent" capable of discovering and publishing stories from raw data.

Software Development Automation

Development teams can create Skills for:

1. Code Quality

   • Review procedures and checklists
   • Testing requirements and standards
   • Documentation generation workflows

2. Deployment Automation

   • CI/CD pipeline management
   • Rollback procedures
   • Monitoring and alerting setup

3. Team Coordination

   • Code review assignments
   • Issue triaging procedures
   • Release planning workflows

You can leverage existing workflow skills like:

• Requesting Code Review - Automatically dispatches code reviewer subagents to validate implementation
• Verification Before Completion - Ensures work is verified before claiming success
• Finishing a Development Branch - Guides integration decisions for completed features

Business Process Automation

Business operations can benefit from:

1. Financial Processing
   • Invoice processing and validation
   • Expense report analysis
   • Budget tracking and reporting

For financial document management, the Invoice Organizer skill automatically extracts information, renames files consistently, and organizes documents for tax preparation.

2. Customer Service
   • Support ticket routing
   • Response template generation
   • Escalation procedures

The Internal Communications skill provides templates and guidelines for various business communications, including status reports, FAQs, and incident responses.

3. Marketing Operations
   • Campaign setup procedures
   • Content generation workflows
   • Performance analysis templates

For marketing insights, the Competitive Ads Extractor can analyze competitors' advertising strategies across multiple platforms to identify what messaging and creative approaches are working.

Document Processing Workflows

The universal Skills ecosystem shines in document processing:

1. Office Document Management

   • PDF Processor - Comprehensive PDF manipulation including extraction, creation, and OCR
   • DOCX Processor - Word document creation, editing, and tracked changes
   • XLSX Processor - Excel spreadsheet handling with formulas and data analysis
   • PPTX Processor - PowerPoint presentation creation and editing

2. Content Creation

   • Content Research Writer - Collaborative writing with research assistance
   • Brand Guidelines - Consistent brand identity across materials
   • Theme Factory - Professional styling with 10 pre-set themes

These Skills demonstrate how the universal ecosystem allows knowledge and workflows to be shared across ChatGPT and Codex CLI, creating a rich tapestry of automated capabilities that benefit users everywhere.

The Future of the Skills Ecosystem

Community Growth

The simplicity and portability of Skills are driving rapid community adoption:

1. Skill Marketplaces: Emerging platforms for sharing and discovering Skills
2. Domain Specialization: Industry-specific Skills collections
3. Template Libraries: Reusable Skill templates for common tasks
4. Best Practices: Community-driven standards and guidelines

Platform Evolution

We're seeing Skills support expand across platforms:

1. Universal Adoption: More AI tools adding Skills support
2. Enhanced Capabilities: Richer Skill features and integrations
3. Performance Optimization: More efficient Skill loading and execution
4. Security Enhancements: Better sandboxing and access controls

Enterprise Integration

Organizations are leveraging Skills for:

1. Internal Workflows: Custom business process automation
2. Knowledge Management: Preserving and distributing expertise
3. Training and Onboarding: Interactive learning experiences
4. Compliance and Auditing: Standardized procedure documentation

Getting Started with Skills

For ChatGPT Users

1. Explore Built-in Skills: Start with the /home/oai/skills directory
2. Learn the Patterns: Understand how existing Skills are structured
3. Experiment: Try using Skills for your specific tasks
4. Provide Feedback: Help improve the Skills ecosystem

For Codex CLI Users

1. Install and Setup: Enable Skills in your Codex CLI configuration
2. Import Existing Skills: Copy Skills from community repositories
3. Create Custom Skills: Build Skills for your specific workflows
4. Share and Collaborate: Contribute back to the community

For Developers

1. Study Best Practices: Learn from existing successful Skills
2. Build Reusable Skills: Focus on common, high-value tasks
3. Document Thoroughly: Ensure Skills are easy to understand and use
4. Test Across Platforms: Verify Skills work in different environments

Conclusion

OpenAI's implementation of Skills across ChatGPT and Codex CLI represents more than just a new feature—it's a fundamental shift in how we think about AI customization and extensibility. The simplicity of the Skills approach, combined with its power and portability, is creating a new ecosystem of AI capabilities that benefits everyone.

The universal nature of Skills means that knowledge and automation can now be easily shared across different platforms and tools. This not only accelerates innovation but also democratizes AI development, allowing more people to contribute to and benefit from AI advancements.

As we move forward, we can expect to see:

1. Explosive growth in the Skills ecosystem
2. Increased specialization for different industries and use cases
3. Enhanced capabilities as platforms evolve
4. Greater standardization as best practices emerge

The Skills revolution is just beginning, and now is the perfect time to get involved. Whether you're a user looking to enhance your AI workflows or a developer wanting to contribute to the ecosystem, Skills provide an accessible and powerful path forward.

Key Takeaways:

• Skills are now live in both ChatGPT and Codex CLI
• The universal Skills ecosystem enables cross-platform compatibility
• Skills represent a simple yet powerful approach to AI customization
• The community is rapidly building and sharing Skills
• Now is the ideal time to explore and contribute to the Skills ecosystem

Ready to dive deeper into the world of AI Skills? Explore our Agent Skills documentation for comprehensive tutorials, best practices, and examples.