The warning comes from an unlikely source: two engineers who helped build one of the most popular AI coding tools in the world. In interviews published this week, they said artificial intelligence is producing enormous volumes of code that looks fine and works badly — software that runs, passes tests and ships, while its underlying architecture accumulates flaws that will surface later, in production, at scale. The tools are not the problem, they said. The way developers use them is.
The engineers drew a careful line. AI is genuinely helpful for simple programming tasks, they said — writing a function, formatting data, explaining an unfamiliar library. The danger begins when developers treat AI as a substitute for understanding. A pattern is spreading, they warned: engineers type vague, sloppy prompts, accept whatever code the model produces, and publish it without serious review. The code passes the immediate test, the feature works, and nobody looks underneath.
What is underneath, according to the warning, is often a mess. AI-generated code tends to be structurally shallow — it solves the visible problem without respecting the architecture around it, duplicating logic that should be shared, ignoring edge cases that the tests do not cover and accumulating technical debt with every commit. Individually, each flaw is minor. Collectively, they produce systems that are fragile, expensive to maintain and dangerous to operate.
The warning comes with a distinctive twist: the cost of bad AI code is not just bugs, but compute. Inefficient code — the kind that repeats work, wastes memory and makes unnecessary calls — burns tokens and server time. For companies running AI systems at scale, that inefficiency translates directly into cloud bills. The engineers described a crisis in the making: as AI writes more of the software stack, the software stack becomes more expensive to run, and the costs compound as the bad code is itself fed back into AI tools that learn from it.
The irony has not been lost on the developers reading the interviews. OpenClaw is an AI coding agent — a tool whose entire purpose is to generate code at the direction of a human. Its own builders are now saying that the most important skill for working with such tools is skepticism. The message is less a rejection of the technology than a demand for discipline: review everything, test everything, and never assume that because a model produced it, it is correct.
The warning echoes a growing body of evidence. Studies of AI-assisted development have repeatedly found that generated code contains security vulnerabilities at higher rates than human-written code, and that developers are often overconfident about its quality. Surveys of engineering teams report rising maintenance burdens as AI-generated contributions accumulate. The industry has spent two years celebrating how much faster code can be written; the harder conversation is about how much more carefully it must be reviewed.
The stakes are highest in infrastructure. Software that runs financial systems, medical devices, power grids and aircraft has traditionally been built under regimes of testing and review that assume human fallibility. AI-generated code introduces a new failure mode: it can be confidently, fluently wrong in ways that human reviewers, especially rushed ones, may not catch. The engineers’ warning suggests that the industry is not yet treating this risk with the seriousness it deserves.
Enterprise technology leaders have begun to respond. Companies adopting AI coding tools are adding guardrails — mandatory review policies, automated security scanning, limits on where AI-generated code can be deployed without human sign-off. The message from the OpenClaw engineers is that such policies are not bureaucracy but necessity: the tools have changed how code gets written, so the process around the code must change with it.
The warning arrives as the industry bets billions on the opposite assumption. The largest software companies are embedding AI coding into their products, teaching new developers to treat agents as the default, and measuring productivity in lines produced per day. The engineers are not calling for a halt; they are calling for a culture change — build the review discipline now, before bad code is baked into systems too large to unwind. They note that the pattern is already visible in their own industry: software written fast, reviewed lightly and deployed everywhere, with the consequences arriving months later in outages, security incidents and compute bills.
For the engineers themselves, the warning is also a plea for craftsmanship. The best developers have always understood that code is read more often than it is written, and that the value of software lives in its structure as much as its behavior. AI can write the words; only humans can own the meaning. The tools will keep improving, the models will keep generating, and the code will keep flowing — but someone has to be responsible for it. The engineers’ point is simple: that someone is still you.
