Between work and study, I spent nearly 10 years with relational databases (2008–2018), with only a passing look at other philosophies of storing data. Along the way I met a few NoSQL zealots who believed it could replace relational databases at everything. But the world of data structures is much bigger than those two ideas, and there is a lot of it that I tried to sum up in the map below, including the new kinds of data (if that is the right word) that have come with the latest waves of technology.
Mapping tables to classes in object-oriented programming was fun for me, especially when the big map took shape: the entity-relationship model, with all its relationships. I didn’t mind the extra complexity of relationships that don’t exist in real life. To say that this phone number belongs to that person, in object-oriented code and in a relational database, there are several ways, but the traditional one is to put the phone number’s ID in the people table. Why not just put the number itself? There are many reasons for that: how an object relates to the way it is used in code, the attempt to arrive at a model that resembles life, and a practical benefit too, since smaller units of data can be changed separately in a database governed by strict locking rules on reads and writes, so that every user gets the same picture. But even in life, or in our brains, that is not exactly what we do. Many people have suffered this frustration. Why is data shaped this way? Why constraints instead of freedom in data structures?
I think that today, with a real layer of AI working on our source code, those considerations have changed. Whether we are talking about schema changes and how the two philosophies differ on them, or about how easy the work is, all of these considerations are gone now. What remains between the two systems is that document databases scale better.
In Designing Data-Intensive Applications, Martin Kleppmann treats this, like any other choice, not as a matter of personal preference but as a set of precise conditions that may lead you to other styles of storage and structure, such as the network model, the graph model and triple stores (Kleppmann, 2017). Something like the wish to escape the constraints of the relational model is one of its main points of failure, and it is what made the document model popular, a model that also scales well, along the familiar path of pessimism and failure by which technology moves forward.
What we learn from Kleppmann about data modelling is to keep a wide view: not only towards those faded models, such as the network or the graph model (they exist and have their specific uses, but they are not real competitors), but also towards the other possible points of failure that could lead us to invent yet another storage model. Failure in systems, and thinking about how they might fail, can take us anywhere.
In today’s age of AI we can revisit the models that were less lucky to spread, such as the network and graph models. Expertise used to be a real barrier to writing custom code for them. Today, for example, I keep tree indexes of the information I store for my daily work with AI, where I think about how AI agents will find what they need, something many systems in the past could not even consider for their applications. We now have far more room to build hybrids of several data models instead of sticking to one. But should we expect new kinds of data, or new data structures, because of AI?
It is unlikely that a language model will invent a new data structure, especially knowing that many of today’s structures go back to the 1960s or 1970s, and that for decades many computer scientists had little else to do but think about problems like these. That is, at its root, exactly what language models struggle with. So I expect language models to help us make use of the existing models, not to invent a new kind, at least not at the level of the basic foundations of today’s data types.
New kinds of data
As the map above shows, there seem to be no new kinds of data. And if we think about it, the ways of arranging information usefully for retrieval are limited. In a way, XML and JSON follow a very similar method and differ only in where the brackets go and how the information is structured, yet the tech world has dealt with each of them very differently. JSON is said to parse faster than XML (Popovic, 2017), for small, precise reasons that come from the shape of the data, but the difference stays small. And if we widen the view to the graph model and others, we find that the existing methods have covered nearly every possibility. Up at the level of systems, though, the picture is different.
When we get to databases and streaming systems, we find a new kind that began in 2011, called conflict-free replicated data types (CRDTs). Almost magically, a CRDT can accept replication across several servers with no coordination between them, relying instead on the data type itself to resolve conflicts, through an algorithm and a state that travels with the stored data. So we are talking about extra complexity, no different from the complexity of any strategy for managing conflicts and replicating data between servers, except that here it belongs to the data type.
CRDTs are not very different from the data landscape of the last 20 years: they lean more on memory and need a network connection to sync (they can survive without one, but they still need it). They also need a lot of storage, more than XML or JSON.
Some data types, which were not new inventions or new structures either, such as the e-graph, have become useful in these language use cases as machine learning and deep learning advanced. E-graphs were designed as stores that gather different variants of the same thing, like the different meanings of a word. In other words, they rest on the relation of equality (in meaning) between the words of a given language. Naturally, “language” may stretch here to its broader sense, not necessarily our spoken human languages.
And in response to the changing demands on version control, Anthropic built a modern replacement for Git, called Scion. Of course, none of us sees Git as a data structure; our relationship with it is different. But it is one, and it has counterparts in database schemas, schema versions and how they are managed. Because of Claude, the number of code merges at Anthropic jumped into the thousands in May 2026 (2,500 merges a day), and to more than 30,000 a day two months ago, in September (Anthropic, 2026). Anthropic turned many Git concepts upside down and built changes into its new system that go beyond anything we would compare with data structures, even though, in the end, it is a data structure.
In the end, we are freer with data structures today: we don’t need personal expertise to work with them. But it is worth saying that programming with AI won’t necessarily lead us to those varied structures, which is exactly why we need to understand and know them, to be able to benefit from them. Knowing the new kinds of data structures also makes us more ambitious about designing, with AI, the structures we need when we need them. That is something else to keep in mind when we try to design a system with unusual, special needs. What was a luxury or an academic excursion yesterday can become part of our systems today.
If Anthropic built its own version control system, we may see other companies and engineers put forward new variants of technologies we have grown used to. But we should also know that the basic structures of data, whether concepts such as the queue, the stack or columnar storage, or well-known formats such as JSON, XML and Parquet, have not changed, and most likely will not. One of the oldest data structures, the table, is still the most used, as logic would have it.
References
- Anthropic. (2026, October 13). Redesigning source control at Anthropic. Anthropic Engineering. https://www.anthropic.com/engineering/redesigning-source-control
- Kleppmann, M. (2017). Designing data-intensive applications: The big ideas behind reliable, scalable, and maintainable systems. O’Reilly Media.
- Popovic, J. (2017). JSON parsing 10x faster than XML parsing. Microsoft Tech Community, SQL Server Blog. https://techcommunity.microsoft.com/blog/sqlserver/json-parsing-10x-faster-than-xml-parsing/385700
Comments