Cutting Through the Hype  

Generative AI has ignited software development with its speed and creativity. It accelerates prototypes, unblocks logic problems, and inspires new features. But let’s ground that excitement in software engineering reality.  

AI pioneer Andrej Karpathy recently framed this problem as the ‘March of Nines.’ He makes a simple point: getting an AI model to work 90% of the time is easy. That’s the “first nine”—the demo phase. But enterprise software doesn’t run on one nine. It needs 99.9% (three nines) or 99.99% reliability.  

The math is brutal. Moving from 90% to 99% takes as much work as the first 90%. In a startup, 90% is a beta. In an enterprise, it’s a broken product. That missing 10% isn’t a margin of error; it is the difference between a tool and a liability.  

Guessing vs. Calculating

To understand why AI isn’t a silver bullet, we have to look at the fundamentals.  

Generative AI is probabilistic. It guesses. It predicts the next likely word based on patterns. It is “fuzzy.” Enterprise Software is deterministic. It calculates. Input A must always result in Output B. You cannot have “likely” correct financial reports or access controls. They are either right or wrong.  

When you inject raw AI code into a complex enterprise stack—governed by DORA, GDPR, and HIPAA—you are introducing a lottery ticket into a system that demands certainty. “Try and see” is not a strategy when you are handling patient data or bank transactions.  

Low-Code as the Chassis

The future isn’t AI or stability. It is about the architecture that combines them.  

This is where low-code platforms like Mendix stop being just productivity tools and become Architectural Guardrails. Think of AI as the high-speed engine, and Low-Code as the chassis, steering, and braking system.  

This approach solves the complexity problem on two fronts:  

1. Abstraction: Developers shouldn’t need a PhD to build AI apps. Low-code abstracts the plumbing. You don’t wrestle with vector databases or complex API integrations; you use standardized, drag-and-drop connectors.  
2. Governance: Instead of asking AI to write raw code (which is hard to debug), you use AI to configure standardized, pre-tested modules. The platform enforces security. If AI suggests a risky data pattern, the platform constraints prevent it from being deployed. 

Visual Development: From Black Box to Glass Box  

There is a second risk to AI-generated code: Obscurity. If an AI generates a script that only one expert engineer can decipher, you have created a silo. You have excluded the business stakeholders who actually understand the domain.  

We need to “Shift Left”—agreeing on the plan before we write the code. Before building, AI agents help stakeholders draft and visualize clear requirements. This ensures the “blueprint” is agreed upon by humans before AI generates the logic. Low code models take it a step further by visualizing the logic.  

It turns the “Black Box” of AI generation into a “Glass Box.”  

• Alignment: Business experts and architects can look at the visual model and verify the logic. 
• Control: When AI accelerates a workflow, the visual nature of the platform ensures the human remains the pilot. You understand why the system works, not just that it currently runs.  

The Bottom Line

Karpathy is right: production-grade AI is coming. But we aren’t there yet.  

Enterprises should stop asking how fast AI can write code, and start asking: What architecture allows us to run AI safely? The answer lies in combining the engine of AI with the chassis of Low-Code. We get the speed, but we keep the control.