We’ve become too fragmented. As programmers, we juggle countless tools to complete a single task. Sometimes the environment breaks without us touching it or even knowing it exists.
This fragmentation seeps out into the world: the same brand with wildly different websites, company representatives telling different stories. Entropy is natural, but that doesn’t mean we can’t fight it.
Paradigm
We fragment because we’re taught to build in pieces. if–else and try–catch turn code into tangled trees. “Do one thing only” functions lead to premature isolation. Tools hide unhappy paths until they fail catastrophically.
I’ve worked in setups where one step ran in GitLab or GitHub actions, another on an in-house platform, logging in Grafana. Just switching contexts drained more energy than solving the problem itself. Imagine one coherent interface orchestrating all of it.
The old wisdom, do one thing only, use the right tool for the job, separate concerns, has limits. We don’t need “simple” tools. We need powerful tools with simple, unified interfaces. LLM chatbots prove the point: immense complexity, one text box. We don’t even need a “simple” interface, just a coherent, unified one.
This is why, since learning Rust in 2018, I haven’t gone back. Features like enum and pattern matching make it easy to handle uncertainty without sacrificing detail, write linear code without losing complexity, and keep both happy and unhappy paths in view, not to mention that visibility that lets us foresee further.
Not Costly Anymore
Convergence is often seen as expensive or perfectionist: coherent user manuals, robust branching, even strong type systems. In reality, the barriers are:
- Unfamiliarity can be solved with time and practice.
- Unfriendly tooling is something we can improve ourselves.
- Lack of insight requires a shift in paradigm, tricky, but not impossible.
And remember, this is 2025. Those once-costly integration efforts you avoided because they took too long? They might be more important and cheaper now. We have AI.
The Ultimate Picture
What isn’t convergence?
- Automation that needs constant manual checking isn’t automation.
- An abstraction that leaks isn’t really an abstraction.
- Boundaries that require constant workarounds are useless.
I want something like a modern aircraft cockpit: every important control within reach, less-important mechanics hidden. It takes time to learn, but there’s a manual.
But cockpits didn’t evolve overnight. The winning bet is on tech that lets us move fluidly up and down abstraction layers so small architecture changes don’t turn into week-long debates.