Every builder starts with an idea. They get together and start designing their architecture on a whiteboard. They draw initial abstractions, unlabelled connections, and write partial explanations of components. They see their diagram as 'good enough' to build, and start developing it without reviewing the whiteboard. In that scenario, architecture is treated like a throwaway artefact, left to die. This version of architecture is dead.

Static diagrams, big upfront design or no design at all, documentation as an output, and architects as gatekeepers. These are all symptoms of old architecture. They do not keep up with the world's pace, especially with AI.

We don't see architecture as an end goal. It's something built on iteratively and always evolving.

Long live architecture.

The new version of architecture is:

Architecture is not about creating one-time documentation. It's a collaborative practice where architects and product builders review design decisions and build on them. To get there, we define a simple set of principles.

Our premise is that architecture is the structure of dynamic systems. Relying on static diagrams only gives you a snapshot in time, and who knows when that snapshot was taken. That's why we design for movement. Architecture is not about getting it right up front. It's about making progress, adapting to new learnings, and evolving through use, not speculation. Like UI and product design, architecture should adapt to new requirements and real-world use.

Designs are meant to be examined and revised, which is why a visual model built for change can follow you through that process. Businesses need architecture to solve what matters right now (not even tomorrow). It evolves as we learn and isn't a waterfall approach.

Modern architecture should be communicated to and accessible by its audience: product, design, engineering, and increasingly, AI agents. It only matters if it's understood, which requires different views for different audiences. Humans reason through diagrams. AI reasons through the model and code. Gatekeeping doesn't work here. Shared understanding beats perfect documentation. Architects, product managers, designers, and software engineers are all product builders. Designs need to serve product builders.

We believe in collaboration. Architecture is not owned by architects. It is a shared responsibility across all teams. Architecture should be a collaborative space for design and decision-making. We model from the ground up, generate views for different use cases, and create contextualised diagrams when needed. Even if collaboration takes time and effort, it's an upfront investment that makes architecture a reflection of reality, not a lag behind it.

The best architecture comes from aligned teams, not isolated silos. These principles describe what we believe. The IcePanel Loop is how we put them into practice.

Start by identifying what you want to build and why. Before implementing a solution or designing any architecture, understand the surrounding business context, technical constraints, and clarify the problem you're solving. The goal is to answer the question: "What does this system need to do, and for whom?"

Modelling intent is a strong starting point. It makes the "why" crystal clear to everyone, so every decision that follows can be traced back to it.

Take the intent you've modelled and represent it in a way that others can see and question. Visualising the system answers two key questions: how does it work today, how did it work before?

This isn't about generating pretty diagrams. It's about surfacing the current state of the system and presenting the required context for teams to make decisions about the future. Use a tool that's flexible enough to speak to every audience.

Share the model with stakeholders. Engineers, product managers, leadership, and agents, should all be looking at the same system. Validating the model is about answering: how should it work, how does it work, and how could it work? The goal is to build alignment, create shared understanding, ideate, and make deliberate decisions.

Adaptation is about figuring out how the new model will work. Requirements always change, so we'll need to update the model to reflect reality, record what was decided and why, then loop back to intent. You don't want to be drowning in manual work, so aim to find solutions that don't get in the way and are there when you need them.

Every iteration of these four steps improves the overall architecture. This loop closes the gap between intent and reality. If we're not collectively incorporating architectural decisions, we're just wishful thinkers.

AI is not replacing human architects. The internet thinks that software engineers are no longer needed, yet companies (especially startups) are hiring them aggressively.

AI redefines the role but doesn't change the need.

Going back to our main premise: AI is changing how we design and build software. The role of the architect is evolving from someone who writes every design document to someone who manages and guides what AI produces. AI can drastically speed us up, but if used incorrectly or without a strong understanding, the pain can compound fast.

AI is great at generating code, diagrams, and infrastructure templates. The architect has to make sure the systems being generated actually make sense together in practice and at scale. The skill of architecture translating context up and down layers in the organization will be more important than ever.

The future of architecture is less one sided. Instead, we see both automation and humans being part of the loop. Automated systems using LLMs to feed in information on how things work into a source of truth (e.g. cloud providers, telemetry tooling, code, etc.), with humans monitoring and communicating how things work from their perspective.

Software architecture is here to stay, with or without AI. Every day, new systems are designed and deployed, and there will always be a need to review and evolve them. Without architecture, it becomes nearly impossible for the teams and businesses that depend on these systems.

AI is changing our roles as architects. We don't know exactly what the future looks like. Nobody does. But one thing is clear: As systems become faster to build, they become harder to maintain. Shared responsibility fixes it, rooted in the four principles we covered.

Architecture is no longer about controlling complexity upfront. It's about reviewing and refining continuously, just like a loop. That's the IcePanel Loop.

Our method might sound familiar. It is inspired by many thought leaders in software architecture. There are many to mention… but here are a few: