There’s a certain type of builder who doesn’t chase attention but ends up shaping how millions of people work anyway. Tom Stenberg fits that description almost perfectly.
If you’ve ever used CodeMirror, interacted with ProseMirror, or indirectly benefited from modern in-browser editing tools, you’ve brushed against his work. Maybe without realizing it. That’s kind of the point. His software doesn’t scream for credit. It just works—cleanly, efficiently, and in places where things are usually messy.
Let’s take a closer look at the person behind those tools, and why his approach matters more than it might seem at first glance.
The Kind of Developer Who Solves the Right Problems
Some developers build flashy things. Others solve the annoying problems everyone else quietly avoids.
Stenberg falls firmly into the second group.
Text editing in the browser sounds simple until you try to build it. Then it becomes a swamp of edge cases—cursor positions breaking, formatting behaving inconsistently, copy-paste chaos, strange browser quirks. It’s the kind of problem that looks easy from the outside and becomes deeply complex the moment you touch it.
Now imagine deciding not only to tackle that problem, but to do it in a way that other developers can build on. That’s what CodeMirror did.
CodeMirror isn’t just a code editor. It’s a foundation. A piece of infrastructure that countless tools rely on. From lightweight coding environments to full-blown developer platforms, it shows up quietly in the background.
And that’s a pattern you see again and again in Stenberg’s work: he builds systems, not just features.
CodeMirror: More Than Just a Code Editor
At first glance, CodeMirror looks like a simple browser-based editor. Syntax highlighting. Line numbers. Maybe some autocomplete if you wire it up.
But spend a bit more time with it, and you realize how much thought went into the architecture.
It’s modular. Extensible. Carefully designed so developers can adapt it without fighting it.
That matters more than it sounds. Anyone who’s tried to customize a rigid tool knows the frustration. You start with a small tweak and end up rewriting half the system.
CodeMirror avoids that trap. It gives you just enough structure without boxing you in.
Here’s a quick example. Say you’re building a documentation site with embedded code examples. You want syntax highlighting, sure—but also inline annotations, custom keybindings, maybe even collaborative editing later on.
With a rigid editor, you’d be stuck hacking around limitations. With CodeMirror, you can extend it step by step. It grows with your needs.
That flexibility didn’t happen by accident. It’s the result of someone thinking deeply about how developers actually use tools—not just how they look in demos.
The Shift to ProseMirror: A Different Kind of Challenge
After CodeMirror, it would’ve been easy to keep iterating in the same space. Improve performance, add features, refine APIs.
Instead, Stenberg moved into something arguably even messier: rich text editing.
If code editors are complex, rich text editors are chaos.
Think about all the expectations people bring from tools like Google Docs or Notion. You press Enter, things should “just work.” You paste content from somewhere else, and it should behave. You collaborate with others, and changes should sync smoothly.
Underneath that simplicity is a tangled web of rules.
ProseMirror was built to bring structure to that chaos.
It treats documents not as loose blobs of HTML but as structured data. That’s a subtle shift, but a powerful one. It allows developers to define exactly what kinds of content are allowed, how they behave, and how they change over time.
Instead of fighting the browser’s default behavior, ProseMirror creates its own model and keeps everything consistent.
Now, let’s be honest—this isn’t the easiest tool to pick up. Many developers hit a wall early on. The concepts are different. The learning curve is real.
But once it clicks, it opens up possibilities that simpler editors can’t handle.
You can build custom editors tailored to specific workflows. Legal documents with strict formatting rules. Collaborative writing tools with structured sections. Interfaces where content isn’t just text but a mix of components.
That’s where ProseMirror shines.
Why His Work Feels Different
There’s a certain restraint in Stenberg’s projects that stands out.
They don’t try to do everything out of the box. They don’t overwhelm you with features you didn’t ask for. Instead, they focus on providing solid primitives.
That word—primitives—comes up a lot when people talk about his work. It basically means building blocks. Small, well-designed pieces that you can combine in different ways.
It’s a philosophy that respects the developer’s intelligence.
Here’s the thing: many tools try to guess what you want and end up getting in your way. They’re optimized for the “average” use case, which means they rarely fit perfectly.
Stenberg’s tools take a different approach. They give you control. Sometimes a bit too much, depending on your perspective.
But if you’re building something non-trivial, that control is exactly what you need.
The Open Source Mindset
Another key part of his impact is how his work lives in the open.
Open source isn’t just about making code available. It’s about creating a shared foundation that others can build on.
CodeMirror and ProseMirror have both attracted active communities. People contribute extensions, report issues, share patterns. Over time, the ecosystem grows beyond what a single person could manage.
But here’s something interesting: despite being widely used, these projects haven’t turned into bloated monsters.
That’s not luck. It’s stewardship.
Maintaining a clear vision while accepting contributions is harder than it sounds. Too much openness, and the project becomes inconsistent. Too much control, and it stagnates.
Stenberg seems to walk that line carefully. Changes are thoughtful. The core stays clean.
As a result, developers trust the tools. And trust is everything when you’re building on top of someone else’s work.
A Developer’s Developer
Talk to people who’ve used CodeMirror or ProseMirror deeply, and you’ll hear a common theme: respect.
Not just for the tools, but for the mindset behind them.
There’s a feeling that the person who built this understands the problem space at a deep level. That they’ve thought about the edge cases you haven’t even encountered yet.
That kind of trust doesn’t come from marketing or hype. It comes from consistent, thoughtful design over time.
It also comes from restraint—knowing when not to add something.
Let’s say you’re designing an API. It’s tempting to include every possible feature upfront. Anticipate every need. Cover all bases.
But that often leads to complexity and confusion.
Stenberg’s work suggests a different approach: start with a strong core, then expand carefully. Let real use cases guide the evolution.
It sounds simple. It’s not.
Real-World Ripples
Even if you’ve never directly used his libraries, you’ve likely benefited from them.
Many popular developer tools, online editors, and content platforms rely on CodeMirror or ProseMirror under the hood. They’re part of the invisible infrastructure of the web.
Think about writing a blog post in a modern editor that feels smooth and responsive. Or editing code in your browser without glitches.
Those experiences don’t happen by accident. They’re built on layers of thoughtful engineering.
And that’s where Stenberg’s influence shows up—not as a brand name, but as a standard.
Lessons Worth Paying Attention To
There’s a lot to take away from how he approaches building software.
First, pick problems that matter. Not just trendy ones, but ones that people struggle with repeatedly.
Second, go deep. Surface-level solutions don’t hold up when complexity hits.
Third, design for flexibility. You can’t predict every use case, but you can create systems that adapt.
And maybe most importantly, respect the people who will use your work. Give them tools, not constraints.
These ideas aren’t limited to programming. They apply to almost any kind of building—products, systems, even writing.
The Quiet Impact
Not every influential figure is loud about it.
Tom Stenberg’s work doesn’t come with big announcements or flashy branding. It spreads through usefulness. Through developers recommending it to each other. Through projects quietly depending on it.
There’s something refreshing about that.
In a world where attention often feels like the goal, it’s a reminder that impact can come from a different direction—solving real problems, thoughtfully, and letting the work speak for itself.
And if you’ve ever built something on the web, there’s a good chance his ideas have already shaped your experience in ways you didn’t notice.
That’s the kind of influence that lasts.