The Law of Conservation of Friction

Here is a theory you hear a lot these days from the venture capital echo chamber: AI makes developers one hundred times faster, so software is about to get incredibly cheap. The mandate has been handed down from on high. We are all supposedly just going to type “make me a massively scalable enterprise web app” into a glowing chat box, hit Enter, and retire to the Bahamas on our mad coin, right?

Wrong. (Attention, LinkedIn thought-leaders: put down your viral thread-hooks and shut up for a second.)

Let me introduce you to Mikey. Mikey is a hypothetical junior developer who thinks he can build a reliable, secure banking portal purely by yelling demands into a large language model. For the first two weeks, Mikey looks like an absolute wizard to his non-technical product manager, generating gigabytes of React components without understanding a single underlying hook or lifecycle method. He is closing Jira tickets at the speed of light.

But let us pose the pragmatist’s question: if this workflow is practically magic, why is Mikey's supposedly scalable app suddenly crashing and burning every single time a user from Munich tries to input a surname with an umlaut? And why is Mikey currently weeping at his Herman Miller chair on a Thursday afternoon, desperately typing “please, I beg you, just format the JSON correctly and remember what a UTF-8 character is” into a prompt window for the forty-seventh consecutive time?

Because Mikey is discovering that skipping the hard part of software engineering usually just creates an exponentially worse, completely invisible hard part.

Mikey is what we must now classify as a Prompt Astronaut.

Years ago, the industry was plagued by the Architecture Astronaut. You remember them. They were the galaxy-brains who refused to write functional code because they were too busy drawing sprawling UML diagrams for hyper-abstracted, multi-tiered XML SOAP factories that solved problems nobody actually had. The Prompt Astronauts are their direct, spiritual descendants.

Except, instead of hiding behind endless enterprise design patterns and object-oriented abstractions, the Prompt Astronauts hide behind massive, rambling, hallucinatory text blobs. They have convinced themselves that the process of structuring text in conversational English is a rigorous hard science, entirely masking their fundamental inability to understand the actual silicon and metal executing their wishes. They write four-paragraph essays dictating the exact persona the AI should adopt, believing they are engaging in deep computer science, when in reality they are just cajoling a glorified autocomplete engine. They will spend hours agonizing over whether saying "take a deep breath and think step by step" yields a 4% better routing algorithm. It is voodoo. It is pure, unadulterated superstition masquerading as engineering.

If you think writing a hundred-page English essay to trick a chatbot into avoiding a simple ten-line unit test qualifies as software engineering, you are gravely mistaken. This practice perfectly mirrors the experience of performing open-heart surgery with a spork controlled by an enthusiastic, drunk intern via walkie-talkie.

The intern means incredibly well. They have supposedly memorized every medical textbook on earth. But they are operating entirely on vibes, they have zero object permanence, and occasionally they will confidently declare that the aorta is a type of root vegetable and simply sever it. When the patient starts bleeding out, you can’t just reach in and clamp the artery yourself; you have to get back on the walkie-talkie and politely ask the intern to re-evaluate their systemic approach to human anatomy.

This brings us to a fundamental, immutable rule of software engineering that the industry consistently ignores: The Law of Conservation of Friction.

Software complexity cannot be magically destroyed by a new interface paradigm; it can only be moved around. Building a robust application requires mapping messy, contradictory human requirements into strict, unforgiving boolean logic. Rather than eliminating the friction of managing this business logic, the Prompt Astronauts have simply relocated it from a predictable, highly constrained environment into a totally unpredictable, probabilistic guessing engine.

Let’s actually do the math on this microeconomic disaster. When you strip away the marketing gloss, software development is just an economic loop of making a mistake, finding it, and fixing it.

In a traditional, deterministic software environment, a developer writes a piece of logic and feeds it to a local compiler. Let us draw a mental flowchart of this process:

The Compiler Loop:

1. Write explicitly deterministic code.
2. Hit compile.
3. The compiler instantly throws a syntax error on line 42.
4. The developer fixes the missing semicolon.

Total elapsed time: 0.4 seconds. Cost in electricity: literally $0.00001.

Now contrast this with the supposedly frictionless modern AI-driven utopia:

The LLM Loop:

1. Write a deeply emotional paragraph begging the model to handle user session tokens correctly.
2. Send a bloated $1.50 API call over the wire.
3. Wait fourteen seconds for a stream of markdown.
4. Deploy the code, which works perfectly right up until the model suddenly hallucinates a database endpoint that does not, and has never, existed.
5. Spend three consecutive days tweaking adjectives in the prompt to stop the hallucination.
6. Everything is still broken, and now the model thinks French is a programming language.

Instead of leveraging incredibly cheap, instantaneous machine cycles to catch deterministic errors, you are now paying an engineer two hundred and fifty thousand dollars a year to sit at a desk guessing why an API forgot how databases work. That is a catastrophic misallocation of capital. We have taken the most reliable, pedantic, rule-following machine ever invented by human beings—the microprocessor—and purposefully jammed a layer of unreliable, smooth-talking, pseudo-random garbage right in the middle of it.

Madness.

Relying on conversational AI to generate massive chunks of core infrastructure without actually understanding the output guarantees one thing: you are taking out a massive, unpayable loan against your own codebase. Every time the model spits out a neat-looking regular expression or a bizarre SQL join that you do not personally know how to debug, you are accumulating the implied cost of additional rework.

This debt will inevitably come due. It will happen on a Friday night, precisely when a critical third-party dependency updates, and your undocumented, AI-generated spaghetti-code collapses like a wet paper bag. You won't have a stack trace you can actually trace. You won't have a predictable failure state. You will just have a massive, opaque blob of string operations that suddenly decided it wants to return a null pointer because the ambient temperature in a data center changed. And because you never bothered to learn how the system routes its packets or authenticates its users, you will be utterly powerless to fix it. You will just be standing there, frantically yelling into the walkie-talkie, hoping the drunk intern wakes up.

The fundamental need for deterministic, rigorously engineered software logic hasn't vanished just because the interface got chattier. As Joseph Heck recently pointed out, engineering fundamentals matter more than ever. A conversational interface does not repeal the laws of physics, it does not rewrite the ruthless rules of microeconomics, and it certainly does not forgive a terrible database schema.

Anyway, unless you are literally building a chatbot to amuse bored teenagers, relying on untestable English prose to execute core business logic is the most labor-intensive way possible to pretend you aren’t writing code. Stop it. Just write the damn unit test.