I built a Beyond Compare clone in 2 hours. It took 15 more hours to ship

I built a Beyond Compare clone in 2 hours. It took 15 more hours to ship.

I've been using Beyond Compare for years to diff files and directories. It works well, but there were a few things I always wanted to customize — the directory tree layout, the way file trees get copied. I figured instead of waiting for a feature request, I'd just build my own. And I wanted to see how fast AI could get me there.

So I opened Claude and said: "Help me build a tool like Beyond Compare."

2 hours later, something usable was running.

Side-by-side diff, syntax highlighting, chunk navigation — most of this is built into Monaco Editor. Tauri handled the local file system access. The first working version came together surprisingly fast.

Then I started thinking about turning it into an actual product. That's when the questions started piling up:

• Only supports copying one direction? And the direction is backwards?
• No node_modules exclusion when comparing folders?
• Should the directory tree look like BC's, or should I design something I actually prefer?
• I want to copy a file tree of "left-only files" or "changed files" — how should that work?
• Should it restore the last comparison on next open?
• It's a product now, so it needs settings — global config and per-session overrides?
• When there's a bug, how do I explain it to AI? — logging is non-negotiable
• What about binary files?

Each question is a product decision, not a technical one.

Take the directory tree. Beyond Compare uses a two-column layout — left side, right side, same path aligned on the same row. Seemed like the "correct" approach since that's what the reference product does. But a single-column merged tree is actually denser — one row tells you everything about a file, no eye-scanning left and right. Add collapsing, status filtering, and filename search, and even large directories stay manageable. I went with single-column. It turned out better than I expected. Studying a reference product is for understanding the problem, not copying the answer.

Take .gitignore conflicts. What happens when the left and right directories have different ignore rules? You could take the union — if either side ignores it, skip it globally. Clean and simple. Or you could show the ignored files grayed out, so the user can see "this file exists, but one side is filtering it out." That's not a technical question — it's a question of how much information you want to surface. I ended up supporting both modes and letting the user choose.

Take the logging system. I kept thinking I could add it later. Then a directory comparison broke and I had no idea why — how many files were scanned, which ones got filtered, which ones failed to read. Nothing. That forced the issue. Once I built it, I immediately regretted not doing it sooner.

Once all of that was sorted out, I figured it was time to ship. New set of questions:

• Where do I host it? How do I automate deployment?
• How do I build for multiple platforms? Can that be automated too?
• How do I set up a website? How do I handle updates?
• How does a private repo work alongside a public one?
• Where do users download it? Where do they send feedback?

Another 15 hours.

Looking back: AI changed the speed of execution, not the thinking itself.

"Single-column or two-column tree?" "How should ignore rule conflicts behave?" "Should config be layered?" — none of those decisions were made by AI. I still had to work through each one. But once I knew what I wanted, AI could execute fast enough that I spent more time thinking and less time buried in code.

That combination feels genuinely different from building alone.

The tool is called Diffre. Free to download: https://www.printf.app/diffre/

Comments

[KristinZ]

One more thing I forgot to mention: the app icon.

I asked AI to generate several versions. None of them worked. Not a technical problem — an aesthetic one. No matter how detailed my description was, something was always slightly off. Hard to explain, just... off.

Eventually I sketched a rough version myself and asked AI to refine from there. That's when it finally started going in the right direction.

AI is great at executing in your direction. Finding that direction in the first place — that part is still on you. Turned out to be true for code decisions and icon design alike.