The aidemo blog
Practical, evidence-backed writing on product demo videos — scripting, recording, automating, and keeping them fresh — from the team behind aidemo, the open-source demo engine for coding agents.
Accessible tutorial videos: captions, transcripts, audio description
Captions clear one of seven WCAG media checks. The descriptive transcript that serves a Deaf-blind reader is the same text your search box needs.
Agent-friendly app instrumentation: data-testid and beyond
Whether an agent can script your UI is decided in your codebase. The instrumentation playbook that pays off for tests, agents, and demo capture at once.
AI demo video generators: what the label actually covers
Four unrelated tools rank for 'AI demo video generator,' and two never output a video of your product. A mechanism map so you buy the right object.
AI documentation tools mapped: Guidde, Scribe, Clueso, Supademo
Five AI documentation tools get sold as one category. They split into text step guides, narrated video, and click-throughs, and each rots differently.
AI voiceover for demo videos: quality, cost, and workflow
AI voiceover per minute is settled and cheap. The real questions: which TTS gives you consistency and one-line re-renders, and where a human voice still wins.
API and SDK documentation videos that stay in sync with the API
A stale UI demo looks wrong on sight. A stale API quickstart shows valid JSON while the field it names no longer exists. How to keep one honest.
App preview videos: hitting App Store and Play specs without a reshoot
Apple wants an uploaded H.264 file at 886 x 1920; Google Play wants a YouTube link. The exact cross-store specs, and how to hit them without a reshoot.
Keeping App Store screenshots current with automation
Localize into 50 languages and App Store screenshots become hundreds of PNGs. The fastlane pipeline that regenerates them, and when a browser wins.
Arcade vs Navattic vs Storylane: picking an interactive demo platform
They rank on the same grids, but Navattic clones your DOM, Arcade stitches screenshots, and Storylane does both. Pick by capture engine, not feature count.
Automated product demo videos: regenerate, don't re-record
Four unrelated machines ship under one label. Only one makes 'the product changed' and 'the demo is current' the same event.
Automating product screenshots for docs and marketing
The complete stills playbook: one YAML for every screenshot, a pull request that recaptures them on a schedule, and a visual regression test you get for free.
Autoplay video on a website: the recipe that works everywhere
Most autoplay bugs are a missing word from one line of markup. Here is the four-attribute set that plays in every browser, and the code for when it still won't.
B2B vs PLG demo videos: seven axes that change the cut
The same product needs two demos: one for a self-serve user, one for a buying committee. Seven axes that decide where each cut lands.
Best frame rate for screen recording: 30 vs 60 fps by content
Doubling the frame rate does not double the file, and on a static form it costs almost nothing. A content-type table for when 60 fps is actually worth it.
Best resolution for screen recording: match delivery, not your monitor
Your monitor is not the resolution to record at. A source-to-delivery table, the bitrate math, and why a 4K capture can make 1080p text worse.
Best format for screen recording: container vs codec, decided
The .mp4 in the filename is the box, not the codec inside it, and the codec is what sets the size. Container and codec, separated and decided.
Camtasia alternatives for software demos and tutorials
TechSmith retired Camtasia's perpetual license, and the timeline was always the real bill. The alternatives, sorted by who does the editing.
Cap vs Screen Studio: open-source polish vs the macOS standard
Both automate the same polish. One is open source and runs anywhere; one is the macOS benchmark. Where Cap wins, where it breaks, and when to pick neither.
Letting a coding agent make your demo video
A coding agent can explore your app and write the demo storyboard. Driving the browser live is the one thing it must not do, and here is exactly why.
Demo environments and seed data that make a demo reproducible
You pinned the browser and the encoder. Then the same click lands on a different dashboard, because the database reseeded. The state has to be pinned too.
Background music for demo videos: licensing and the loudness math
Royalty-free is a billing term, not a free pass: the licenses that clear a paid demo, the clauses that bite, and the 20 dB gap that keeps the voice on top.
Demo video CTAs: one ask, placed where viewers still are
An end card offering five things converts nobody. The one-ask rule, a developer CTA taxonomy, and the retention math for where the closing ask goes.
Captions on demo videos: the accessibility case and the numbers
Most demo views start muted, so the caption is the demo, not the soundtrack: the timing, the formats, and the WCAG rule that decide whether the words land.
How much does a demo video cost? Four tiers and the hidden recurring bill
Four production tiers, priced per finished minute, plus the line item every quote leaves off: what it costs to make the same demo again when the UI moves.
How to start a demo video: the first five seconds
Viewers decide to leave in the first few seconds. Six opening moves that earn the next fifty, the one intro to retire, and which hook fits muted autoplay.
Demo video metrics: play rate, retention, and assisted conversions
Your dashboard hands you "views" for free, and it is the least useful number you own. Read play rate, the retention curve, and assisted conversions instead.
Ten demo video mistakes, ranked by how many viewers they cost
Not all demo blunders are equal. The ones that bite in the first five seconds empty the whole room; the ones at the end cost only the stragglers. Ranked.
Putting a demo video on your landing page without wrecking load time
A hero video is the heaviest thing on the page and the thing Google times it by. Here is how to ship one so the page still paints in under 2.5 seconds.
Demo video script template: problem, walkthrough, proof
Narration runs about 2.5 words a second, so a demo's runtime is a word budget. Grab a copy-paste script skeleton and two worked scripts, counted line by line.
Demo video software pricing landscape, per finished minute
Sticker prices lie because the units differ: per seat, per minute, per demo, per view. Normalized to cost per finished demo-minute, the ranking flips.
The demo video thumbnail: poster frame vs marketing cover
The poster that fills the box, the cover that earns the click, and the share card a crawler reads are three different pictures. Which frame to pick for each.
Rendering demo videos in CI: a GitHub Actions walkthrough
GitHub's runner ships Chrome but not ffmpeg. Here is what a video-rendering job actually needs, how to trigger it, and where the file should land.
Demos as code: commit the storyboard, render the video
A recording is a performance you own and maintain. A spec is text you can diff, review, regenerate, and hand to an agent. That decides everything downstream.
Descript alternatives for editing demo videos
Descript edits video by editing the transcript. That trick shines on a podcast and fights a screen demo. The alternatives, sorted by what you grab.
Detecting UI drift before your demo lies about the product
A raw pixel diff fires on every font tweak; a bare selector check misses a button that moved. Here is the ladder in between, rung by rung.
Deterministic browser automation for video capture
A test that flakes just reruns. A demo that flakes ships the stutter. The eight-variable checklist for making one browser flow render the same pixels twice.
Developer-education screencasts: terminal, code, and browser together
Editors, terminals, and browsers each break a generic recorder differently. A format guide for dev screencasts that stay legible after the codec.
Docs that test themselves: executable documentation
Python's docs literally call it 'executable documentation': an example that fails when the code drifts. The same trick works one layer up, on your screenshots.
Does video actually increase conversion? Tracing the 80% claim
The famous 80% conversion lift traces to one 2011 A/B test. Here is what a 35,000-page analysis and your LCP budget actually say about video.
How to embed video on a website: self-host vs YouTube vs streaming host
Paste the YouTube iframe and you ship 540 KB of someone else's JavaScript. Self-host and you own the egress bill. Here is how to choose, with the arithmetic.
Embedding video in docs sites without wrecking load time
You can't lazy-load a <video> the way you lazy-load an image. Here is how to put clips in Docusaurus and MkDocs without a page that stalls or breaks offline.
Feature announcement and changelog videos: a 30-second template
A launch is an event; a feature announcement is a habit. The three-beat, 30-second template and the cadence that keeps the program alive past sprint three.
Free demo video software: what the free tier actually gives you
Some free demo tools are free forever, some stop you at 5 minutes, and some brand every export. A field guide to which paywall is waiting for you.
GIFs in documentation: when a loop beats a screenshot
An auto-looping GIF fails a Level A accessibility rule and offers no pause button. When a loop truly beats a still, and how to ship it without the tax.
Headless screen recording: capturing a screen with no display
Recording a screen with no monitor forks two ways: grab a virtual X display with ffmpeg, or pull frames from a browser that never paints. When each wins.
Hide notifications while screen recording, on every OS
A toast doesn't live in your window; the OS paints it on top. Do Not Disturb on every OS, why it still leaks, and where a notification can't fire.
How long should a demo video be? The retention math
Most demos run longer than they should, and that is an editing problem. Here is the target length for every placement, plus what to cut first.
How to make a product demo video (that people finish)
The playbook for a demo people actually finish: script first, record second, with the word, scene, and length budgets that decide every second.
How to record your screen in high quality: the settings that matter
Blurry text, a laggy cursor, the wrong frame rate: high quality is a handful of capture settings, each with one number and a one-line fix.
Interactive product demos vs video demos: when each wins
One is a program you drive, the other a file that plays anywhere. Where clickable tours beat video, where video wins, and the two costs listicles skip.
Keeping a tutorial video library current at scale
Two hundred tutorials meet one redesign, and the re-record backlog no docs team gets funded to clear. Here is the maintenance math, and the one way out.
LinkedIn video for B2B software: native, captioned, and square
Paste a YouTube link and the LinkedIn feed buries the post. Upload native, size it square, burn the captions: the B2B feed mechanics, with the specs.
Loom alternatives for product demos after the Atlassian era
Loom is async video messaging that Atlassian now owns, not a product-demo tool. Sort the alternatives by which of Loom's jobs you are actually replacing.
MCP servers for media generation: the agent-to-render interface
A media render runs for minutes; an MCP tool call times out in sixty seconds. How to design the agent-to-render interface so the video survives the gap.
Measuring whether documentation videos actually work
A play count cannot tell you whether a documentation video did its job. Measure the four gates it must clear, and retire the clips that fail them.
Microvideos in documentation: the 10-second clip that replaces a paragraph
The walkthrough is the wrong unit. The clip that survives a real docs site is a 5-15 second silent loop of one action, and it is the cheaper one to keep true.
Multi-language product demo videos from one recording
Localizing a demo doesn't mean re-shooting it five times. Keep one recorded take, swap the words, and do the honest math on where each locale really costs you.
Nightly demo builds: re-render the demo while you sleep
Compilers rebuild themselves overnight so breakage lands in a log, not a release. Point the habit at your demo and it quits quietly lying about the product.
OBS Studio for product demos: what it does and doesn't do
OBS is free and captures anything, but it finishes nothing: no auto-zoom, no cursor smoothing, no trim. Here is what the hand-labor actually costs.
In-app onboarding walkthrough videos that survive redesigns
The onboarding video shows the exact first-run UI a growth team keeps reshaping. How to build a walkthrough that survives the next redesign.
Open-source demo video tools, scored by license and install reality
Not everything on GitHub is open source. Cap, vhs, Remotion, Revideo, editly, and aidemo, scored on OSI compliance, install friction, and what the pixels are.
Personalized demo videos at scale: the template-render pattern
A merge field with the prospect's name is not a demo that shows their data. Three depths of personalization, priced honestly for a fifty-prospect batch.
Product demo storytelling: three frameworks on one timeline
A feature tour leaks viewers. Three named story frameworks on one 60-second timeline, with per-beat second budgets and the payoff placed on purpose.
The Product Hunt launch video: spec, format, and the first five seconds
The Product Hunt feed shows a 240x240 thumbnail, not your video. The real asset spec, an honest read on the 53% stat, and a shot-list for the night before.
Product launch video: one recording, every launch-day cut
A launch fires six surfaces in one day, all pointing at each other. Here is the cut list from one recording, mapped to the clock and to the 11pm change.
Product onboarding videos that shorten time-to-value
An onboarding video's job is activation, not orientation: four onboarding clips, each mapped to the metric it moves, with a length budget per type.
Product walkthrough video: follow one real task end to end
A walkthrough follows one real task from empty state to done. The table that separates it from a demo, a click-by-click shot-list, and the pacing rules.
What makes a screen recording look professional
The polish people call professional is five named transforms with parameters, not a knack. Here is what each one does and why a bad zoom is a recompose.
README GIFs that update themselves
A 20-second demo GIF can weigh 18 MB, past GitHub's 10 MB ceiling. The format rules, the real size math, and a recapture loop that keeps it honest.
Generating demo data that looks real (and stays safe)
Lorem ipsum makes a demo look like a toy; a copy of production makes it a data-protection incident. The safe middle is seeded, coherent, synthetic data.
How to record just one browser tab (three ways, one clean result)
Recording one browser tab is picking a capture surface, not cropping your desktop. Three ways to do it, scored on fidelity, what leaks, and repeatability.
How to record a terminal session (and when to skip the video)
A terminal is characters, not pixels, so you can record it as copyable text, a GIF, or a re-renderable tape. Pick by where the demo has to live.
How to record your screen on Linux (X11 and Wayland)
On Linux the top screen-recording answer, ffmpeg x11grab, silently fails under Wayland. A capture matrix keyed to your display server, with the commands.
How to record your screen with audio (system, mic, or both)
Your OS won't let an app read its own output, which is why system audio is the hard part. The routing map per OS for system, mic, or both, plus the levels rule.
Release-notes videos generated per release
A monthly recap is a chore that slips; a per-tag video is a release artifact. Which releases clear the bar reads straight off the version number.
Reproducible demo renders: byte-for-byte, on purpose
You pinned the browser so it paints the same pixels every run. The MP4 still differs. Here is why, and the reproducible-builds discipline that closes it.
Reviewing video and media diffs in pull requests
A pull request has nothing to say about a video: git renders it as 'Binary files differ.' Here is how to make a media change a reviewer can actually approve.
SaaS demo video examples: what the best ones do differently
Six real SaaS demo videos from Vercel, Notion, Loom, Linear, Warp, and Retool, read with a stopwatch and a transcript instead of a mood board.
The async sales demo video: a repeatable asset, not a live call
Your live demo reached the one stakeholder in the room; the deal needs twelve more. The shot list for a recorded sales demo, and when it beats a call.
Screen recording aspect ratio: 16:9, 9:16, and the black-bar problem
Black bars are an aspect mismatch, not a look. The destination-to-aspect table with real pixels, and how to get a clean vertical cut from a landscape UI.
Screen recording with a webcam: when the talking-head bubble helps
Every recorder offers a face cam and most leave it on by habit. A yes/no framework for the talking-head bubble, and the corner it should never take.
Screen recording without the mouse cursor (or with a better one)
A captured cursor can't be cleanly removed later, so hiding it is a record-time switch. The per-tool cheat sheet, and the pro move that beats hiding it.
Screen Studio alternatives for Windows, Linux, and CI
Screen Studio is macOS-only and subscription-only now. Here is the honest, per-platform map of what replaces it on Windows, Linux, and in CI.
Selectors that survive a redesign
A demo pinned to nth-child and hashed CSS classes breaks the day a designer touches the layout. Here are the selectors that outlast a redesign.
Social cuts for a launch: one demo into a week of clips
A launch week wants twenty posts across four feeds. You shot one demo. Here is how to cut it into a week of clips instead of reshooting each one.
Storyboard design patterns for demos as code
When the demo is a JSON file, authoring becomes a design-patterns problem: the moves that keep a storyboard readable, and the smells that wreck it.
Support and knowledge-base videos that actually deflect tickets
Most help-center videos deflect zero tickets because they are too long, unsearchable, or stale. Here is which ones pay off, and the deflection math.
Synthesia alternatives when the job is a software demo, not an avatar
Synthesia films a presenter reading a script, which is the wrong star when the job is showing your product actually work. Sort the alternatives by output type.
Testing demos like code: golden files and drift gates
Your code has a test suite; the demo video of it has a filename and a vibe. Golden-file testing closes that gap, once you pick the right layer to freeze.
Versioned demos: one demo per product release
A nightly build keeps one demo current. Versioning does the opposite job: it lets v2.3's demo stay v2.3's forever, so nobody sees a feature they don't have.
Versioning media assets in git: LFS, committed, or external
Git can diff a storyboard forever for free and chokes on the MP4 it renders. Where that binary lives — committed, LFS, or nowhere — is a real decision.
Video-as-code tools: Remotion, Revideo, editly, vhs — and real-UI capture
Remotion and Revideo draw every frame, editly stitches clips, vhs replays a terminal, real-UI capture films your product. Five models, one map.
Video documentation for software: when the medium earns its keep
The evidence-based case for video as a documentation medium: where a clip beats a paragraph, where it quietly loses, and how to route each doc job.
Video in email marketing: the GIF workaround that actually ships
Most inboxes strip your video tag and Outlook freezes your GIF. The client-by-client table for the animated thumbnail that reaches every reader.
Video marketing for software: one recording, every channel
Your buyers sit on nine surfaces; your budget is for one recording. The channel-by-channel spec that turns a single demo into every placement it needs.
Video SEO for product pages: VideoObject schema, done right
Google names three required VideoObject properties, not thirty. The copy-paste JSON-LD that nests a demo into Product schema, and what the markup really buys.
Video vs written documentation: the decision, with evidence
Stop asking whether your docs should be video or text. Score each doc job on four axes and read the right format off the total, evidence not vibes.
Visual regression testing for marketing assets, not just components
Your Storybook is under test; your pricing page is not. Which marketing assets to baseline, how many snapshots each really is, and the noise to mute.
Visual regression testing tools compared by diff engine
Ten tools, three diff engines, one question the listicles skip: where do your baselines live? Cleave the category by mechanism and the field collapses to three.
Where to use your demo video: one recording, ten placements
You recorded one demo and posted it in one place. Here is the ten-surface checklist that makes it pay for itself, each with the cut it needs.
Why every product demo is out of date (and what rot costs)
Linear redrew every header, icon, and nav in one release, and every demo filmed before that day went wrong in every frame. This is how fast demos rot.
YouTube marketing for developer tools: teach, don't advertise
Developers block ads and skip intros, then watch half an hour of a tool that teaches them. The content mix and YouTube-SEO checklist for a dev channel.