Putting agentic software development into practice: Lessons from a real-world project

A popular eCommerce site with millions of users had an engagement problem. The majority of users who downloaded its mobile app never returned after their first session.

The company realized that minor UI fixes weren’t going to change that behavior. It wanted to rebuild the entire application from scratch and launch it ahead of the Black Friday rush. That gave them only five months to do what would normally take well over a year.

Until recently, a project like this would have forced an early compromise between scope and schedule. But today, every ambitious project is an opportunity to push the frontiers of AI in product development, and to test the limits of a new product development framework we’ve been working on.

The Modus Agentic Framework™ is our software development lifecycle framework to embed AI throughout product delivery while keeping human judgment firmly at the center. It doesn’t discard the Agile principles that still serve us well. Instead, it rethinks the development workflow around the deliberate, thoughtful use of AI.

The eCommerce project gave us the ideal opportunity to put the Agentic Framework™ to the test. Here’s what happened when it met a real client, a real deadline, and some very real stakes.

Choosing the right skills (for humans & AI)

To begin with, we increased the team’s designer-to-developer ratio to keep pace with how much faster developers could work with AI. In traditional agile teams, one designer for every three or four developers would already be considered a high ratio. We moved closer to one designer per developer.

We used Claude Code for development, but simply giving engineers access to Claude Code was not enough. The more consequential layer was the unique set of Claude Skills, based on years of actual delivery experience.

Many teams approach AI-led development as AI doing the work, with humans stepping in to rubber-stamp the results. We designed our Skills specifically to avoid this checkpoint approach. Instead, they make human involvement part of the development process itself, keeping people in the loop throughout delivery.

Here are a few examples of Claude Skills used during the project:

Similarly, our designers used Impeccable, a set of design skills for coding agents, to give Claude more structured guidance around visual hierarchy, typography, accessibility, interaction, and polish. Instead of relying on generic AI-generated UI, Claude now had a more opinionated framework for critiquing and refining both engineering and design work.

With a team composition suited for AI-led development, a set of purpose-built skills, and clear human-in-the-loop practices, we now had the essential ingredients to put the Modus Agentic Framework™ into practice.

From requirements to QA: The Modus Agentic Workflow™ in practice

The best way to understand the Modus Agentic Framework™ is to follow a feature through the entire delivery process. Consider an email login feature that lets users create an account on the eCommerce application using their primary email.

The context for this feature existed primarily in two places:

• Jira ticket with requirements and acceptance criteria
• Figma wireframe with design and UX details

That design context wasn’t always limited to static wireframes. When a feature’s behavior was difficult to communicate through screens alone, our designers used Claude Code to build interactive prototypes with the actual design tokens, icons, and typography. This immediately improved the quality of feedback. Instead of reacting to static screens, stakeholders could interact with something much closer to the real product and test it directly on their phones.

Anthropic’s Model Context Protocol (MCP) brought information from Jira and Figma directly into our development environment. This meant AI wasn’t tasked with implementing email login from standalone prompts. It had access to the same relevant context the team was working from.

The feature now entered into what we call a Governed Delivery Loop, where AI and humans work in lockstep.

1. AI proposes how it will build the feature

Most studies on AI in product development confirm that speed in one part of the process can create additional work elsewhere. In GitLab's 2026 survey of 1,528 developers, 85% say AI has shifted the bottleneck from writing code to reviewing it.

We were aware that rushed implementation would only create more complexity during validation. So, before AI wrote any code, our Planning Skill worked through the requirement and proposed an implementation plan. For the email login feature, that meant:

• locating the relevant parts of the application
• mapping the email flow, and
• identifying relevant APIs and integrations

Next, our engineer reviewed the plan, challenged assumptions, and approved the approach before implementation began. A human review here is essential because it’s much cheaper to correct a bad plan than a bad implementation.

2. AI implements the feature on a development branch

Once the approach was approved, AI moved into implementation on the working branch. But it wasn’t starting from first principles. Claude Skills gave it access to our established engineering practices, including answers to questions like how code should be structured and which technical conventions to follow.

Some of that guidance was specific to the technology itself. For example, the application was built in React Native, which meant certain features like the email login had to be exercised in a mobile emulator rather than treated as if they were running in a browser.

By encoding this institutional knowledge into Claude Skills, we reduced the amount of project-specific guidance engineers had to provide during implementation. As a result, many features could go from requirements to testing in just 2-3 days.

3. The team validates the feature before QA

As mentioned before, QA is one of the harder problems in AI-led development. For this project, we pushed part of that validation into development itself.

Our Testing Skill instructed AI to launch the React Native application in an iOS emulator, navigate to the feature it had just implemented, and capture the rendered screen. A human engineer could then compare that output with the corresponding Figma design before the code left the development branch.

If the two diverged, the engineer corrected the implementation with AI and ran it again. This removed a class of issues from the QA queue altogether. There was little value in asking a tester to report that a screen did not match the approved design when the engineer could establish that directly before opening a pull request. QA still performed its normal role. The difference was that features reached it after the engineer had already verified the implementation against the most immediate source of truth.

4. Humans still own the code

We had an explicit rule on the project — using AI to develop features did not transfer responsibility to the agent. If an engineer submitted the pull request, they were expected to understand the code and defend the technical decisions behind it.

The pull request then went through the project’s standard technical review, with the tech lead examining the diff before approving the merge. Only after the merge did the feature enter formal QA. Testers worked from the original Jira ticket and its acceptance criteria, giving the feature an independent check against the requirement that started the process.

There is a useful symmetry to this process. The feature begins as a requirement in Jira and ends with QA testing the implementation against that same requirement. Between those points, AI can do considerably more of the work. What it does not acquire at any stage is the authority to approve its own work.

So, what do we do with Agile?

Many Agile practices were shaped in a world where engineering capacity was a significant constraint and implementation took much longer than it does today. Therefore, there is a growing argument that AI-led development will make Agile obsolete.

But we disagree. We feel the four core values of the Agile manifesto, drafted over two decades ago, are as relevant today as they were two decades ago. Therefore, the Modus Agentic Framework™ isn’t a call to toss out Agile. However, it does emphasize the need to evolve some of the operating assumptions around it.

For example, on this project, we retained two-week sprints but treated capacity more flexibly. The team committed to a realistic baseline of work, knowing that engineers would often finish earlier and pull additional ready work into the sprint. We deliberately avoided turning that acceleration into a fixed productivity multiplier. We knew the team could deliver more, but we did not yet have enough evidence to say how much more consistently.

This allowed us to benefit from higher engineering throughput without converting AI adoption into higher workload expectations.

Results & lessons learned

The team delivered the entire application within just five months and was rolled out without critical stability issues. Early observations reveal a conversion rate increase of nearly 40%.

More importantly, the project gave us a much clearer picture of what happens when AI acceleration is applied across a real delivery environment rather than an isolated development task.

Some of the most useful lessons came from the pressure that higher engineering throughput created elsewhere. QA had to absorb considerably more work, and technical review became more demanding as pull-request volume increased. These are now areas where we see further opportunities to extend the same agentic principles that accelerated development.

We are also getting more precise about the economics of the model. Token consumption, model selection, and the cost of sustained AI usage are becoming part of how we think about project planning, just as cloud infrastructure and engineering capacity already are.

Agile retrospectives have usually helped teams turn experience into better ways of working. With the Agentic Framework™, some of those lessons can go a step further. We can encode them into reusable skills and carry real-world insights into future projects. Each engagement, therefore, adds to the body of delivery knowledge available to the next.

The Modus Agentic Framework™ gives product teams a structured way to define work, use agents to explore and execute, evaluate outputs against evidence and business goals, and decide what to do next. It is grounded in what we’ve learned from active work with Global 2000 enterprises. Explore the Modus Agentic Framework™ ->

This article was developed with contributions from Joao Kestering (Principal, Software Engineer) and Isabela Freitas (Product Designer).