The System Is the Thing

I didn't set out to become a systems thinker. For a long time, I wouldn't have used the term at all. I started in architecture, then moved through design, software, startups, generative work, physical computing, and eventually AI. Those look like different disciplines. I don't think they are anymore.

The tools changed. The thing I was looking for didn't. I wanted to know how the parts connected: not just what something did, but what happened before it, what happened after it, what depended on it, what broke when it changed. And usually, at some point, I wanted to build it.

It took me a while to realize that the common thread wasn't technology. It was systems.

A room is never just a room

Architecture probably started this. You learn quickly that you cannot really design a room in isolation. Move a wall and circulation changes. Move a window and the light changes. Change the material and acoustics change. Change the structure and something somewhere else has to carry the load.

The drawing might show individual objects. The building doesn't experience them individually. It experiences the relationships between them.

That way of looking at things stayed with me long after I stopped working in architecture. I see it in software now. And increasingly, I see it in AI.

The model isn't the system

A lot of AI discussion still revolves around models. Which model is smartest? Which one has the largest context window? Which one won the benchmark? Which one can reason better? Useful questions, but they are component questions.

A model sitting by itself doesn't do much. Give it context and things change. Give it retrieval and things change again. Give it tools, memory, APIs, sensors, databases, interfaces, permissions, and the ability to take actions, and you have something very different. The model didn't necessarily become smarter. The system did.

That distinction matters. The question stops being Which model should I use? It becomes What should the system around the model look like?

Where does the intelligence go?

I've been thinking about this a lot through retrieval. Traditional RAG makes an important decision very early: documents get divided into chunks before anybody knows what a user is going to ask. That decision makes sense operationally. Do the expensive work once, make query time fast.

But it creates a strange situation. The system makes one of its most consequential decisions at the moment when it has the least information. Then the query arrives, and now the system finally knows what the person wants. Too late.

That sent me down a long path through chunking strategies, retrieval architectures, and query-time intelligence. Eventually I became less interested in chunking than in the larger question underneath it: at what point in a system should intelligence make the decision? That question travels surprisingly well.

The behavior lives between the parts

The Autonomous FarmBot started with a deliberately simple question: could an AI grow a plant? It had a Raspberry Pi, camera, soil-moisture sensor, light sensor, water pump, and grow light. There was an LLM in the loop, but the LLM wasn't really the experiment. The loop was.

The system sensed the environment, interpreted what it saw, made a decision, changed the environment, then sensed it again: sense, interpret, decide, act, observe, repeat. No individual part could grow the plant. The moisture sensor couldn't. The camera couldn't. The pump couldn't. The language model couldn't. Connect them and something new appears: behavior.

The same instinct shows up across my other projects, just dressed differently each time. MCP Investment Mentors: different investment philosophies as separate reasoning lenses inside one system. Local Frontier: the cloud stops being a required layer. What If? Magazine: research, generation, constraints, and judgment running as one editorial pipeline. Studio OS: the full path from an idea to a finished artifact, behaving like one environment.

Different projects. Same instinct. I keep wanting to know what happens between the parts.

AI changes the number of parts we can connect

This is where AI gets interesting for systems thinkers. The obvious story is that AI makes individual tasks easier: write this, summarize that, generate an image, analyze this document, write some code. Those capabilities are useful, but I think they obscure the larger change.

AI is becoming connective tissue. Language can become structured data. An image can become an observation. A document can become context. A sentence can become a software action. An API can become a tool an agent decides to use. Unstructured information that previously required a person to interpret it can now move through software.

That changes the kinds of systems one person can build. Five years ago, connecting some of these pieces required a team. Now I can sit down with a question and have a rough system running by the end of the night. Most of it will be wrong. That's useful. There is something to learn from.

Building is part of the thinking

This is why I have trouble separating research from prototyping. Reading tells me what a technology is supposed to do. Building tells me what it actually does. The difference is usually where the real work starts.

A retrieval technique looks elegant until the wrong query arrives. An agent architecture looks convincing until the agent gets stuck calling the same tool. A local model looks capable until memory pressure changes the experience. A plant-care system looks autonomous until a moisture sensor gives you a ridiculous reading at two in the morning. Reality is very good at finding the assumptions in a diagram.

So I build the smallest honest version I can. Not a mockup. Something real enough to fail. Then I watch where it fails. That failure usually tells me more about the system than another week of reading would have. Research, prototype, understand, then do it again.

AI makes judgment more important, not less

There is an assumption underneath a lot of AI tooling that better models will eventually remove the need to think carefully about systems. I suspect the opposite. As individual components become more capable, architecture matters more.

If every model can generate competent text, the interesting question isn't whether the text can be generated. It's what information the model received, why it received it, what it was allowed to do, what happens when it is wrong, whether another system checks it, whether a person should make the final decision, whether the task needed an LLM in the first place.

These are judgment calls. AI doesn't eliminate them. It creates more of them.

Intelligence is a design material

I used to think about systems in terms of familiar materials: interfaces, data, logic, networks, hardware, people. AI adds something unusual to that list. Intelligence. Not the science-fiction kind. The practical kind: interpretation, classification, generation, planning, tool selection, pattern recognition, reasoning over information that doesn't fit neatly into a database column.

Those capabilities can now be placed inside a system almost like another design material, which raises a new architectural question: where should the intelligence go? Sometimes the answer is everywhere. Usually it isn't. A deterministic rule is better when the rule is known. A database is better when the answer already exists. A calculator is better at arithmetic. A human is better when accountability and judgment matter.

The interesting systems aren't the ones with the most AI. They're the ones that put AI where ambiguity actually exists.

Systems thinking in the age of AI

Maybe this is what being a systems thinker means now. Don't start with the model. Start with the system. Understand what enters it. Understand what leaves it. Find the decisions, the dependencies, the feedback loops. Look for the places where information gets lost.

Decide which things should be deterministic and which genuinely benefit from intelligence. Build something small enough that you can see the whole thing. Then put it into contact with reality.

AI gives us remarkably capable parts. That doesn't mean the parts know how to fit together. Someone still has to decide that. And increasingly, I think that's the work.