A video editor for developers who hate timelines

You can stand up an API, wire a CI pipeline, and debug a race condition before lunch. But cutting a 40-second demo of the thing you just built somehow eats an entire afternoon. The work isn't hard — it's tedious. Hunting for the moment your command actually returns, syncing captions, finding music that doesn't sound like elevator hold. That's the tax you pay just to show people what you made.

The villain here is the manual timeline. Dev tools, APIs, and CLIs are some of the hardest things to demo well — most of the action is text scrolling in a terminal — and the GUI editors that exist treat you like you've got hours to fiddle with razor tools. You'd rather pipe a recording into a command and get a finished cut back. That instinct is correct.

We built OpenNolan because we'd rather ship than learn a timeline too. It's a Mac app where an AI agent makes the whole vertical short from your raw clips — cuts, captions, B-roll, music, motion — and it runs locally, brings its own intelligence through your own API key, and is open source so you can read exactly what it does. You stay the builder. The agent handles the editing.

Turn a terminal recording into a short

Pipe a recording in, get a finished cut back — that's the workflow developers actually want.

The agent-first workflow is the part that will feel familiar. Drop in your screen capture or terminal recording, tell the agent what the tool does, and bring your own provider key. It reads the brief, finds the payoff moment, and assembles a vertical cut tuned for Reels, TikTok, and Shorts — the formats where developer audiences actually scroll.

Because dev demos are mostly text in motion, the agent leans on the things that make them watchable: a hard hook in the first second, fast cuts every one to three seconds, captions burned in for the ~85% who watch on mute, and screenshot proof with auto-highlight when you want to point at a result. It is the short-form playbook applied to a `curl` call instead of a dance trend.

• Screen or terminal recording in, vertical short out
• Agent picks the hook and the cuts, not you
• Burned-in captions so the demo reads on mute
• Screenshot proof with auto-highlight for results and benchmarks

The agent does the editing — you stay in the loop

Here's the plan, three steps. One: drop in your clips, or just describe the demo, and add your API key. Two: the agent makes the whole reel — pulling supporting images and B-roll from the web, adding music and sound effects, writing captions, animating overlays, and cutting it for vertical. Three: post it, or open a real timeline and tweak first.

If you do want to adjust something, the editing model is built for people who think in terms of cheap iteration. OpenNolan renders once, then most edits — reorder, retrim, retime, reposition, transitions, text — preview instantly without re-rendering. Only AI-composition scenes re-render, and only the single scene you changed. It feels less like a video suite and more like a fast feedback loop you already trust.

• Agent-built composition: cuts, B-roll, captions, music, motion
• Render once, then preview most edits with no re-render
• Only the one changed scene re-renders, not the whole timeline
• A real NLE timeline is there when you want manual control

Local-first, open source, bring your own key

This is the part a technical audience cares about most, so we'll be plain. OpenNolan is a native macOS app that runs on your machine — your clips and project files stay local. It is open source, so you can read the code, see how the agent makes decisions, and trust it because you can inspect it, not because we asked you to.

There's no subscription and no markup. You bring your own AI provider key and pay the provider directly — no account required. If you've ever wired up an API key for a side project, the setup is the same idea. You control the key, the cost, and the data.

Founders and indie hackers want the same speed for different reasons — see the founders page and the indie hackers page. For developers, the draw is the agentic, scriptable feel: tell it what you built, let it edit, keep the receipts local.

• Native Mac app, runs locally, files stay on your machine
• Open source — read exactly what the agent does
• Bring your own key, pay providers directly, no markup
• No subscription, no account required

Ship demos as fast as you ship code

The outcome is simple. The new feature you merged this morning gets a short by this afternoon — not next sprint, not never. Your launch tweet has a video attached instead of a wall of text. The CLI nobody could picture suddenly clicks because someone watched fifteen seconds of it working.

Developer products live or die on whether people can see them in action. When making the demo costs minutes instead of an afternoon, you make more of them — and the tool you built actually gets discovered. That's the whole point: less time as a reluctant editor, more time shipping. New to the format? Start with what makes a hook work.

Frequently asked questions