Codex Skills: Sam Altman's Framework for Unlocking AI Agent Capabilities (2026)

Sam Altman posted something on June 6, 2026 that hit 194K views and 3,200+ likes:

"Whenever I don't use Codex for a task, I ask myself why and usually realize that there's some missing context, I needed to write a skill, or I just didn't think to use it. Rarely is it because the task is outside of the capabilities of the model. Overhang right now feels large."

The word "skill" is the key. Altman isn't talking about the AI getting smarter. He's talking about a specific workflow: when Codex fails, the fix is usually writing a skill - a structured knowledge package that gives the agent the context it needs to succeed.

This is the Codex Skills framework. Here's what it is and how to use it.

What Are Codex Skills?

A Codex Skill is a structured markdown file that tells an AI coding agent how to work with a specific tool, API, codebase, or workflow. It's the knowledge layer that sits between the model's general training and the specific context of your project.

Altman's point is that most of Codex's apparent limitations aren't model limitations - they're context limitations. The model knows how to code. It doesn't know your specific deployment process, your team's conventions, which API endpoints are deprecated, or how to authenticate with your internal services.

A skill encodes all of that.

The Agent Skills Standard

Codex Skills are part of the broader Agent Skills open standard. Originally developed by Anthropic and released as an open standard under Apache 2.0 in early 2026, it has been adopted across all major AI coding agents: Claude Code, Cursor, GitHub Copilot, Gemini CLI, OpenAI Codex, Windsurf, Aider, and 30+ others.

The standard is gaining rapid adoption. The awesome-agent-skills community library has cataloged over 1,200 skills compatible with 16+ different agents. GitHub trending regularly shows multiple Skills repositories:

• mvanhorn/last30days-skill - 34,700+ stars, real-time research across Reddit, X, YouTube, and HackerNews
• google/skills - 12,200+ stars, official Google Cloud infrastructure skills
• VoltAgent/awesome-agent-skills - 24,600+ stars, curated directory with official skills from Anthropic, Google, Vercel, Stripe, Cloudflare, and more

This isn't a coincidence. Skills have become the primary mechanism for extending what AI agents can do without waiting for a better model.

The Three Reasons Codex Fails (Altman's Framework)

Altman's tweet identified three reasons an agent task fails:

1. Missing context

The agent doesn't know something it needs to know. Your API structure, your environment variables, your deployment target. This is fixed by documentation in the project or a context skill.

2. No skill for this

The task requires knowledge that isn't encoded anywhere the agent can access. How does your CI/CD pipeline work? What's the internal process for getting code reviewed? What are the gotchas with your database migration tool? This is fixed by writing a skill.

3. Didn't think to use it

You defaulted to manual work out of habit. This is the "overhang" Altman mentions - the gap between what Codex can actually do and what people are actually using it for. OpenAI estimates that even if models were frozen at current capability, the untapped economic value is enormous.

Of these three, #2 is the most actionable. Writing skills is the primary lever for expanding what your AI agent can reliably accomplish.

How Agent Skills Work: Progressive Disclosure

The Agent Skills standard uses a three-stage loading model that keeps context lean:

1. Discovery: At startup, agents load only the name and description of each available skill - just enough to know when it might be relevant.
2. Activation: When a task matches a skill's description, the agent reads the full SKILL.md instructions into context.
3. Execution: The agent follows the instructions, optionally executing bundled scripts or loading referenced files as needed.

This means you can have dozens of skills installed without bloating every session's context window. The agent only loads what it needs.

How to Write a Codex Skill

A Skill is a folder containing at minimum a SKILL.md file. The YAML frontmatter tells the agent when to use it; the markdown body tells it what to do:

---
name: deploy-to-production
description: "How to deploy this project to production. Use when the user asks to deploy, push to prod, or release a new version."
---

# Deploy to Production

## Prerequisites
- AWS credentials configured via `aws configure`
- Docker running locally
- Environment: `export ENV=production`

## Steps
1. Run tests: `npm test`
2. Build Docker image: `docker build -t app:latest .`
3. Push to ECR: `docker push [ECR_URL]/app:latest`
4. Deploy: `aws ecs update-service --service app-prod`

## Common errors
- "No space left": clear Docker cache with `docker system prune`
- "Credentials expired": run `aws sso login --profile prod`

The description field is critical. It's how the agent decides whether to load this skill. Include trigger phrases - the exact words someone would use when they need this workflow.

Once installed, your agent can deploy your application without you spelling out the steps every session.

Installing and Managing Skills

Skills work across every major agent host:

# Claude Code (marketplace - auto-updates)
/plugin marketplace add [skill-name]

# Codex, Cursor, Copilot, Gemini CLI, and 30+ others
npx skills add [skill-name]

# Install globally (available across all projects)
npx skills add [skill-name] -g

# Update
npx skills update [skill-name]

For project-specific skills you write yourself, place the folder in .claude/skills/ (Claude Code), .cursor/skills/ (Cursor), or .agents/skills/ (cross-platform standard).

The Skill Categories That Matter Most

Based on what's working in production teams right now, the highest-value skills to write or install:

Why "Overhang Feels Large"

Altman's observation that "overhang feels large" aligns with what he told interviewers more broadly: even if model capabilities were frozen at GPT-5.2 and Codex today - no more improvements, no GPT-6 - there is still enormous untapped economic value. The models can already do far more than people are using them for.

The model is not the bottleneck. The knowledge encoding is.

This creates a temporary arbitrage: if you figure out how to actually use these models before your competitors and colleagues do, you have an edge. But if you're waiting for AI to "get smart enough" before you change your workflow, you might be waiting for something that's already here.

What This Means for Your Workflow

Altman's framework suggests a simple diagnostic: the next time your AI agent fails at something, ask why. Was it a model limitation - the task was genuinely beyond its capabilities? Or was it a context limitation - it didn't know something it needed to know?

For most teams, the honest answer is mostly context. The fix is a skill.

Start here: Think about the last 5 times you had to explain something to your agent that you've explained before. Each of those is a skill waiting to be written. Write those five skills, install them, and see how much of your "the AI can't do this" friction disappears.

That's the overhang Altman is talking about. It's yours to capture.