Most AI tools make you explain your process every single time. Every new session, the same context dump: here's what I'm doing, here's where the data lives, here's how I want the output formatted.
OpenAI Codex just shipped a different approach: show it once, and it remembers.
What the Feature Does
The workflow is straightforward:
- You perform a task while Codex watches — screen recording or live session
- Codex reviews the recording and extracts what it learned: where your data lives, the sequence of steps, your preferences at each decision point
- It generates a skill — a structured, reusable description of your process
- Next time, you attach the relevant assets and Codex runs the task for you
The example in OpenAI's own demo: a team publishes YouTube videos on a regular cadence. Their process involves pulling metadata from a publishing spreadsheet, finding matching assets (thumbnail, caption file), and manually working through fields in YouTube Studio — title, description, thumbnail, English captions, save as private.
Doing this manually for every video means the same repetitive sequence every time. With Codex's teach-by-showing feature, the team lead records the process once. Codex watches, then generates a skill that captures:
- Where the metadata spreadsheet lives
- How the upload package is organized
- Which fields to fill and in what order
- How captions are added
- How the video is saved and verified
The next upload? Attach the new video package, open a fresh thread, and Codex handles it — matching the package to the right spreadsheet row, filling metadata, adding the thumbnail and English captions, uploading as private, and verifying everything saved correctly.
No prompt. No re-explanation. Just the assets.
Why This Matters
The bottleneck in most AI-assisted workflows isn't capability — it's context transfer. You know exactly how your process works. Getting the AI to the same understanding requires writing it out, which takes time and still doesn't capture the tacit knowledge embedded in how you actually do things.
Recording bypasses that bottleneck. Watching you work is a richer signal than any prompt you'd write. Codex can see:
- Which spreadsheet column maps to which YouTube field (not something you'd think to specify in a prompt)
- That you always check the captions file before uploading (a preference you have but might forget to mention)
- That you verify the "private" setting after saving, not before (a sequence detail that matters for accuracy)
These micro-decisions — the ones that make your process yours — don't survive the translation to written instructions. They do survive a recording.
How Codex Executes the Skill
When you run a learned skill, Codex doesn't just replay a script. It uses the same execution modes available in any Codex session:
Computer use — Direct desktop control. Codex navigates apps, fills forms, clicks buttons, just as it would if you walked it through the task with typed instructions. For YouTube Studio, this means actually operating the interface.
Browser use — Web-specific automation. Navigating to URLs, interacting with web interfaces, handling authentication flows. For pulling metadata from a Google Sheets spreadsheet, this is the relevant path.
Connected plugins — If you've connected tools (Google Drive, YouTube, Notion, Calendar), Codex can call their APIs directly rather than controlling the UI. Faster and more reliable for structured data operations.
Combinations — Most real workflows span multiple tools. Codex can pull from a spreadsheet via plugin, then use browser use to operate YouTube Studio, then verify via API — all in one skill run.
The skill specifies what to do and your preferences. The execution mode is chosen based on what's available and what the step requires.
Use Cases Beyond YouTube Uploads
The feature generalizes to any repeatable, multi-step software task. OpenAI's announcement names three:
How you publish a video — The canonical demo. Metadata from spreadsheet, assets from a package, fields in a publishing interface, save and verify.
How you format and share a pull request — Your specific PR checklist: which reviewers to add, how you structure the description, which labels go on, whether you link to a Linear ticket or a Notion doc. All preferences, all repeatable.
How you like to set up calendar invites — Conference room preferences, recurring meeting structures, which fields you fill in which order, whether you add a Zoom link or use the native integration.
The common pattern: tasks you do more than once, tasks with a consistent structure, tasks that involve switching between multiple tools or interfaces.
Comparison: How This Fits the Skill Ecosystem
Codex's teach-by-showing approach is one answer to a question the whole industry is working on: how do AI agents learn to do your work, not just generic work?
Claude Code Skills (SKILL.md)
Claude Code skills are authored explicitly — you write a SKILL.md that describes the task, the inputs, the steps, and your preferences. The output is a precise, inspectable document that an agent can follow.
Trade-off: More control and transparency, but it requires writing. Non-technical users may find the structure intimidating. Developers who want exact behavior get exactly what they write.
Codex's recording approach inverts this: the skill is authored for you from a demonstration. Less control over the exact wording, but zero authoring friction.
Perplexity Brain
Perplexity Brain (announced June 18) builds a memory graph automatically from your sessions — it learns what sources you trust, what projects you're working on, what context matters. But it's passive: it learns from what you do naturally, not from a deliberate demonstration.
Codex's teaching is active: you perform the task with the intent of teaching. Higher signal, faster knowledge transfer, but requires a dedicated recording session rather than ambient learning.
Traditional RPA (Robotic Process Automation)
Tools like UiPath and Automation Anywhere have offered "record and replay" for years. The difference is the AI layer: traditional RPA captures exact clicks and coordinates, which breaks when the UI changes by a pixel. Codex captures intent — what you're trying to accomplish at each step — and can adapt when the interface varies.
What Makes a Good "Teaching Session"
Based on the design of the feature, a few principles for getting good skills out of a recording:
Do the task the way you actually do it. Don't simplify for the recording. If you always check something twice, check it twice. If you have an intermediate step you always do, do it. The recording captures your real process, not an idealized one.
Use your actual data. Record with a real upload package, a real spreadsheet, a real PR. Codex needs to see the structure of your data to understand where things live.
Go all the way through verification. The demo shows Codex recording not just the upload but also the verification step ("verifies everything was saved correctly"). Don't stop when the main task is done — include the checks you always run.
One skill per coherent workflow. A skill for "publish YouTube video" is coherent. A skill for "publish YouTube video, then tweet about it, then update the content calendar" might be better as three separate skills that can be chained — or one, if you always do them together.
The Broader Pattern: AI That Learns From You
What Codex is building with teach-by-showing is a specific model of the human-AI relationship: you are the expert, the AI is the learner and executor.
Most current AI interactions are the inverse — the AI is the expert, the human is the prompter. That works well for generic knowledge tasks (drafting, summarizing, coding from scratch). It works less well for your specific operational processes, which are idiosyncratic and institution-specific.
The teach-by-showing model flips the information flow. Your tacit process knowledge — accumulated over months of doing the work — becomes the training signal for an agent that can then replicate that process at scale.
OpenAI frames it explicitly: "You don't have to explain every step or preference in a prompt. Just show Codex how you do it, and next time it can do it for you."
The limiting factor becomes the quality of what you demonstrate. A sloppy recording produces a sloppy skill. A careful, representative recording of your actual best-practice process produces a skill that runs your process — not a generic approximation of it.
Current Availability
Codex's teach-by-showing feature is rolling out as part of the broader Codex product. Check your Codex interface for the skill recording option — it may be under a "teach" or "show" mode depending on the current UI.
Skills created via recording can be combined with Codex's existing plugin integrations (YouTube, Google Workspace, GitHub, Notion, and others in the Codex plugin ecosystem) for the execution step.