The Paradoxes of AI-first and Everything-LLM

Logic vs Implementation

The main observation I want to make is based on the idea of conservation of complexity: there are fundamental limits to how we can organize the logic of our design before we hit a limit. We can move complexity to other subsystems but we can't eliminate it, this is true irrespective of the technology we use. The problem and its constraints demand e certain set of logical steps and state transitions. As long as we talk about AI though, we're looking at our system from the perspective of implementation rather than logic, and, for the most part, we can only hope to bring small improvements over time, directly related to the performance increase of the latest software releases. The logical layer is where major improvements can be made. The idea of "spec driven development" seems to align with this premise, AI is used mainly to write the implementation of a design.

I'd like to clarify that I'm implicitly making reference to medium/large scale engineering endeavors that we can generallly call "complex". Clearly AI can have a role in engineering, but writing a single function or writing a complex software for mission critical applications with many overlapping constraints are vastly different situations.

From a technological perspective AI is a novelty, from the logical one, hardly so. Essentially we're still doing the same things we did a decade or more ago, just a little faster and for the most part, we're working with the same (or very similar) technologies. I would challenge the idea that a tool, even AI, represents a novel logic that fundamentally changes how we think about engineering. In this sense, AI does little to "solve" design challenges.

The point is not being anti AI, but it's incorrect to point at the tool when the limit is the logic.

There is a small selection of tasks where AI unlocks new possibilities. Its value comes when the problem itself is fuzzy, ambiguous, or expensive to encode with rules. But even in those cases, AI is just one unit of a complex machine. As soon as we venture outside the implementation of the individual building block, we're again faced with the same issues I've pointed at above, we're still bound to logical limits, we still need to understand state transitions and failure modes and design accordingly. If nothing else AI exacerbates these problems. As of today, AI hasn't really impacted the logic of design, not yet, and the limitation is not technological and cannot easily be eliminated.

Conservation of Complexity

It's tempting to replace every component of our system with an LLM call via an MCP server or an AI equivalent, but that turns a local microsecond operation into a blocking network request. You are burning through compute and tokens, increasing security concerns, multiplying your API costs and exposing yourself to novel failure modes. These issues have become common talking points these days.

Prototyping with AI can feel like a breeze, no logic to program into your software, just let AI make the decision. That approach may work in development, but production systems are require more checks and guarantees. On the way towards implementing reliability and performance guarantees, constraints become more apparent and the trade-offs begin to accumulate. At that point the idea that AI isn't bringing those magical advantages starts to seep in.

It's a good result to solve engineering problems keeping complexity low. But Now that we have a central AI component, we must fine-tune it, perhaps generate datasets of features and versioned training datasets for evals, keep track of metrics, then there's authorization and observability and the list goes on. All these systems are built on a foundation of traditional engineering. Most of the heavy lifting is actually standard code and API calls designed to mitigate LLM randomness, measure performance, and keep the system running.

Conclusion

AI was supposed to simplify things. I'm arguing that accounting for errors, supervision, verification and model improvement, it often doesn't make things better, and that's not for superficial reasons that can be easily dismissed. The AI fever is leading us to paradoxes and architectural monstrosities. We may be persuaded by the fact that the initial design steps are simplified by replacing the costs of implementing logic with a fuzzy LLM system, but the conservation of complexity is soon going to bite back, forcing you to resort to compensatory systems that often add more burdens rather than solving problems.