TL;DR: The era of "defensible software" is over. Nicolas Bustamante reveals that complex business logic, once hard-coded into millions of lines of Python, is now just a Markdown file written by a domain expert. But the destruction goes deeper. We are witnessing the End of the Lindy Effect in code, the death of the "Dependency Tree," and the rise of Hyper-Vertical Monoliths. If you are betting on legacy code or open-source community moats, you are betting on the past.
James here, CEO of Mercury Technology Solutions. Hong Kong - February 18, 2026
I recently read a post by Nicolas Bustamante regarding the sell-off of SaaS stocks. It aligns perfectly with the structural shifts we are seeing in the engineering world right now.
The Thesis: Traditional Vertical SaaS (software for specific industries like Law or Finance) was valuable because it "encoded" how the industry worked. But LLMs have turned that hard-coded logic into a simple Markdown file. Furthermore, the very way we architect software is collapsing from "Distributed Dependency Hell" back to "Bare-Metal Monoliths."
Here is why the software world you know is dissolving.
1. The Markdown Revolution: Logic is No Longer Code
In the old world, building a platform for lawyers (like Doctrine) was incredibly hard. You needed a "Unicorn": A Software Engineer who also understood Litigation. Every time the logic changed, you needed a Product Manager to write a spec, an Engineer to write the if/then branches in Python, a QA team to test it, and a DevOps team to deploy it. Time to Market: Years.
Now, look at Fintool (a financial analysis AI). They needed a tool to perform a DCF (Discounted Cash Flow) valuation. In the old world, this would be thousands of lines of code handling WACC calculations and edge cases.
In the AI world? It is a Markdown file. A Portfolio Manager (not a coder) wrote a text file explaining to the LLM:
- "Here is how you collect data."
- "Here is how you calculate WACC by industry."
The Engineer: Zero. The "Domain Expert" built the product. The Moat: Evaporated.
2. The Return of the Hyper-Vertical Monolith
If business logic is just text, what happens to the underlying infrastructure? For the last 15 years, we have been obsessed with "Don't Reinvent the Wheel." We import thousands of libraries (npm, pip) to do simple things. We built deep, fragile Dependency Trees.
AI kills the Dependency Tree. Why import a massive, bloated library just to use one function, when you can ask an Agent to write that specific function from scratch in 5 seconds?
The Shift:
- Reduced Supply Chains: We are cutting out 3rd party libraries. This reduces the attack surface (no more left-pad incidents).
- Bare Metal Coding: We can now code an entire app from the ground up, optimized for the specific hardware, without relying on bloated abstractions.
- Performance: Smaller binaries, faster boot times.
The "Monolith" is back, not because we are lazy, but because rewriting code is now cheaper than understanding foreign code.
3. The End of the Lindy Effect
The Lindy Effect suggests that the longer something has survived, the longer it will likely continue to survive. In software, this meant "Legacy Code is King." You don't rewrite the banking core because it has worked for 40 years.
AI breaks the Lindy Effect. Chesterton's Fence ("Don't remove a fence until you know why it was put there") is irrelevant when an AI Agent can analyze the fence, understand its purpose, and rebuild a better fence in milliseconds.
- Legacy is not an Asset: It is technical debt.
- Rewrite Everything: We can now rewrite ancient COBOL banking systems into Rust or Go with minimal friction. The "History" of the code no longer protects it.
4. The Rise of "Machine Languages" (Strong Typing)
Historically, we chose languages like Python or JavaScript because they were easy for Humans to read and write. We sacrificed performance and safety for "Developer Ergonomics."
But Humans aren't writing the code anymore. AI Agents don't care about ergonomics. They care about Correctness. This will drive a massive shift toward Strongly Typed, Formally Verifiable languages (like Rust, OCaml, or even new AI-specific languages).
- The Unknown Unknowns: The risk with AI code is that it looks right but contains subtle bugs.
- Formal Verification: We need languages that mathematically prove the code is safe before it runs. AI thrives in these strict environments.
The future isn't Python (easy for humans). The future is Rust (safe for machines).
5. The Death of Open Source "Community"
For decades, Open Source was about Human Connection. We gathered on GitHub to learn, share, and belong. But in a world where code is written by machines and read by machines, the "Community" incentive collapses.
- The New Open Source: It won't be people chatting on Discord. It will be swarms of AI Agents optimizing libraries for other AI Agents.
- The Loss: We lose the mentorship and the human spirit of code.
- The Gain: Ruthless efficiency.
Conclusion: Who Owns the Value?
If a 10-year codebase can be replaced by a 1-week prompt, and the underlying infrastructure can be rewritten overnight by an Agent, the value of "Software" drops to near zero.
The value shifts entirely to "Domain Expertise." The winners of 2026 won't be the best Coders. They will be the best Thinkers. They will be the Lawyers, Doctors, and Engineers who can write the Markdown file that teaches the AI Why, while the AI handles the How using a language you can't even read.
The barrier to entry is gone. The barrier to Excellence is higher than ever.
Mercury Technology Solutions: Accelerate Digitality.
