A testing team’s shift to AI-first delivery, and the 4x productivity jump that followed — with a 600% target already in sight.

Engineering Practices · July 2026

Every AI adoption story eventually has to answer one question: did it actually change the work? For one of our API testing teams, the honest starting point was a plateau — steady delivery, but no meaningful movement — and the answer, six months later, is a 4x jump in throughput per person. This is the story of how that happened, what it took beyond simply turning a tool on, and why the approach worked.

Key takeaways

  • API test delivery had plateaued at roughly 5 endpoints and fragments per person, even as coverage demands kept growing.
  • Adopting an AI agent for k6 test development lifted output to roughly 20 per person — a 4x jump, from a 100% baseline to 400% velocity.
  • 600% is the next target, as the agent’s learning compounds with every delivery cycle.
  • AI accelerated onboarding: testers new to k6 ramped up fast and delivered results alongside experienced colleagues — augmenting human capability rather than replacing it.
  • k6’s code-first design is a large part of why this worked: AI-generated tests are plain, reviewable JavaScript, not a proprietary format.

The problem: API test delivery had hit a plateau

Every transformation starts with an honest look in the mirror, and this one started with a number: each team member was delivering around five k6 test endpoints and fragments in a given cycle. Building them by hand was slow — every item required significant manual effort, from scripting through validation.

For colleagues new to k6, the ramp-up made the problem worse. The learning curve was steep enough that new testers took considerable time to reach baseline productivity, let alone match experienced team members.

Meanwhile, coverage demands kept growing in the other direction. Incremental gains — training, better templates, more hires — were not going to close that gap. The team needed a step change in delivery efficiency, not a marginal one.

What is k6, and why it matters here

k6 is an open-source, developer-centric load and performance testing tool, originally built by the startup k6 and acquired by Grafana Labs in 2021. Unlike older enterprise load-testing suites built around record-and-playback interfaces, k6 tests are written as plain JavaScript (or TypeScript) code, executed by a fast, memory-efficient runner (written in Go) that can simulate large numbers of virtual users from a single machine. It supports HTTP, gRPC, and WebSocket protocols, and is commonly used to validate how APIs and services hold up under load before problems reach production.

That code-first design is exactly what makes k6 a strong fit for AI-assisted authoring. Because tests are structured JavaScript rather than a proprietary GUI format, an AI agent can read an API’s schema or documentation and generate a well-formed k6 script or fragment the same way it would generate any other piece of code — and a human reviewer can read, version, and debug that output with the same tools and habits used for any other codebase. This overlap between the tool’s design and the AI agent’s strengths is a meaningful part of why the team’s results were possible at all.

Adopt, embed, evolve: an AI-first way of working

As part of a broader commitment to AI-driven ways of working, the team adopted an AI agent purpose-built for k6 test development. But adopting a tool was the easy part. The real shift was in how the team worked around it, following a deliberate three-stage pattern:

  • Adopt — bring in an AI agent purpose-fit for k6 test development, rather than a general-purpose assistant retrofitted to the task.
  • Embed — integrate the agent into day-to-day delivery as part of the standard workflow, not as a side experiment run by a few enthusiasts.
  • Evolve — let the agent improve from every interaction, so throughput compounds instead of plateauing again.

One of the most rewarding outcomes was how fast onboarding became. Team members with no prior k6 experience used the agent to ramp up quickly and were delivering strong results within their first cycles — output that stood alongside colleagues with far more tenure. AI enhanced human potential here; it didn’t replace it.

Other approaches the team considered

Scaling test delivery is not a problem with only one answer. Before settling on an embedded, purpose-fit AI agent, a few different approaches were on the table, each with different trade-offs:

  • General-purpose coding assistants. Off-the-shelf coding copilots can write k6 scripts too, but they aren’t tuned to the team’s specific service catalogue, naming conventions, or existing fragment library — so every output needs heavier review and rework.
  • No-code / record-and-playback test builders. These lower the entry barrier for non-technical testers but tend to produce brittle, hard-to-maintain tests that don’t hold up well against frequently changing APIs.
  • Auto-generation from OpenAPI/Swagger specs. Promising for coverage of basic CRUD endpoints, but weak on the scenario-specific logic, data setup, and edge cases that make a test genuinely useful.
  • More hiring and training. The traditional lever — but with a steep k6 learning curve, this scales linearly with headcount and time, not exponentially, and was too slow for the coverage growth the team was facing.

The purpose-fit AI agent won out because it combined the coverage benefits of generation with the flexibility of a tool that could be embedded into the team’s actual workflow and improve over time — rather than a one-off script generator or a slower, linear scaling lever.

The results: 4x productivity, and climbing

The team kept the success metric deliberately simple and honest: endpoints and fragments delivered per team member. That number moved from roughly 5 to roughly 20 — a 4x increase in individual output, and a jump from a 100% baseline to 400% velocity.

600% is the next target, as the agent’s learning compounds with every additional delivery cycle. Leadership treated the milestone as more than a productivity metric — it was read as proof that AI-first ways of working produce measurable, repeatable value, and the team has already been handed the baton for the next stage of the journey.

Why this works

A few mechanics sit underneath the 4x number:

  • Code-native tooling meets code-generation strengths. Because k6 tests are plain JavaScript, the agent’s output can be reviewed, versioned, and debugged with the same tools and habits testers already use for any other code — there’s no separate proprietary format to learn.
  • Repetition compounds. Much of the “5 to 20” gap wasn’t creative problem-solving — it was boilerplate: request setup, headers, assertions, data fixtures. That’s exactly the kind of repetitive, pattern-based work AI agents remove, freeing testers to focus on scenario design and edge cases.
  • Embedding beats experimentation. Tools that stay optional get used inconsistently. Making the agent part of the standard delivery workflow — not a side experiment — is what turned early productivity gains into a sustained, team-wide baseline.
  • The feedback loop is real, not simulated. Every generated test is run against real k6 output, so incorrect or broken scripts surface immediately rather than persisting silently — reducing the risk of AI-generated code quietly degrading quality.
  • Learning compounds. As the agent sees more of the team’s endpoints, conventions, and fixes, its suggestions get closer to what a senior tester would write — which is the basis for the team’s 600% target.

What this means going forward

This story lines up with what came out of the FY27 Leadership Fireside Chat: the organizations that win are the ones that connect business outcomes, technology, and human capability — not the ones that treat AI adoption as a technology project running in isolation.

The 4x milestone isn’t the finish line. It’s the new baseline for what comes next.

As the agent continues learning from every interaction, the target is 600% and beyond — and the same adopt-embed-evolve pattern is now shaping how other delivery teams approach AI-first ways of working. If you’re exploring how AI agents can compress delivery timelines in your own testing or QA practice, Exaze’s engineering team can help you design that path.