When we talk about AI for development teams, the conversation quickly turns to tools: Copilot, Cursor, Claude. And when you start experimenting, you dream of delivering twice as fast, with half the staff, and creating twice the value. It’s tempting! But that’s rarely what happens in the first few weeks.
The reality is that adopting AI is less like a sprint and more like a shift in mindset. The benefits do come, but not where we expected them, not at the pace we hoped for, and not without some friction.
In fact, the report ROI of AI-assisted Software Development (Google Cloud, 2026) is clear on this point: in the age of agents, the ROI of AI is not measured by the number of developers it replaces, but by the bottlenecks it eliminates and the capacity it frees up for innovation
At Nexapp, we’ve experienced this firsthand, both with our own teams and our clients. I’d like to share with you how it went.
We could have written this article in vague terms. “We use AI in our work.” “We support our clients in their transformation.” But these clichés have never helped anyone make progress.
Here’s what we’ve actually experienced, honestly.
No guidelines, no formal budget. Developers who wanted to experiment did so. We observed how it changed our day-to-day work and kept up with what was happening in the industry. The goal wasn’t to perform—it was to understand. Some people adopted Copilot, others tested Cursor, and still others didn’t change a thing.
We’ve formalized the process. An AI committee has been established with a clear mandate: to define Nexapp’s internal stance on the use of AI. Not just to encourage adoption, but above all to build a shared vision. We’re rolling out LiteLLM to provide AI models to all our teams through a unified interface. For the first time, we have visibility into who is using what, how often, and at what cost. The data speaks for itself.
At our annual meeting—which brings the entire team together and kicks off a new fiscal year—we articulate a goal: to be recognized for integrating AI into our software development practices. These aren’t just inspiring words. It’s a measurable goal, with an internal lead assigned to it. We’re formalizing a dedicated budget for AI tools for each member of the development team. We’re creating synergies between our AI power users and those who are wondering how to take the first step. The message is clear: this is no longer a pilot project—it’s a corporate priority.
100% of our colleagues use AI regularly. Levels vary greatly from person to person: some are at Level 1, while others are close to Level 3 (I’ll explain these levels in more detail a bit later). We don’t impose a specific pace. What we measure is progress, not compliance.
This is when we reach a symbolic and strategic milestone: AI will no longer be optional in our software development practices. Our goal is to establish Level 2 as the minimum threshold for all our teams. This means that everyone involved in software development at Nexapp works within a broader context, where AI understands the architecture, scans the codebase, and contributes to consistent changes. This is the new standard.
At the same time, our product Axify is launching features to measure AI adoption and impact—a direct response to what we were experiencing internally: concretely measuring who is using AI, at what level, how much it costs, and what the actual effect is on delivery velocity. What we couldn’t see before, we can now quantify.
Earlier this year, we surveyed the entire software engineering team about their day-to-day use of AI: perceived level of proficiency with AI tools, time savings, level of trust in AI-generated code, the impact of AI on compliance with quality standards, understanding of our stance on AI, challenges faced, concerns, successes, and more. This snapshot sparked an initial wave of initiatives. Six months later, we repeated the exercise, and comparing the two snapshots confirms what we’d been sensing on the ground: we’re no longer in an adoption phase. We’ve reached an entirely new stage of AI maturity.
And this stage comes with entirely different challenges. Equipping and training individuals was the challenge of the past two years. Helping a collective evolve is another: rethinking team rituals, reviewing how work is organized, and standardizing practices that were developed in silos. That’s the chapter we’re writing right now.
The path over the past two years hasn’t been linear. There’s been resistance, false starts, and tools that were abandoned. But each step allows us to move forward, and that’s why we can now guide our clients along the same path.
Dan Shapiro, a tech entrepreneur, proposed one of the first framework for assessing a team’s level of AI autonomy. His framework has been widely shared, and it served as the basis for our initial reflections. But when we applied it to our teams and those of our clients, we quickly realized that concrete benchmarks were missing: what exactly defines each level? What exactly do we delegate: a code snippet, a task, a user story, a product vision? What does a human still need to approve? So we developed our own maturity scale, inspired by his but grounded in what we observe in the field.
It also reflects a broader transition: from the traditional software development lifecycle (SDLC) to an AI-enhanced SDLC, and then to the ADLC, or Agentic Development Lifecycle, where the development cycle is reorganized around agents. And one constant runs through all six levels: accountability remains with humans.
Generative AI produces isolated snippets of code without access to the project. The developer enters requests via a chat interface, evaluates the result, and implements it manually. The SDLC remains unchanged: the AI is outside the workflow.
AI is integrated into programming tools. It completes, suggests, refactors locally, and generates unit tests, with a scope limited to the open file. The developer delegates simple tasks to it, stays in the loop at every step, and reviews every line of code.
The AI understands the entire repository: it modifies multiple files and delivers a feature, tests, and a pull request, but only acts on request. The developer works in a continuous flow and delegates complex tasks. Review becomes more time-consuming than coding, and it remains 100% human. This is where most teams hit a plateau.
The development team no longer writes code. The product team (dev, design, PO) breaks down the work and writes specifications that an agent can use; the developer supervises several agents simultaneously and ensures compliance with engineering best practices. This marks the transition to the ADLC: rituals, the definition of “ready,” and acceptance criteria are rewritten to be machine-readable. The bottleneck is no longer development time, but rather the drafting of requirements and the validation of the delivered work.
The team no longer manages agents one by one: it builds, observes, and improves the system that enables them to deliver autonomously. The ticket becomes the interface: a story is marked as “ready,” an agent picks it up, codes, tests, and deploys it behind a feature flag. The developer handles exceptions and intervenes only if a safeguard is triggered. Trust is based on tests, safeguards, and measured results.
No human writes or reviews the code. The AI self-corrects, self-improves, and determines its technical priorities based on production signals. Humans set the intent and constraints (budget, risk, compliance) and become owners of the outcome rather than operators. This is the logic behind the “dark factory,” as seen at StrongDM, where a team of three engineers deploys Rust and Go to production without ever reading a single line of the generated code.
Note: Scaling up is not a goal in and of itself. The right level is the one that allows you to move faster while delivering value, within the context of your organization and your projects. Security, performance, scalability, architecture, and quality remain the solid foundations that enable us to give AI greater autonomy. Furthermore, AI-assisted development is evolving rapidly: this scale reflects our current vision and is bound to change.
A study by METR (2025) showed that experienced developers using AI tools took 19% longer than before, even though they estimated they were working 24% faster.
In February 2026, METR published an update that qualified the figures but reiterated the conclusion. The problem isn’t the tool, but the workflow surrounding it, which hasn’t changed. Teams that are seeing gains have redesigned their way of working—they haven’t just added a plugin.
The DORA report on AI ROI confirms this phenomenon across the industry: most organizations experience a J-curve—a temporary dip in productivity associated with the learning curve of the transformation. The most common pitfall? Executives who interpret this dip as a failure and cut funding at the worst possible time. Successful organizations budget for it from the start.
The more AI takes over execution, the more value is placed on the ability to clearly define what needs to be built. An ambiguous specification produces ambiguous software.
The DORA report on AI ROI gives this skill a name: context engineering—the art of providing the agent with a precise business and technical context. Its investment roadmap, in fact, follows this order: first, the context layer—that is, high-fidelity, machine-readable documentation and internal data accessible to AI; then training humans in specification and verification, so that they act as orchestrators rather than executors.
In the age of agents, the old adage “garbage in, garbage out” now applies to the context we provide to the agent. This is a skill that needs to be developed, and most teams do not yet practice it intentionally.
Reading every line of code generated by AI is reassuring, but it’s also what prevents us from shifting into high gear. The mental leap from reviewing everything to reviewing only the results is greater than the technical leap. The DORA report gives this bottleneck a name: the verification overhead. As long as trust is low, every generated line is reviewed and reviewed again, and the gains evaporate. And this leap doesn’t happen on its own.
Up to Level 2, AI remains an individual practice: each team member develops their own reflexes and way of working on their own. We can share our successes and lessons learned, but each person continues to work in their own way. At Level 3, the entire team shifts its approach. Rituals, the definition of “ready,” and acceptance criteria are rewritten to be actionable by agents, and accountability shifts from the individual developer to the system that the team sets up and monitors.
As DORA points out, without this collective transformation, AI only creates localized productivity gains. So, the ability to move away from line-by-line review isn’t a leap of faith: it’s based on automated safeguards (non-optional tests and quality gates) that we choose and maintain together. Like the brakes on a race car: it’s because they’re reliable that we can go fast.
This paradox is well documented at the market level. The Stanford studies on productivity in software engineering—conducted among tens of thousands of developers and featured in the DORA report on AI ROI—quantifies the phenomenon: gains of 35 to 40% on simple greenfield tasks, but often 10% or less on complex legacy code.
We see this firsthand in our projects. On a new mobile app project with relatively simple features, one of our developers delivered the product four times faster than originally planned—all thanks to AI. Conversely, there are still contexts where the time savings are less impressive, particularly for complex systems with legacy code.
Level 5 can work for well-defined scopes, in greenfield projects, with few regulatory constraints. For enterprise-grade software, human oversight is a matter of legal responsibility, compliance, and governance. The goal isn’t to reach Level 5 at any cost. It’s about making progress to achieve benefits, while knowing exactly what we’re delegating and why.
At Nexapp, working with one of our clients, we took the liberty of adding a Level 4.5, which we refer to as “lit factory ”: since humans remain in the loop, the lights are never turned off.
At Nexapp, this journey took us two years. We started with some exploratory work, then established structure through an AI committee, and we’ve now reached 100% adoption, with Level 2 as the minimum threshold for all our teams and projects that are already aiming for Level 4.
For you, the question is probably no longer whether your teams will use AI—almost everyone answers “yes” to that question. The real question is what level your team is actually operating at and where you want to be in 12 months.
Moving from Level 1 to Level 3 doesn’t require a huge budget. It requires taking an honest look at how you’re working right now, deciding how far you want to go, and then getting support to build on where you are today.
We’ve walked this path with our own teams before offering it to our clients. If you’d like to assess where your team stands, let’s talk.