How I Shipped 186 Commits in 5 Days With an AI Dev Partner

What actually makes human and AI collaboration work at speed — and why English is now the most important programming language you can learn

Five days. That is how long my AI development partner and I have been working together.

In those five days we shipped 186 commits to production. We built 12,000 lines of code across the Mission Control dashboard, a custom Go DevOps CLI, and a multi-tenant LLM routing layer. We applied 11 database migrations, wired 49 API routes, wrote 87 automated regression tests, and delivered 5 complete product epics covering gamification, billing, routing infrastructure, SEO, and deployment automation.

I did not type most of that code. I described what I wanted.

Andrej Karpathy said it best: "English is the new hot programming language." The most valuable skill for a modern developer is no longer knowing the semantics of any particular language. It is knowing how to communicate intent precisely, how to define boundaries clearly, and how to make good product decisions fast. The execution layer is increasingly AI's job. The thinking layer is still yours.

What We Actually Built

Before I explain the process, the architecture deserves context. This is not a simple CRUD app.

Mission Control is a multi-tenant SaaS dashboard for managing AI agents. It runs on Next.js 15 with server components, connects to a PostgreSQL database via Drizzle ORM, and authenticates with NextAuth. It has a full Kanban board with drag and drop, a real-time Activity tab that polls the OpenClaw gateway for live agent status, a gamification system with XP, streaks, 7 progression ranks and an apex Archon tier, a workspace file browser with memory editing, and a built-in LLM router called AiPipe that routes requests across OpenAI, Anthropic, and other providers based on quality-adjusted cost scoring.

Behind the dashboard sits a Go CLI called navi-ops that manages the autonomous development loop, a Cloudflare Tunnel for zero-config public HTTPS, a tls-proxy with automatic restart watchdog, and a GitHub Actions pipeline that SSH deploys to a DigitalOcean server and swaps the running Docker container with zero downtime.

There is also an LLM routing proxy (AiPipe) with per-tenant API key encryption using AES-256-GCM, a Stripe billing integration, a Resend-powered newsletter system, and an OpenAPI spec with Swagger UI.

That is the product we built in five days. Not "scaffolded." Not "prototyped." Deployed, tested, live in production, serving real users.

The Collaboration Model

My AI partner's name is Navi. She runs on OpenClaw on a server in Singapore, connected to me via Telegram. She is not a chatbot. She is closer to a senior engineer with a strong opinionated process and access to every layer of the stack.

The relationship works because we have defined roles with clear boundaries, not just an open chat interface.

I own product vision, architectural direction, production approvals, and anything that touches money or external users. Navi owns execution, sub-agent coordination, regression testing, deployment mechanics, and proactive flagging when something looks wrong or my idea is a bad one.

That last part matters. This week I suggested evaluating a lighter agent runtime. Navi came back with a full technical analysis, flagged that our entire provisioning design would need a rewrite, and gave me her verdict: "I would bet 80% the research comes back: stay." She was right. That friction is not a bug. It is exactly what you want from a development partner.

The Sprint System

The core mechanism that turns conversations into shipped software is a sprint workflow with five phases.

Phase 0 is pre-flight spec: define assumptions, success criteria, and scope before touching a single line of code. No silent guesses. No moving targets mid-build.

Phase 1 is story decomposition: break complex features into independently executable items that can run in parallel.

Phase 2 is the readiness check: a CONFIDENCE_SCORE gate. If the plan scores below 95, Navi flags it to me and waits. She does not proceed on shaky assumptions.

Phase 3 is implementation: sub-agents execute in parallel across independent stories. While one agent builds the API routes, another writes the tests, another handles the UI components. No sequential waiting.

Phase 4 is the quality contract: TypeScript compilation check, full regression suite, code review. This is not optional and not skippable.

Every sprint item has a classification: AUTO means Navi executes it without asking. NEEDS_USER means she waits for my explicit sign-off. BLOCKED means a dependency is unresolved. A Go CLI called navi-ops runs this classification loop every 30 minutes via cron. I wake up most mornings to completed work I did not explicitly request.

Nothing reaches production without my "yes, merge to main." That is a hard rule enforced by a pre-push git hook. Not a guideline. A technical constraint.

The Parallelism

The speed multiplier is sub-agents. When I have four independent tasks, Navi does not queue them. She spawns four agents simultaneously. Each one focuses on a single story, runs its own tests, and reports back.

Right now, as I write this sentence, four sub-agents are running in parallel: one implementing a real-time chat backend, one building the insights index page you are reading this on, one writing comprehensive developer onboarding documentation, and one building a new developer setup script with Docker Compose. I have not opened a code editor for any of it.

That parallelism is compounding. The rate-limiting factor is no longer how fast I can write code. It is how fast I can make good product decisions and communicate them clearly.

Which brings us back to Karpathy's point. English is the programming language. Precision of thought, expressed in plain sentences, is the skill that translates directly into shipping velocity. Every ambiguous requirement becomes a slow conversation or a wrong implementation. Every clear one becomes a committed feature.

What Most People Get Wrong

I have talked to developers who tried AI-assisted development and gave up. The problems are almost always the same three things.

The first is no persistent memory. If your AI starts fresh every session, you spend 20 minutes re-establishing context before doing any real work. Navi reads a MEMORY.md file at the start of every session covering every key decision, infrastructure detail, and preference from every previous conversation. She knows what the Coolify migration was, why we chose DigitalOcean for provisioning, that AES-256-GCM is the encryption standard for API keys, and that I prefer outcome-first updates in Done, Blocked, Next format.

The second is no boundaries. An AI that does whatever you ask without friction executes bad decisions faster than you can catch them. The NEEDS_USER classification, the production approval gate, the regression suite as a hard merge requirement — these are not limitations on capability. They are the reason I can trust the system to run while I sleep.

The third is no upfront investment. I spent time writing SOUL.md (Navi's operating identity and principles), WORKFLOW_AUTO.md (the full autonomous operation protocol), and role files for 10 specialised sub-agents covering architecture, planning, implementation, testing, security review, documentation, and refactoring. That investment pays dividends on every single interaction after it.

The Numbers

Five days. 186 commits to production. 12,138 lines of code in the MC dashboard. 2,786 lines in the navi-ops Go CLI. 5 major product epics shipped, covering 25 individual stories. 49 API routes. 11 database migrations. 87 automated regression tests. One human making product decisions over Telegram.

The bottleneck in modern software development is not writing code. It is coordination, context management, and decision throughput. AI handles the first two better than any human at a fraction of the time and cost. The third one still belongs to you, and it always will.

The question is not whether to work this way. It is how quickly you can build the system that makes it work.

Navi runs on OpenClaw. Mission Control, the dashboard we built and use to run this workflow, is live at https://archonhq.ai. The full developer workflow documentation is in the docs section.