Nov 12 2026 · 8 min read

What Building a Product in 22 Days With AI Agents Taught Me About Engineering Judgment

In 22 days, I worked with AI agents to take an internal MojoTech product from first commit to about 87,000 lines of application and infrastructure code, 64,000 lines of tests, and 194 merged pull requests. The speed was real. What surprised me was where the hard work moved.

That product is Mojo Experience, an AI document-processing platform. We use it internally, and it also serves as a working reference for clients on what it takes to run AI over sensitive documents securely, designed with enterprise architecture and compliance in mind. Its first commit was on September 27, and these figures reflect the October 19, 2026 snapshot. The line counts are raw counts that include blank lines and comments.

I came to this work with more than 20 years in technology strategy, AI, and hands-on software and data engineering, with deep AWS expertise, AI engineering experience with Claude and OpenAI, and AI-accelerated implementation. I remained responsible for deciding what to build and whether the result was good enough.

Faster implementation lets teams evaluate a working approach sooner and devote more attention to design and validation. That shorter feedback loop can help leaders make better-informed decisions about where a product should go next.

The hard work moved to architecture, directing the agents, and checking what they produced: the tests, the delivery metrics, and the product's readiness. First, here is how the work was organized.

How I built it: one engineer and a team of AI agents#

At MojoTech, we use agentic teams across many of our projects. For Mojo Experience, I tried a different approach: Claude Code’s experimental agent teams, where a lead session coordinates teammates who each work in their own context and can message one another directly. I used a full agent team for the most complex changes, such as work that spanned the processing pipeline, the API, and the infrastructure at once, and lighter role-based agents for focused tasks such as reviews.

I worked as part of the team, not outside it. The rest of the team was AI agents, each with a defined role and only the access that role needed. A lead agent coordinated the work, tracked who owned which files, and handled every Git operation. An architect, a product manager, and a designer advised on structure, scope, and user experience; they could read the code but not change it. A developer and a DevOps engineer made the changes, each limited to the files or infrastructure assigned to them, so parallel work did not collide. A quality engineer and a security engineer reviewed the result independently; they could inspect and test the code but not edit it. Not every role worked on every change. The lead brought in the roles a change needed.

My role was to set direction and make every decision. I approved a concrete plan before any significant change, such as a new data schema, authentication, handling of sensitive data, or infrastructure. Blocking review findings had to be resolved before a change merged. I reviewed every pull request myself before it merged, and I authorized each merge to the main branch and each production deployment. The structure kept generating code and checking it.

Together, these steps formed an agentic development lifecycle (ADLC), sometimes called an AI software development lifecycle (AI-SDLC). Changes went through a loop of plan, build, independent review, and fix, and I closed each loop with a decision. I will cover that lifecycle, and what it costs, in a later post.

Diagram of the AI agent team: an engineering leader makes every decision and reviews every pull request; a lead agent coordinates advise, build and independent review roles.

Architecture has to keep up with AI-assisted implementation#

When implementation moves quickly, an unclear architectural decision can spread through a codebase before anyone has resolved the underlying question.

Boundaries, data ownership, dependencies, and failure behavior still need deliberate decisions. An agent can produce a locally reasonable solution that makes the wider system harder to change. Someone has to evaluate that tradeoff across the product.

My takeaway is to make architectural expectations explicit early, then keep checking them as the system develops. A diagram created at the beginning does little good if subsequent changes quietly contradict it. On Mojo Experience, I approved the plan before each significant change, where those expectations were set, and independent reviews were where they were checked.

For leaders, this is a reason to preserve experienced engineering involvement as delivery accelerates. The cost of generating an implementation may fall while the consequences of choosing the wrong implementation remain substantial.

Directing AI agents is engineering work#

One person directing AI agents can accomplish a great deal. The quality of that work still depends on the direction.

A useful task gives an agent enough context to understand the intended behavior, the constraints it must respect, and the evidence that would demonstrate success. Vague instructions leave room for assumptions that may be difficult to see in a convincing implementation.

I think about human oversight in terms of accountability. Who owns the requirement? Who decides whether a proposed approach fits the system? Who can explain why the result is acceptable?

AI can help with each of those questions. Responsibility for the answers stays with the people delivering the software. Faster code generation makes that ownership more important.

AI-generated tests need scrutiny#

The 64,000 lines of tests are an important part of the build. Their size alone says little about how effectively they protect the product.

A large suite can still miss a critical failure path. A test generated alongside an implementation can repeat the same mistaken assumption, producing a reassuring result without checking the behavior that matters.

The question I want answered is whether the tests would catch a meaningful defect. That requires examining their assertions, the risks they cover, and the conditions they leave unexplored.

For AI-assisted engineering, validation needs some independence from the code being validated. Expected behavior should come from requirements and risk analysis. It should not simply be inferred from whatever the implementation happens to do. That is why the quality and security engineers on the team were separate agents that could test the code but not edit it.

Delivery metrics need context#

At the October 19 snapshot, 194 pull requests had been merged, with none open or abandoned. About 77 went to the main branch, mostly release pull requests that carried forward already-merged work, so the number of distinct changes was roughly 120. Median time from opening a pull request to merging it was 18 minutes.

Those figures help describe the pace and flow of the work. The short merge interval partly reflects where review happened. Much of the quality and security review happened in separate agent sessions before a pull request was opened, so the interval doesn't include that review time. It still doesn't show how thoroughly a change was reviewed, how much preparation preceded it, or how well it will behave under real operating conditions.

The product has since been released, and work has continued to enhance it. By November 11, the codebase had grown to about 157,000 lines of application and infrastructure code and 146,000 lines of tests, across 345 merged pull requests.

I am equally cautious about treating lines of code as a productivity target. More code can represent useful capability, unnecessary complexity, or both. It also creates something the organization must understand and maintain.

The business questions are more demanding: does the product solve the intended problem, can people use it effectively, and can the team operate and change it safely? Activity metrics help explain the build. Evidence about outcomes has to follow.

Readiness needs evidence beyond the build#

I evaluated Mojo Experience with MojoReady, MojoTech’s codebase readiness framework, which combines recognized standards such as ISO/IEC 25010 and OWASP with well-established principles for software design, maintainability, and testing. That brought a structured quality perspective to a project whose speed could easily dominate the conversation.

A readiness assessment helps examine the software and identify questions that deserve attention. Its conclusions still depend on the evidence available and the scope of the assessment. In this case, an AI agent ran the assessment using MojoTech’s own framework, so it is a structured self-assessment rather than an independent audit.

Real-world adoption, operating reliability, and return on investment need their own evidence over time. I would not use the 22-day timeline, the test volume, or the assessment itself as proof of those outcomes.

The build demonstrates what one experienced engineer working with AI agents can produce in a bounded period. How well that product serves its users is a continuing responsibility.

What I would ask leaders to do next#

Choose a bounded internal product with a clear purpose. Establish the architectural constraints and acceptance criteria before optimizing for speed. Give a named person responsibility for the result, and decide how you will measure usefulness after delivery.

Then examine both the pace and the quality of the work. Keep the evidence that supports your conclusions and be explicit about what remains unproven.

The opportunity I see is to shorten the distance between an idea and software we can evaluate. Realizing that opportunity responsibly takes engineering judgment throughout the process.

If you are deciding how to bring AI agents into your own engineering work, I’m glad to compare notes. At MojoTech, we help engineering leaders set up the structure, reviews, and readiness checks that let a team move faster without losing control of quality.

In my next post, “What It Takes to Run AI Over Sensitive Documents,” I will cover what Mojo Experience does and the lessons from building its retrieval-augmented generation (RAG) pipeline: understanding the documents before designing for them, handling messy real-world data, budgeting for reprocessing, and measuring the AI that checks the AI.

Travis Rogers

Share:

Accelerate Your Digital Strategy

Contact Us