Our Tools Weren't Built for This

Claude Code kept rewriting my documentation files, and I had no way to track what changed.

That sentence probably doesn’t surprise you. If you’ve spent any real time collaborating with AI on anything longer than a chat message, you’ve felt this. The AI makes changes. Good changes, usually. But you’re left squinting at the output thinking… what exactly is different? What did it keep? What did it quietly drop?

The AI did its job. The tools around it completely failed to do theirs.

The collaboration gap

We’re in this weird in-between moment. AI has gotten remarkably good at producing and editing text, code, documents, entire projects. But the tools we use to manage that work haven’t caught up. Not even close.

Think about what a typical AI collaboration actually looks like right now. You write something. You paste it into a chat. The AI rewrites it. You paste the result back into your editor. You try to remember what your original said. You squint. You compare tabs. You lose track of which version had that paragraph you liked.

It’s like having a brilliant co-author who scribbles all over your manuscript in invisible ink. Worse if you use Claude Cowork. It just updates the document and gives you a vague overview of what it did. And you pray it didn’t hallucinate something for your important proposal.

“It’s like having a brilliant co-author who scribbles all over your manuscript in invisible ink.”

Version control exists, obviously. Git is incredible for code. But for prose? For documentation? For the kind of messy, iterative, back-and-forth work that AI collaboration actually involves? Git diffs are unreadable. Google Docs track changes weren’t designed for an agent that rewrites entire sections in one pass. And plain text editors give you nothing at all.

The tools assume a human is making small, sequential edits. That’s not what’s happening anymore.

What AI collaboration actually needs

When you work with another human, you have norms for this. Track changes in Word. Suggesting mode in Google Docs. Comments in the margin. “Hey, I rewrote section three, take a look.” There’s a social contract around transparency.

AI doesn’t have that contract. It changes what it changes and moves on. Which means the tooling needs to enforce what social norms used to handle. You need to see what changed. Not in a raw diff that looks like a merge conflict. In something you can actually read and reason about.

You also need continuity. The document on your screen and the document the AI is working with need to be the same document, updating in real time. Not a copy-paste relay race between your editor and a chat window. That workflow is fragile, error-prone, and honestly just exhausting after the third round trip.

And you need a writing surface that doesn’t fight you. Most editors are either too heavy (looking at you, Word) or too bare (plain text with no awareness of what just happened). There’s a middle ground that barely exists yet. Clean enough to think in. Smart enough to show you what your AI collaborator just did.

Why I built HrafnMark

This isn’t hypothetical frustration for me. I hit this wall daily.

I was using Claude Code and Cowork to help maintain documentation across multiple projects. And I kept running into the same problem: Claude would update a file, and I’d have no clear picture of what changed. Sometimes it improved things. Sometimes it subtly shifted meaning in ways I didn’t catch until much later. The changes weren’t wrong exactly. They were just… invisible.

So I built HrafnMark. A text editor designed specifically for this kind of work. Version control that actually shows you what your AI changed, in a way that makes sense for prose, not just code. Live sync so Claude Code and your documents stay in step. No more copy-paste relay. A clean writing surface that gets out of the way when you’re thinking and shows up when you need to review.

It’s not a full word editor. It’s not trying to be. It’s the space where human thinking and AI output meet, with enough transparency to make that collaboration actually trustworthy.

This is a bigger problem than my editor

I built a tool to solve my own problem. But the underlying issue is everywhere.

Every application that integrates AI is going to face this. How do you show the user what the AI did? How do you let them roll back gracefully? How do you maintain trust when an agent can change fifty things in a single pass?

Right now, most apps handle this by… not handling it. The AI makes changes, and you either accept the whole thing or you don’t. That’s not collaboration. That’s delegation with no oversight.

The tools that win in the AI era won’t just be the ones that integrate AI the fastest. They’ll be the ones that make AI collaboration legible. That give humans the right level of visibility without drowning them in diffs and changelogs. That treat the AI as a collaborator who needs to show their work, not a black box that produces output.

We figured this out for human collaboration decades ago. Track changes, version history, commenting, suggesting mode. None of those concepts are new. But they all need to be reimagined for a collaborator that works at machine speed and machine scale.

The trust layer

Here’s what it comes down to. You can’t collaborate with something you can’t verify. And right now, verifying what AI changed in your work is way harder than it should be.

“You can’t collaborate with something you can’t verify.”

The fix isn’t to slow AI down or limit what it can do. The fix is better glass. Clearer windows into what happened, when, and why. Tools that make the AI’s contributions as visible as a colleague’s tracked changes.

We’re building a world where AI touches nearly everything we write, code, and create. The question isn’t whether we trust the AI. It’s whether our tools give us enough visibility to trust the process.

Mine didn’t. So I built one that does.

HrafnMark is in early beta. If this resonates, get in touch.