IO8

Over the past few years, large language models have transformed the way software gets built. The most advanced models can perform meaningful code reviews, generate substantial portions of a codebase, and answer complex technical questions in seconds. It's now realistic to build AI-driven ecosystems that automate entire workflows from end to end. For any business that wants to stay competitive, adopting these tools is no longer optional. Companies that don't, are at real risk of falling behind. This is a genuine shift in how software gets built, and its impact is not in question.

Speed Has a Price

What is in question is how that speed gets used. As development has accelerated, market expectations have accelerated with it. Clients and stakeholders have adjusted to the new pace, and now expect shorter deadlines at lower cost. That shift puts real pressure on software development teams, and that pressure has consequences. Keeping quality, cost, and speed in balance at the same time is difficult. Across a range of projects, we've consistently seen the same pattern: when push comes to shove, deadlines and feature lists win out over quality.

Why Quality Slips

In our experience, the problem comes from a combination of factors:

• 1. Market-driven time pressure. Businesses that fail to ship as fast as their competitors risk losing the race entirely, and that pressure filters directly down to development teams.
• 2. Fast-growing codebases. AI coding agents make it easy to generate large volumes of code very quickly. But larger codebases require proportionally more effort to review and verify, whether that verification is done by people or by AI.
• 3. Overtrust in agentic coding. Agentic coding has become widely adopted, and for good reason, but automating part of the workflow can also quietly hide mistakes. We've seen projects with test coverage close to 90% that still had serious issues surface only after going live. In these cases, teams placed too much trust in the agent's output and skipped the deep functional analysis that should have followed.
• 4. Insufficient verification and validation. High test coverage is not the same as correct software. When cost and time pressure are high, developers are often left with little choice but to move faster than they should, and the steps that require real time are the ones that get cut. Thorough code review, which demands carefully thinking through edge cases, gets rushed. Building proper test coverage manually is time-consuming, so tests are increasingly AI-generated, which isn't a problem on its own, but becomes one when those generated tests are never reviewed, allowing broken functionality to slip through unnoticed.
• 5. AI agents can't solve everything on their own. Some problems still require a developer to step in with a solution the agent can't produce independently.

A Familiar Scenario

Consider a team building a video editing application. A developer writes a thorough specification and hands it to an AI agent, along with a request to implement the feature and cover it with unit and integration tests. A few hours later, the software is generated, with test coverage above 90%.

Does it actually work as intended? Does it deliver the right functionality? Is it scalable? Is it maintainable? Is it cost-efficient? And what happens if the original specification was incomplete, or ambiguous in places?

In practice, generated functionality often covers only part of the real requirements, yet it's not uncommon for that code to be shipped without further manual testing or deeper review. The result: a feature that looks great in a demo and breaks down under real production conditions.

Why It Matters

Skipping validation and cutting corners on quality can put a business at real risk. Trust is hard to earn and easy to lose. A competitor may well ship faster than you, but if their product is unreliable, that speed won't win the long game. In our experience, patience and quality consistently outperform speed and bugs.

Our Recommendations

• Don't skip manual verification and validation. These phases exist for a reason. Protect them, even under pressure.
• Prioritize quality over deadlines. If you notice quality slipping, slow down. Do not deploy any functionality just because a deadline is close and pressure is high. Delivering poor-quality features can have a severe impact on your business, causing you to lose the trust of your clients.
• Use agentic coding with caution. We're strong believers in the productivity it enables, particularly for prototyping. Treat AI-generated code destined for production with the same standards as any other code.
• Work in shorter iterations. It's far easier to catch bugs in small, well-scoped pieces of functionality than in large ones.

AI is a genuinely powerful technology, and it's here to stay. Used thoughtfully, with the right guardrails around verification and validation, it's one of the most valuable tools a development team can have. Used carelessly, it can quietly undermine the very quality it was meant to help you deliver faster.