He Built a Video Editor and Admitted It’s Broken. That’s the Whole Point.

He built a video editor in the browser. It renders with FFmpeg. And then he told everyone it doesn’t work properly.

That’s not a bug in the pitch. That’s the pitch.

Thiago Albrecht dropped Weave on Hacker News like a confession. “I tried my best to have the React video preview closely replicate the FFmpeg lavfi filtergraph output,” he wrote, “but naturally this is not perfect.”

Naturally. Of course it’s not perfect. And that’s exactly why you should pay attention to it.

Here’s what Weave actually is: a React app with a multi-track timeline editor. You trim, stitch, add transitions, layer audio tracks. Standard video editing stuff. But instead of rendering in the browser, it maps your edits directly to an FFmpeg command and renders the real thing.

The problem? The preview in your browser and the final FFmpeg render don’t match. The eq filter in FFmpeg, when approximated with SVG filters in the browser, looks different. Sometimes subtly. Sometimes wildly.

Most developers would hide this. They’d slap a “beta” label on it, bury the disclaimer in a README, and pretend the gap doesn’t exist.

Thiago put it front and center.

The most dangerous lie in software development is “what you see is what you get.” It never is.

Let me explain why this matters beyond one weekend project.

Every developer who’s ever built a front-end abstraction for a complex backend knows this pain. You build a beautiful UI. The user clicks buttons, drags sliders, arranges timelines. Behind the scenes, you’re translating those interactions into commands, queries, API calls, or in this case, FFmpeg filter graphs.

And then the output doesn’t match the preview.

The user sees one thing. The system produces another. And nobody notices until it’s too late — until the video is rendered, until the report is generated, until the deployment is live.

Weave exposes this gap in the most honest way possible. It’s not a polished product. It’s a prototype for something else. Thiago isn’t trying to sell you anything. He’s showing you the seams.

Every abstraction leaks. The question isn’t whether yours will — it’s whether you’ll be honest about where.

But here’s the twist. The real value of Weave isn’t the editor. It’s not the timeline. It’s not even the final rendered video.

It’s the mapping layer.

When you drag a clip in Weave’s timeline, you’re not just editing a video. You’re watching React UI decisions get translated into FFmpeg commands in real time. You’re seeing how a visual action becomes a command-line instruction. How a transition becomes a filter. How an audio track becomes a parameter.

This is a debugging tool disguised as a video editor.

If you’ve ever stared at an FFmpeg command line trying to figure out why your filter graph isn’t working, you know the pain. FFmpeg is powerful, but its syntax reads like ancient runes. Weave lets you see the relationship between what you want and what you get — and more importantly, where they diverge.

Someone in the comments mentioned they built something similar called FableCut. The pattern is emerging: developers are building visual layers on top of command-line tools, and every single one of them is hitting the same wall.

The wall between preview and reality.

The gap between your interface and your output isn’t a bug to fix. It’s a boundary to understand.

Here’s what this means for you, whether you’re building a video editor or a no-code tool or a visual pipeline builder:

Stop obsessing over pixel-perfect previews. Start obsessing over the translation layer.

Your users don’t need to see exactly what they’ll get. They need to understand why they’re getting what they’re getting. They need to see the mapping. They need to peek behind the curtain.

Thiago built a tool that shows you the curtain. He didn’t pretend it was invisible. He told you exactly where it frays.

That’s not just good engineering. That’s good art.

And in a world where every product launch promises perfection and delivers approximation, that kind of honesty is worth more than any feature roadmap.

Build the thing. Ship the thing. And when the preview doesn’t match the output, don’t hide it — teach with it.

Weave might not be maintained. It might not become a product. But it already did something more valuable than any production tool could: it showed us where the abstraction breaks.

Go play with it. Drag some clips. Render a video. And then look at the difference between what you saw and what you got.

That difference is where all the interesting work happens.