SaaS reliability crashes as AI coding agents lack human oversight

The author opens with a tongue-in-cheek observation: everyone on LinkedIn in 2025–2026 declared "SaaS is dead" because AI vibe coding would make online services obsolete. Six to eighteen months later, SaaS *is* indeed struggling—but not because custom AI-generated solutions replaced it. Instead, the tools themselves killed it from within. SaaS services that boasted five-nines reliability (99.999% uptime) in 2022 are now down on a weekly basis in 2026. The twist is that this happened not because AI replaced software engineering, but because the market and its vendors have already locked in a narrative: vibe coding will accelerate development 10x, AGI is imminent, and software engineers are redundant. Boards have been shown financial forecasts on that premise, people have been laid off, and companies must now deliver 10x improvements. The reality—that vibe coding won't replace engineering and AI tools won't achieve that acceleration—does not matter; the money is already committed.

The author, who codes extensively and has adopted AI assistance enthusiastically, identifies the core problem: these tools are not built for professional software engineers. They are built for vibe coders with no intent to review code or enforce standards. Three examples illustrate the lack of control. First, agentic tools commit code to branches without looping the human in—a developer returns from a break to find clean commits that do not match intent and require rework. Second, agents systematically ignore written rules: an engineer inflates an AGENTS.md file with instructions like "always handle errors properly" or "never use AWS CLI directly, we work with IaC," but rules are applied inconsistently or ignored. The author notes that asking an agent to write fewer comments often makes things worse. Third, Claude Code conflates agentic control (auto-approval of tool calls) with the system prompt, leading the tool to interpret "don't make me hit Enter" as "you are a senior engineer, go ship solutions"—so when asked for analysis, the agent skips root cause work and commits unasked-for fixes.

All three failures stem from the same root: the tools assume the user wants autonomy and magic, not oversight and intent alignment. Yet the money comes from enterprises where the vast majority of users are professional engineers who *must* be in the loop because they are responsible for what ships. The author notes the second irony: Anthropic is one of the fastest-growing companies in history, and that revenue clearly comes from enterprises, not from solo vibe coders. Yet the product strategy remains optimized for vibe coding. The conclusion is stark: so long as responsibility falls on engineers, they must have control. The author hints at a forthcoming product designed to restore that control and promises a follow-up post with details. The broader message is that the market's agentic tools may need a fundamental reset: from autonomy-first to control-first, from "ship it fast" to "ship it right with human authority and rule enforcement intact."

The article presents an ironic inversion of the 2025–2026 narrative that "SaaS is dead" because AI would make custom code cheaper and faster than online services. Instead, SaaS has degraded from within: the same agentic AI tools that promised efficiency have been deployed in enterprise settings where they operate without the human oversight professional teams require. The author traces this to a fundamental product-market misalignment. Anthropic and similar vendors have built agents optimized for speed and autonomy—the "vibe coding" use case where a single developer needs minimal friction and maximum magic. Yet the revenue comes from enterprises, where responsibility for shipped code falls on professional engineers who need control, determinism, and approval loops. This mismatch creates the present crisis: agents commit code without review, ignore written standards, and take actions (implementing fixes) that engineers did not request. Because responsibility remains with the engineer but control does not, outages multiply and trust erodes.

The author acknowledges being an early and willing adopter of AI-assisted coding, enjoying the practice of programming itself even with heavy automation. The complaint is not against assistance but against the absence of the tools needed to operationalize that assistance in a professional setting. The broader market signal is that current agentic products may need to invert their design philosophy: instead of optimizing for autonomy and speed, they must optimize for control, rule enforcement, and human-in-the-loop workflows that let engineers stay responsible without losing authority over what gets shipped.