A Year of Building a Production Product With AI Agents: The Journey in 15 Parts

For the past year we have been building and running a client's production product with AI coding agents doing most of the typing. It isn't a demo or a weekend prototype. It's two React Native mobile apps and a multi-role web portal, built against backend services owned by the client's own engineering team.

This series is what we learned. It covers how we work, not who we work for: no client names, features, tickets or infrastructure details.

What we were building

The workspace is five projects sitting side by side in one parent folder:

• two React Native mobile apps, each for a different kind of user
• a web portal, built as a micro-frontend monorepo, with more than one user role
• the client's backend API, which their team shares with us as a repository of API request collections
• a design workspace where requirements become Figma screens

Keeping everything under one parent folder mattered more than we expected. Agents read sibling repositories all the time: to port a feature from one app to another, to check the API contract, or to find the ticket behind a change.

The numbers, counted from git and session logs

• Web portal: about 1,530 commits since late 2025. The share of commits co-authored by an AI agent went from zero at the start to 77% in September 2026 and 93% in October.
• Consumer app: about 1,370 commits since March, 65% agent co-authored, around 170 pull requests.
• Business app: about 250 commits, 66% agent co-authored.
• The last month alone: roughly 360 agent sessions across the workspace. On the web portal, 115 pull requests were merged from 444 developer prompts, and the median prompt was 24 characters long.
• Merges: the agent opened more than a hundred pull requests on the portal that month and merged none of them. A human merges.

"Co-authored" here means the agent wrote the change and a human reviewed and merged it.

The phases

1. Before the harness (late 2025 to February 2026). People wrote the code, helped by AI autocomplete. No agent trailers appear in the history.
2. Bootstrap (March 2026). We installed a harness in the portal in one day: instruction files for each agent tool, an architecture document, Always / Ask / Never boundaries and a one-command verification script. Both mobile apps had instruction files from their first week.
3. Spec everything (April to July). Every change went brainstorm, written spec, task plan, execution. That came to about 120 specs and 115 plans, along with quality gates, mandatory test-first development and git worktrees.
4. Right-sizing (July and August). We moved every repository under one folder and added an API-sync command and release scripts. In August we told the agent that skills and process are tools, not obligations. Formal specs became rare after that.
5. Field tooling (September). We added a redacted mirror of the client's issue tracker, a live-API probe skill, a real-device driver and a security pass. Ticket work settled into a loop: "look into ticket N", then "go", then "Merged. Cleanup."
6. Orchestration (October). One coordinator session ran four peer sessions across two repositories. QA was run by cheaper-model subagents behind a write guard. Client reports were generated from tickets and commits.

Five models, one harness

Over the year, the model in the loop moved through five generations, with a smaller model handling cheaper work alongside it. Every upgrade helped, but none of them carried over anything the previous model had learned about the product.

What did carry over was the harness: the instruction files, the memory, the skills and scripts, the ticket mirror, and the habits built around them. That is the main argument of this series, and the reason we now install the same setup for other teams through our harness engineering work.

The series

1. The journey (this post).
2. The instruction file that learns: turning every agent mistake into a rule.
3. Spec before code, then less of it: matching how much process we use to how uncertain the work is.
4. Agent memory that survives /clear: notes, indexes and pruning.
5. Tickets in, reports out: safe agent access to a client's issue tracker.
6. Verified, not asserted: how agents prove their work.
7. The human taps, the agent reads the logs: AI agents on real phones.
8. Designing in Figma with an agent.
9. Many agents, one product: peer sessions, briefs and QA subagents.
10. Shipping with agents: worktrees, the cleanup ritual and release scripts.
11. Guardrails: permissions, credentials and the classifier that said no.
12. What the human still does.
13. Trimming is not a plan: when the memory index hit its ceiling.
14. Memory is a cache, the repo is the source: moving 90 notes out of the agent's head.
15. Designing for a phone the model has never seen: an iPhone Duo design in 40 minutes.

Ground rules for this series

• No client names, features, tickets or infrastructure details.
• Numbers come from git history and session logs, not from memory.
• Quotes from the developer and the agent are lightly edited to remove client terms.