System Architecture in the Age of AI Coding

TL;DR: AI makes it easy to generate code, but much harder to manage complex systems. ICS’ node-based architecture enforces clear boundaries, contracts and message flows, ensuring AI-built systems stay reliable, secure and understandable.

AI coding is everywhere, and for good reason. I use it to build internal tools and data pipelines. My daughter leans on it for her molecular biology research. She’s thrilled she doesn’t have to become a programmer along the way! Meanwhile, software engineers are spinning up entire services in minutes.

With AI, the cost of producing code has shrunk and shifted the bottleneck. For projects where writing the code was the bulk of the work, the gains are dramatic. But many of today’s problems aren’t isolated applications, they’re systems. And those systems are increasingly complex. For instance, medical devices that coordinate with cloud services, electronic health records and embedded microcontrollers, all operating together.

In that environment, speed can be deceptive. When code is easy to produce, it’s also easy to accumulate. The challenge becomes less about writing functionality and more about understanding how pieces interact, how changes ripple and where assumptions quietly break down. 

A message to or from a device isn’t just data. It’s a chain of trust, transformations and dependencies that must hold together under real conditions. How do you know a message from the device is validated before it is recorded in the medical record? What happens when one component changes? To build a coherent system, you need to understand at both a conceptual and a very detailed level what the software is doing.

AI can accelerate the construction, but it also raises the bar for how well we understand what we’ve built.

An Old Answer to a New Problem

System architecture isn’t new, but AI coding puts it at center stage. In the past, keeping architecture functioning and relevant after implementation began was expensive, and defining strict contracts, state machines and boundaries meant a lot of tedious work on top of already tedious coding. 

Now, when you clearly define how a system should behave and where its boundaries are, AI can generate the structure — the schemas, contracts and state definitions — making solid architecture accessible to even small project teams.

Node-Based Architecture

At ICS, we have developed a node-based architecture that builds complex systems by configuring and connecting small, self-contained nodes, each with a single job. The architecture's real work is defining the edges — the rules governing how the nodes communicate with each other. 

The architecture provides:

Actual boundaries, not suggestions. Each node is allowed to send and receive specific messages. Everything else is rejected.

Explicit logic paths. The state machine engine governs what the system can do and when. If a proposed action isn't explicitly permitted — whether it’s out of sequence, missing required context or simply undefined — it's blocked.

Everything needed to generate code. Because the boundaries and behavior are defined structurally, you can regenerate a piece of code at any time without affecting the rest of the system.

The architecture is the framework that enforces these rules. For each system, you identify the components and define the contracts — the boundaries, logic paths and permissions — that govern how they interact. To test this approach, we used this architecture to build a system to track customer hardware. 

Here’s what that looks like:

Equipment can enter the system two ways, either registered formally by IT or reported provisionally by a remote engineer. Both paths need to end up in the same place with the right permissions. 

Each node is configured to receive and send very specific messages. The rules about who can do what, in what order and through which paths are configured and enforced by the architecture. That's what makes the whole thing coherent. 

System Architecture is Now Infrastructure, Not Overhead

System architecture has historically been the thing that senior architects insist on and everyone else routes around because it doesn't seem to help them ship. Now that AI coding is pervasive, system architecture should be seen as infrastructure, not overhead. 

When architecture is built into the system, it pays for itself:

• You can reconfigure and regenerate a component without breaking other parts of the system. 

• The contract is the spec. It defines what the node does, what to test and what the system enforces. They can't drift apart because they're the same thing.

• Security is handled by the framework, not coded into each service.

• A new team member can get up to speed quickly by reading the configuration.

• When something goes wrong, you know where to look. The architecture tells you which node violated the protocol so you don’t have to trace through the codebase

In this model, the engineer focuses on the topology — who talks to whom, what they say, how they respond. The framework handles the rest. 

AI and Architecture are Meant for Each Other

Until recently, architecture was aspirational. It was expensive to define and impossible to maintain. Only architects saw its value. AI solved the first problem and creation of a framework that enforces the architecture solved the second. As a result, now everyone sees the value.

Architecture and AI belong together. We can move at AI speed and still understand what we've built – and that’s the real breakthrough.

If you’d like to learn more about ICS’ node-based architecture, get in touch.