Thinking In Systems... The Next Layer
What happens when code becomes cheap and the domain becomes precious?
There’s something profoundly beautiful about thinking in systems. Not just understanding individual components, but seeing how they connect, influence, and transform each other. It’s the difference between looking at a tree and seeing a forest ecosystem. Between debugging a function and understanding an architecture. Between building a feature and shaping a platform. It’s seeing the patterns in all the chaos, and realising, it was never really chaos at all. You just weren’t paying attention to it.
I remember when I was a little kid, I would picture systems in my mind. I would play a game where I would try to memorise complex routes and see if I could remember my way back home. I would close my eyes and see if I could see where I was currently at based on whether or not we had gone left or right, whether we were at a stop sign.
Turns out that game never stopped.
The Hidden Elegance
When you start thinking in systems, the world reveals patterns you couldn’t see before. You notice how small changes ripple through connected parts. How feedback loops amplify or dampen behaviour. How emergent properties arise from simple interactions that no single component could produce alone.
Software engineers who think in systems don’t just write code - they design interfaces that compose. They build abstractions that scale. They create tools that enable others to build tools.
The most elegant systems hide their complexity behind simple, powerful interfaces. Git’s commit, branch, and merge commands conceal an intricate directed acyclic graph. Docker’s run command abstracts away kernel namespaces and cgroups. These tools work because they respect how systems actually behave.
Everything has a purpose. Everything is intentional… When you think in systems.
The Pattern of Progress
Look at how digital infrastructure has evolved. Each era built a new layer on top of the previous:
Physical Layer - Cables, electrical signals, the actual bits flowing on wires. The foundation of all digital communication.
Data Link Layer - Ethernet frames, MAC addresses, error detection. Made it possible to reliably send data between devices on the same network.
Network Layer - IP addressing, routing protocols, packet switching. Connected separate networks together, creating the internet itself.
Transport Layer - TCP/UDP, flow control, reliable delivery. Ensured data arrived correctly, in order, even across unreliable networks.
Session Layer - Managing connections, authentication, keeping track of who’s talking to whom. Made persistent communication possible.
Presentation Layer - Encryption, data formatting, compression. SSL/TLS ensuring secure communication became infrastructure everyone could use.
Application Layer - HTTP, web services, REST APIs, cloud platforms. Abstracted away networking complexity so developers could focus on building applications.
AI Layer - Large language models, reasoning engines, autonomous agents. Intelligence as infrastructure, available through simple API calls.
Domain Layer - TBD
Each layer democratised access to what came before. Each layer became infrastructure for the next.
But here’s what’s fascinating: we’ve built all the way up to AI, yet we’re forgetting about what comes next…
The domain itself.
The Next Layer
Right now, domain knowledge lives in people’s heads, scattered docs, and tribal wisdom.
When a medical device engineer knows how sensor calibration affects diagnostic accuracy across temperature ranges, that’s invaluable. When a manufacturing engineer grasps the cascading dependencies between supply chain, production line timing, and quality control, that’s critical institutional knowledge. When a aerospace engineer understands how an aircraft’s fuel system interacts with its electrical system and flight controls, that knowledge is precious.
But it’s locked away. Hard to version. Difficult to share systematically. Lost when people leave.
We’ve built infrastructure for machines, memory, deployment, applications, even AI.
What if the domain is the next layer?
Why This Matters Now
Code is becoming cheap. When AI can generate boilerplate, when GitHub Copilot writes functions, when the act of writing code itself is being democratised, something profound happens.
The bottleneck shifts.
The democratisation of code activates the domain layer.
When writing code is no longer the expensive part, we can finally focus on systematising domain knowledge. Not just documentation. Not just models sitting in isolation. But queryable, composable, version-controlled infrastructure - the same way we treat code today.
What if the knowledge about what you’re building was as accessible and systematic as the knowledge about how to build?
When system models can compose and integrate the way code does, what new possibilities emerge?
Systems All The Way Down
This brings us full circle to why systems thinking matters.
When you see the world as systems, you notice that every layer of abstraction is itself a system. And that these systems enable new systems to emerge.
The Physical Layer enabled the Network Layer. The Application Layer enabled the AI Layer. Each new layer unlocked possibilities we couldn’t imagine before.
Code becoming cheap activates the Domain Layer.
When the cost of writing code approaches zero, the value shifts entirely to what you encode. Domain knowledge. System relationships. The actual expertise about how things work and interact.
What happens when we can finally focus on domain knowledge instead of fighting with the code?
What new systems emerge when domain expertise becomes the primary constraint, not implementation?
What becomes possible when we can spend our energy understanding the decades of research with what we’re building instead of struggling with how to build?
These aren’t just interesting questions. They’re the questions that define the next era of engineering.
The future belongs to those who embrace thinking in systems - and recognise when a new layer is ready to emerge.
Are you paying attention? Are you ready?
I love this so much. Systems Thinking.
The original title of my book was Network Thinking. It was just too confusing of a title, so we changed it to "Network Science with Python."
So, I will always love this topic and be a fan of anyone who writes about it.
Thank you, thank you, thank you. This is the signal.
Solid framing of how abstraction layers compound. The shift from code scarcity to domain scarcity really does change the optimization target. I've been wrestling with this in my work where suddenly the bottleneck isn't writing functons anymore but articulating exactly what the system should do in edge cases. The systematization of domainknowledge feels inevitable once implementation cost drops low enough.