Turning Code Into Space
Museums are wonderful places. I think it's very cool how artists manage to translate abstract, complex themes into real spaces and objects. As a visitor, you don't require knowledge about the topic to get a sense of the artist's mind, because the layout of the exhibition and its rooms do a lot of the explaining.
While I was walking through an exhibition about masculinity, I started wondering: if a topic such as this can be translated into the physical world, how could one do the same for software development and coding? A topic that shapes so much of our daily lives, especially now in the age of AI. We live in a time where everyone feels like they’ve become a (vibe-coding) software developer, but very few actually grasp the underlying systems and architectures.
What AI makes clear is that software development can be split into two categories: writing lines of code and designing the overall architecture. Writing lines of code is what AI does well. It knows how to produce boilerplate code, write CRUD endpoints, connect to a database, and handle other relatively simple things that have been done thousands of times by developers already. But knowing and understanding the architecture of a software project is something different, something way more complex. It is about choosing solutions, applying real-world rules and abstracting them, defining boundaries, and accepting trade-offs, all while making sure the solution stays scalable and secure. If AI is becoming good at filling in the details, the human role naturally shifts toward shaping the system.
So how do we explain this to all of our new vibe-coding friends? That’s hard, mainly because the software we use every day is largely invisible. Compare it to an iceberg: users only see the tip, while most of it is hidden underwater. With software, users only see the frontend interfaces, while the actual structure of the system (the layers, dependencies, and libraries) is invisible to them. It exists only on servers “in the cloud” and in the heads of the people who built it. The hardest and most important part of software development is also the least visible.
Back from the museum exhibition, in my hotel room, I found myself thinking about this. Museums are good at making abstract ideas come to life. They turn invisible concepts into a visible reality. That made me wonder: what if software development and coding were exhibited in the same way? Not by showing screens with lines of code, but by turning systems into something you could physically move through. Not to teach people how to program at a fine-grained level, but to show the overall, zoomed-out architecture of software systems.
Imagine a museum where a software system is laid out as a building. You enter through a hall that represents the load-balancing and controller layer. Requests (visualized by yourself, the visitor) come in and are checked, routed, or rejected. Based on the type of request, some doors open while others stay shut. Even without understanding anything technical, it becomes clear that this is where the gatekeeping happens, where the system decides what it will and will not accept from the outside world. It's your way in.
Further inside are rooms where decisions are made. A request can take different routes depending on its contents. This is the business or logic layer, where a request is processed further based on a set of conditions and rules, much like how people exist and behave in society.
One floor deeper, we enter the data layer, which could be visualized as an archive or vault. Access is restricted; only those with proper credentials can enter. Some can only see (read), while others can also change (create, update, delete). In any case, this room should make you feel that this is not a place to wander freely. Data is important and valuable, like gold and silver. Without showing a single line of code, visitors understand why this layer needs protection and why a software system with good architecture treats its data with care.
In an age where AI can generate (boilerplate) code at scale, visualizing the architecture that holds it all together, in a compelling way through a museum exhibition, feels important. Important for everyone to understand. By turning software architecture into something you can walk through, you reveal what software development really is in the end: a human craft where structure and careful considerations are very important.
Code may be partly written by machines, but architecture always needs a human author.