Coding 10x faster with AI: the new calculus of agentic development

When velocity changes the rules of the game

A team of experienced engineers within Amazon Bedrock produces code at 10 times the rate of a typical team. This is not a theoretical projection, it is a measured result over several months. The approach relies on agentic development: each engineer collaborates with an AI agent (Amazon Q, Kiro) to produce code, while remaining responsible for every committed line. This experience, shared by Joe Magerramov, a principal engineer at AWS, reveals that raw velocity is not enough. The entire development ecosystem must evolve in parallel.

Agentic development is not vibe coding

The distinction is fundamental. Vibe coding means letting AI generate code without rigorous supervision. Agentic development is a structured collaboration. The engineer breaks down the task until they have complete clarity, formulates a precise prompt, reviews the agent’s output, iterates until fully satisfied and sometimes takes over to finish manually.

In this team, roughly 80% of committed code is written by the AI agent. But every commit carries an engineer’s name who takes responsibility for it. Steering rules define the constraints within which the agent operates. Choosing Rust as the primary language reinforces this approach: the Rust compiler catches many problems at compile time and provides explicit error messages that help the agent self-correct.

Driving at 200mph requires more downforce

The automotive metaphor is apt. A typical team produces occasional bugs that slip through testing. At normal velocity, this translates to one or two production incidents per year. At 10x velocity, the same per-commit bug probability generates a weekly incident. Even if most bugs are caught in test environments, they impact the shared codebase and slow down the rest of the team.

The conclusion is mathematical: for agentic development to increase velocity by an order of magnitude, the probability of problematic commits must decrease by an order of magnitude too. And likely more, since at high velocity individual commits begin interacting with each other in unexpected ways.

Rethinking tests: the software wind tunnel

The aviation industry tests aircraft at every stage: simulations, component tests, wind tunnel, stress tests, test flights. Software development can draw from this rigor. The “wind tunnel” test idea consists of assembling the complete system locally with high-fidelity fakes of external dependencies, then running end-to-end tests against this replica.

This approach existed in theory but was too expensive to implement and maintain. Agentic development changes this calculus. AI agents excel at producing large volumes of code when expected behavior is well defined. Implementing and maintaining fakes of external dependencies, once a multi-week investment, now takes just a few days.

The Amazon Bedrock team maintains fake implementations of authentication, storage, chain replication and the inference engine. A test harness assembles the complete distributed system on the developer’s machine. Build-time tests run canaries against this locally assembled stack. This approach catches a category of bugs that previously could only be detected in shared test environments.

CI/CD pipelines an order of magnitude faster

A typical CI/CD pipeline takes several hours to build, package and test changes, then a few days to progressively deploy to production. At normal velocity, this is acceptable. At 10x velocity, during the build time of one set of commits, a dozen more are waiting. When a change reaches production, it may contain 100 commits. If one of them causes a problem, the rollback blocks the entire pipeline.

This is comparable to the yellow flag in Formula 1. A track incident forces all cars to slow down behind the safety car. To minimize these slowdowns, organizers prepare teams capable of clearing the track in minutes. Similarly, problems in a high-velocity pipeline must be identified, isolated and reverted in minutes rather than hours.

Coordination becomes the bottleneck

At normal velocity, a team makes one or two architectural decisions per week. At 10x velocity, it is several per day. Engineer A refactors the authentication flow while Engineer B extends the API that depends on it. These are not implementation details, they are architectural choices that ripple through the codebase.

Traditional coordination mechanisms (Slack messages, scheduled meetings) introduce too much latency. Waiting for a response creates a bottleneck or a risk of going down the wrong path. The Amazon Bedrock team solves this through physical co-location. When a decision impacts other engineers, you walk over and hash it out in front of a whiteboard in minutes. The decision is made quickly, correctly, without creating a pile-up of blocked work.

This model does not solve the problem for distributed teams, which remains an open challenge.

What this means for businesses

Agentic development is not about bolting AI agents onto existing practices. It is like adding a turbocharger to a car with narrow tires and old brakes: the result will not be faster lap times but crashes. Real gains materialize when the entire development lifecycle evolves in concert: testing, deployment, coordination and governance.

The good news is that the AI agents increasing coding velocity can also build the infrastructure needed to sustain that velocity. Engineering practices that were too expensive to implement become accessible. This is the real opportunity: using AI to make previously impractical approaches practical.

For the complete methodological framework, read our article on the AI-Driven Development Life Cycle (AI-DLC). LCMH supports businesses in adopting these development practices on AWS.

Sources

1. Joe Magerramov, The New Calculus of AI-based Coding, October 2025. blog.joemag.dev
2. AWS, Open-Sourcing Adaptive Workflows for AI-DLC. aws.amazon.com/blogs/devops
3. AWS, Amazon Q Developer. aws.amazon.com/q/developer