Use Any Coding Agent to Record Your App Demo

Vorec Team · 2026-06-09 · 11 min read

Your AI coding agent just built a feature. It wrote the code, ran the tests, maybe even opened the app to check it. And then you — the human — open a screen recorder, click through the thing you just watched the agent build, and try to narrate a demo. There's a gap here that's starting to feel absurd: the agent that did the work hands off the documentation of that work to a person.

What if the agent recorded the demo too? Not a synthetic, generated-from-a-prompt video — a real screen recording of your actual running app, with the actions detected and narrated automatically. That's the idea behind agent-mode recording, and it works with whatever coding agent you already use: Claude Code, Codex, or others.

This is the pillar guide to the whole approach — what it is, why it's different from the AI-video tools you've seen, and how to set it up regardless of which agent you run.

The agent that builds your app is the one that knows exactly what it built — which screens, which flows, which "aha" moment. Handing the demo recording back to a human throws that context away. Agent-mode recording keeps it.

What "agent-mode recording" actually means

Agent-mode recording is simple to state: your coding agent drives a real screen recording of your running app, and AI turns that recording into a narrated demo or tutorial.

Concretely, the agent:

1. Describes the walkthrough — which app, which actions, in what order (a small manifest, e.g. a `vorec.json`).
2. Drives a real recording of your actual app through the Vorec Recorder (the macOS capture engine).
3. Hands it to Vorec's AI, which detects every action and generates a synced narration.
4. Returns a finished, narrated demo — plus, optionally, a written step-by-step article.

The key word is real. This isn't a video assembled from stock components or a generated avatar describing your product from a text prompt. It's a genuine recording of your software actually working, narrated to match what's on screen.

Why this is different from other "AI video" tools

There's a wave of AI-video tooling right now, and it's easy to lump this in with it. But the approaches are fundamentally different:

The distinction matters because a demo of your real app — real data, real flows, real edge cases — is what users and prospects actually want to see. A generated approximation looks like marketing; a real narrated walkthrough looks like proof.

If a prospect can tell your "demo" was generated rather than recorded, it loses its persuasive power. The whole point of a product demo is "here's the thing actually working." Agent-mode recording keeps that authenticity while still removing the manual labor.

Why let the agent do it at all?

You could record the demo yourself. So why hand it to the agent?

• The agent has the context. It just built the feature; it knows the exact flow that demonstrates it. You'd be reconstructing what it already knows.
• It closes the loop. Build → demo → document becomes one continuous agent task instead of a build step plus a manual chore you'll probably skip.
• It scales with your shipping. Every feature the agent builds can come with a demo, automatically, instead of a backlog of "demos I should make."
• It's consistent. The agent produces the same clean walkthrough every time, regardless of whether you felt like making a video that day.

For solo developers especially, this is the difference between "I'll demo it later" (you won't) and a narrated demo arriving as part of the build.

How it works under the hood

The architecture is deliberately agent-agnostic, because the recording engine and the narration are separate from whichever agent drives them:

• The recording engine is the Vorec Recorder for macOS (ScreenCaptureKit, retina 2× capture). This is what actually captures your running app.
• The narration is Vorec's AI: it watches the recording, detects clicks and actions, writes the script, and generates the voiceover.
• The agent is just the driver. It writes the manifest and triggers the recording, then hands the result to Vorec.

Because the agent is only the driver, any agent that can run a command or call an API can do agent-mode recording. That's why this works across Claude Code, Codex, and others.

The two paths: plugin vs CLI

There are two ways an agent drives the flow, and which one you use depends on your agent:

Path 1 — Claude Code (plugin). Claude Code has a dedicated `record-tutorial` plugin. You ask Claude Code to record a demo, it writes the manifest and drives the recording through the plugin, and you get a narrated demo back. It's the most turnkey path. (See our dedicated Claude Code guide.)

Path 2 — Codex and other agents (CLI). Codex, and any other coding agent, drive the same flow through the `@vorec/cli` command-line tool plus the Vorec Agent API. The agent writes a `vorec.json` manifest, runs the CLI to record through the Vorec Recorder, you review the raw recording, then the CLI uploads and triggers narration. Same engine, same result — just driven from the command line instead of a plugin. (See our dedicated Codex guide.)

The mental model: Claude Code = plugin, everything else = CLI, identical recording engine underneath.

One recording engine, two driving paths, any coding agent. The narration and capture are the same whether Claude Code or Codex pulls the trigger — so the quality of the demo doesn't depend on which agent you happen to use.

What you can have your agent record

Agent-mode recording isn't only for launch demos. Anything your agent builds, it can document:

• Feature demos — show the thing it just shipped, narrated.
• Onboarding walkthroughs — the getting-started flow, kept current as the app changes.
• Bug repros — have the agent reproduce and record the issue with narration.
• Changelog clips — a short narrated demo attached to every release.
• Marketing demos — your core "aha" flow for the landing page or Product Hunt.

Each is the same loop: the agent drives a real recording, Vorec narrates it. And because Vorec can also produce a written guide from the recording, your agent can effectively generate both a demo video and a doc in one pass.

Prerequisites

To do agent-mode recording you'll need:

• A Mac — the Vorec Recorder is a macOS app (ScreenCaptureKit capture).
• The Vorec Recorder installed and signed in.
• Your agent of choice — Claude Code (with the `record-tutorial` plugin) or Codex/another agent (with `@vorec/cli`).
• A Vorec account — the free trial includes 200 credits to try the full loop before paying. Pricing after: Starter $9/mo, Pro $24/mo, Business $59/mo.

Getting started

1. Install the Vorec Recorder for macOS and sign in.
2. Pick your path — Claude Code plugin, or `@vorec/cli` for Codex and others.
3. Ask your agent to record a demo of a feature — it writes the manifest and drives the recording.
4. Review and let AI narrate — you get a real, narrated demo of your actual app.

From there, dive into the agent-specific guides: the Claude Code walkthrough, the Codex walkthrough, and the "vibe-coded app to narrated demo" guide for builders shipping fast with AI.

The bottom line

The agent that builds your app already knows exactly what it built — so it's the natural thing to record the demo too. Agent-mode recording keeps that context, produces a real narrated walkthrough of your actual running app (not a generated approximation), and works with whatever coding agent you use: Claude Code via the plugin, Codex and others via the CLI, the same recording engine underneath.

Stop handing the demo back to a human. Let the agent that built it record it.

Have your coding agent record a real, narrated demo of the app it just built — Claude Code or Codex. Start free with 200 credits

← Back to blog