There is already plenty written about how AI coding assistants can introduce bugs or how misconfigured agent permissions can lead to outages. What is not discussed is the more important question: how do we enable teams to consistently ship quality software and not just more defects?
The AI coding revolution feels like merely an opening act. What’s coming next is bigger, and it’s unfolding at a pace that’s faster than most teams are prepared to handle.
From copilots to agents and everything that changes with it
A year ago, the industry was grappling with the implications of AI-generated code. Engineers were reporting 10% to 20% efficiency gains. At the same time, defect escape rates were rising, and change failure rates were climbing. The velocity was real, but confidence in that velocity was not. We had speed, but not certainty. And yet, speed was the metric most teams continued to optimize for.
I’ve written before that velocity has become practically free. An engineer can now produce in an afternoon what used to take an entire sprint. But faster isn’t always faster if what’s shipped doesn’t work. We’ve made speed abundant, but trust is now the bottleneck. Based on our research, 95% of organizations reported AI-related setbacks. It's clear that most teams are still optimizing for the wrong metric – velocity without confidence.
Now, before we’ve even resolved that challenge, the game has fundamentally changed again.
Frameworks like OpenClaw have ushered in the age of the autonomous AI agent — not just assistants drafting code, but agents making decisions, accessing enterprise systems, acting on behalf of users across real workflows. This advancement is no longer about accelerating output; it’s about delegating control.
Here’s what that means in practice. It is no longer just AI-generated code running in your codebase. It is AI-generated behavior running inside your business.
Three things that are now critical (and mostly unmeasured)
When a human engineer writes code, there is a chain of accountability. Code review. Test coverage. Staging environments. Deployment gates. The process is imperfect, but it exists.
When an AI agent executes a multi-step workflow — pulling from enterprise data, making conditional decisions, triggering downstream actions — that chain largely doesn’t exist yet. Most organizations have not extended their quality and governance frameworks to cover agent behavior. Is sticking with Copilot-era thinking for an agentic-era problem creating a quality tax that stops your teams from delivering results?
Quality, redefined. Quality used to mean: does the software do what the spec said? Functional testing remains the foundation and at scale, it’s still the most reliable way to validate core user journeys and system behavior. But in an agentic world, that foundation needs to evolve.
The bottleneck is no longer just execution—it’s creation and coverage. Teams struggle to keep up with generating, maintaining, and updating test cases fast enough to match the velocity of AI-driven development. When software is being produced at unprecedented speed, traditional approaches to test creation become the limiting factor.
Now, quality means asking yourself: can you continuously validate both what the system does and how it behaves across the full range of real-world scenarios? That requires expanding from functional validation to behavioral validation—testing not just deterministic flows, but decision-making under real-world conditions. It means automating test creation, increasing coverage without increasing effort, and continuously validating outcomes as systems interact with dynamic data and evolving workflows.
In this world, quality is no longer a checkpoint—it’s a continuous, scalable capability that keeps pace with how software is built and how agents operate.
Governance, built in — not bolted on. Many of the most recent software incidents had the same root cause going back to systems with access to consequential enterprise resources, operating without adequate guardrails. AI agents now touch customer records, financial systems, HR data, and proprietary IP. The access control models and audit trails that govern human access to those systems were not designed for autonomous agents acting at machine speed. Governance for the agentic era has to be part of the architecture from day one and not something compliance teams retrofit after a Sev 1.
Accountability, at the organizational level. Our research reveals that 60% of organizations said they hold individual employees accountable for AI-generated errors — not the tools, not the processes, not the leaders who deployed without adequate safeguards. That model is already under strain, and it will not survive the agentic era.
When an autonomous agent is making decisions, accountability cannot rest with whoever happens to be monitoring the dashboard. It must be designed into the system itself—and owned at the organizational level.
That means accountability shifts from individuals to architecture, from reactive blame to intentional design, and from isolated incidents to the decisions that made those outcomes possible in the first place.
Velocity was always the easy part. Confidence is the hard piece
The industry spent two years optimizing for AI-assisted code generation as if velocity were still the constraint. It wasn’t. Understanding requirements, validating behavior, ensuring software actually does what it’s supposed to do — these were always the bottlenecks. AI coding tools didn’t solve them; they exposed them.
Now we’re repeating the mistake at a higher level of abstraction. We’re deploying autonomous agents into enterprise workflows because we can, optimizing for deployment speed, and deferring the question of confidence to later.
The companies that navigate this well won’t necessarily be the ones with the most sophisticated AI. They’ll be the ones who build confidence into their software from the start.
That means extending quality frameworks beyond code to agent behavior—testing not just what agents produce, but how they reason, what they access, and how they perform under real-world conditions. It means validating outcomes continuously, not just at release, and ensuring coverage keeps pace with the speed at which software—and now agents—are created.
It also means removing traditional quality bottlenecks. Test creation, maintenance, and environment fragmentation can no longer slow teams down. Leading organizations will invest in scalable, automated testing approaches that expand coverage without adding friction—so quality can move at the same velocity as development.
Governance, too, becomes infrastructure. The same rigor applied to production systems must extend to agent access controls, observability, and auditability. And with that comes a new class of metrics: not just task completion rates, but behavioral confidence, quality signals across environments, and the ability to trace and explain agent-driven actions after the fact.
The agentic era is not a reason to slow down. The productivity gains are real, the business cases are compelling, and the organizations that figure this out will beat out their competitors. The leaders who will get this right are the ones who understand that confidence is the new infrastructure—not overhead—and that continuous quality is what makes that confidence real at scale.
I’ve spent more than two decades building products at Amazon, Cisco, Twilio, and now Sauce Labs. Every major platform shift I’ve lived through — cloud, mobile, DevOps — created a window of competitive advantage for the organizations that got the underlying infrastructure right while everyone else was chasing the top-line metric. The agentic shift is no different. The top-line metric is agent capability. The infrastructure question is: Do you actually know what your agents are doing?
The question isn’t whether your organization is ready to deploy AI agents. It’s whether you have the confidence to trust what they do. For more insights into how our teams are using agentic AI in software testing, read our full research report.
