Forty years ago, a program consisted of a few thousand lines of code. One person could read it, understand it, and keep it in their head. Today, systems consist of millions of lines, hundreds of libraries, countless dependencies—and yet many of them still behave as though they were alone in the world.
The Pain
Today, every program knows its libraries. It knows which function it imports from which package, which version is compatible, and which path leads to a file. But hardly any program understands why another component exists in the first place. It doesn’t know who in the system might actually be able to help when a task lies beyond its own capabilities. And it has no way of recognizing how new capabilities could emerge without someone programming them into the system from the outside.
When something is missing, another configuration file gets written. When more is missing, another dependency gets added. The system grows—but it grows like a pile, not like an organism. Every part works on its own. Yet the whole remains blind to itself.
Our Question
What if software could manage its relationships as naturally as it manages its data? Not centrally controlled by an instance that knows everything. Not hidden away through yet another layer of abstraction. But in the way living beings interact with one another: with identity, with boundaries, with the ability to recognize when they can move forward on their own and when they depend on someone else.
Biocodie grew out of that question.
Cells Instead of Files
Biocodie does not describe software as a collection of files that are somehow supposed to work together. It describes software as a community of independent cells. Each of these cells has its own identity—it is not interchangeable; it is something specific. It takes responsibility for a clearly defined area instead of doing a little bit of everything. It maintains relationships with other cells that it knows and trusts. It has boundaries that define what it does and what is explicitly not its responsibility. It can ask for help when a task exceeds its own capabilities. And it can evolve without someone having to take the entire system apart.
None of these ideas is new. Every one of them has existed for a long time—in distributed systems, in microservices, and in the biological metaphors that computer science has been brushing up against for decades. Biocodie attempts to think these ideas through consistently to their conclusion.
The Goal
We are not trying to make software more intelligent. Artificial intelligence opens up many new possibilities—Biocodie is concerned with a different question: How can programs understand and use their own relationships? We are trying to do something more modest and, at the same time, more difficult: make software easier to understand. For itself and for the people who work with it.
Because a system that understands its own relationships can also be understood more easily by people. Not because it is simpler. But because it is more honest about what it is and what it can do.
Where We Stand Today
Biocodie is being developed in public. Not behind closed doors, not as a finished product that will one day simply be announced. But commit by commit, with discussions, with mistakes, with ideas that turn out to be dead ends, and others that point exactly in the right direction.
Maybe Biocodie will one day become a new way of building software. Maybe it will remain an idea that influences other approaches without ever becoming the blueprint itself.
We don’t know. But we believe the question—relationships instead of dependencies—is important enough to ask in public.
Because when programs understand their own relationships, people no longer have to keep the entire system in their heads.
New capabilities can be added without putting the whole system at risk. Errors become easier to trace. Software becomes easier to understand—for itself and for the people who work with it.
And that’s exactly what we’d like to invite you to do: think with us, question with us, and doubt with us.
