Codex's record and replay feature turns any workflow into a reusable AI skill

Most people still treat AI like a chatbot they have to talk to every single time. Type a prompt, wait, tweak it, repeat. But there's a feature buried inside Codex that flips that entire model on its head — instead of describing what you want in words, you just do the task once while Codex watches, and it turns your actions into something it can repeat on command.

It's called Record & Replay, and it's easily one of the most underrated things OpenAI has shipped this year. Not because it's flashy, but because it solves a problem almost every knowledge worker has: some tasks are genuinely hard to explain in a prompt, but dead simple to just show someone.

What is Codex's record and replay feature?

Record & Replay is a feature inside the Codex app that turns a single demonstrated macOS workflow into a reusable, editable AI skill. Instead of writing a detailed prompt or configuring an automation script, you perform the task once on your Mac while Codex watches, and it converts that demonstration into a skill it can run again whenever you need it.

The official OpenAI community post describes it simply: Record & Replay lets you show Codex a recurring task, like filing an expense report or submitting a time-off request, and Codex turns that demo into an inspectable, editable skill.

You can read OpenAI's own announcement thread on the OpenAI Developer Community forum, and the official documentation for building and using skills lives at developers.openai.com/codex/skills.

How does the recording process actually work?

Here's the breakdown, based on how OpenAI describes it: you enable the feature inside the Codex app, hit record, and then just do your thing. When you hit record, Codex watches your workflow closely and builds a structured skill from your actions. It's not just capturing screen coordinates like old-school macro recorders — it's paying attention to intent.

That distinction matters a lot. Unlike traditional RPA tools that capture pixel coordinates, Codex generates a natural-language SKILL.md file its reasoning model interprets on replay, which means the skill can adapt even if a button moves, a file name changes, or the layout shifts slightly. A regular macro would just break. As one breakdown of the feature puts it, a Codex skill is a reasoned description of intent, so it can adapt when the file name, the date, or the layout changes.

Once the recording is done, OpenAI says that each skill contains the details on when to use it, the inputs it might need, the steps for completing it, and how to know when it is finished. That's a genuinely useful structure — it's not a black box. You can open the skill file, read exactly what Codex thinks it should do, and edit it if something's off.

Why is showing better than telling for certain tasks?

Think about the last time you tried to write a prompt for something repetitive and messy — like downloading a monthly report, renaming it correctly, uploading it to the right folder, and updating a tracker. Describing every click, every naming convention, and every edge case in words takes forever. And you'll still miss something.

That's exactly the gap this feature closes. There is a reason for this. Most people find it way simpler to demonstrate a repetitive task than to sit down and explain every step. Rather than crafting the perfect prompt, you just do the workflow naturally and let Codex figure out the underlying logic.

OpenAI's own guidance backs this up directly. According to the skills documentation, if you already know the workflow and it's easier to show than describe, use Record & Replay. That's a specific, narrow use case — and it's worth taking seriously rather than trying to record everything.

In fact, the sweet spot is narrower than people assume. Record and replay earns its place when the task is "easier to show than describe" and it is your own repetitive workflow with stable, clear success criteria. If a task is simple enough to type out in a sentence, just prompt Codex directly — recording adds unnecessary overhead.

What kinds of tasks work best with this feature?

OpenAI has pointed to some very concrete examples rather than vague hypotheticals. OpenAI's examples include filing an expense, booking a parking space, creating a correctly configured issue, publishing a video, and downloading a recurring report.

Notice the pattern: these are all tasks that are repetitive, follow a predictable structure, and have a clear "done" state. That's the profile you want to look for in your own work before you hit record. A monthly report you download from the same dashboard, format the same way, and send to the same three people? Perfect candidate. A one-off creative brainstorm? Not so much.

How is this different from a regular macro recorder?

This is where it gets interesting for anyone who's tried old-school automation tools like Keyboard Maestro or basic RPA software and gotten frustrated when things broke. Traditional macro tools replay literal mouse coordinates and keystrokes — if a window moves half an inch or a menu item shifts position, the whole thing falls apart.

Codex skills work differently because they're built on reasoning rather than replaying raw input. The recorded skill documents when to use the workflow, the inputs, the steps, and how to verify the result, so it is inspectable and editable rather than an opaque macro. Unlike traditional RPA that replays coordinates and clicks, Record & Replay keeps the intent of the work as text, so it adapts more easily when the screen changes.

That's a meaningful upgrade for anyone who's been burned by brittle automation before.

Can you schedule these skills to run automatically?

Once a skill exists, you're not limited to manually triggering it every time. You can activate a skill directly by name — the documentation notes that inside the CLI or IDE, you can run /skills or type $ to mention a skill to invoke it explicitly. Codex can also pick up a skill on its own when a request matches what the skill is designed to do, which the docs call implicit invocation.

That combination — reusable skills plus flexible triggering — is what makes scheduling repetitive computer work genuinely practical instead of a novelty. You demonstrate the task once, and from then on it's available on demand, whether you call it directly or let Codex recognize when it's needed.

Should you use record and replay, prompting, or a plugin?

This is the part people skip, and it's the difference between using the feature well and using it as a gimmick. OpenAI actually lays out three distinct paths for giving Codex a capability, and they're not interchangeable. OpenAI is refreshingly clear that this is one of three ways to give Codex a skill, and they overlap less than you would think. If a task is easy to describe in words, just prompt Codex and move on. Recording adds nothing.

The third path is for when you want something more permanent and shareable. And when you want to distribute a stable, documented capability across a team, bundle several skills, or wire in MCP servers, OpenAI points you at building a plugin instead.

So the decision tree looks like this:

1. Quick, one-off, easy to explain? Just write a prompt.
2. Repetitive, personal, easier to show than describe? Use Record & Replay.
3. Needs to be shared across a team or bundled with other tools? Build a plugin.

How do you get started with it?

The feature currently lives inside the Codex desktop app for macOS, and it's rolled out to ChatGPT Plus, Pro, Business, Enterprise, and Edu subscribers outside the European Economic Area (EEA), the United Kingdom, and Switzerland. If you're on a supported plan and region, here's the general flow:

1. Open the Codex app and enable Record & Replay in the plugins or skills panel.
2. Hit record and perform your repetitive task exactly as you normally would — Codex is watching for both your actions and context.
3. Let Codex finish processing the demonstration into a structured skill file.
4. Open the generated skill to review or edit the steps, inputs, and completion criteria.
5. Reuse the skill anytime by invoking it explicitly with /skills or $skill-name, or let Codex trigger it automatically when a matching task comes up.

For the full technical rundown on how skills are structured and invoked, check OpenAI's Codex skills documentation and the general Codex CLI overview.

The real value of Record & Replay isn't that it's a cool party trick — it's that it quietly removes one of the biggest friction points in using AI for actual work: the tax of having to explain yourself in perfect prose every single time. Show it once, let it learn, and get back the ten minutes you would've spent writing a prompt that still wouldn't have gotten it exactly right. The tools that win from here aren't the ones with the flashiest demos — they're the ones that disappear into your workflow. This one's got a real shot at doing that.