Scaling Agentic Coding to 150+ PRs/Week: Lessons from $85K in Tokens at Lovable

Alexander Lebedev joined Lovable in January 2026, shortly after the AI coding agent boom. By June, he had scaled from a solo dev with a few agents doing 20–30 merged PRs per week to one human overseeing 6–7 agents (each with its own subagent swarm) pushing 150+ merged PRs weekly. The cost: ~$25K/month in May, totaling ~$85K in tokens since January. Here's how he did it — and what broke along the way.

From 30 to 150+ PRs/Week: The Architecture

In January, the process was traditional: plan mode, permission requests, classic human code review. By June, Lebedev had built a dedicated agent that writes tasks for other agents, with multiple levels of implementation and review agents. Large changes now ship as a 10-PR stack instead of a single PR. Human review only touches important decisions, rarely the code itself.

Where Tokens Go: 75% Implementation, 25% Automation

The bulk of the $85K spend — about 75% — goes directly to implementation (code creation). The remaining 25% (and growing) funds automation: AI reviews outside the dev environment, post-merge AI reviews, and routine automated tasks. Lebedev predicts automation's share will keep rising as more work shifts out of the code-creation PR loop.

Human Review: Exception, Not Rule

Lebedev argues that line-by-line review of AI-written code is as impractical as reviewing compiler output was after the shift from assembly to high-level languages. Instead, human review is reserved for the most impactful changes — usually not on PRs at all, but at the RFC/ADR level: system design discussions, whiteboard sessions, infrastructure choices. A single design decision can have more impact than 50 implementation PRs.

The downside: code review was a learning tool and knowledge diffusion mechanism. Engineering now needs new ways to preserve those second-order effects. Lebedev admits: "I don't see any good solutions yet, only space for new experiments."

Change Risk Classification: The Safety Net

Bypassing human review doesn't work naively at scale — especially for new joiners who don't know what they don't know. Lebedev built an AI workflow that classifies every PR by risk level and hard-enforces human review on high-risk PRs. The classifier uses:

• A single markdown policy file read by the agent, which inspects the PR diff and metadata.
• Classification dimensions: size, risk level, code ownership (does the author's team own the majority of changed code?).
• High-risk categories: infrastructure, auth, large diffs, production features.
• Low-risk example: publishing a blog post.

The classification output feeds a deterministic tool that applies policy via GitHub actions and branch rulesets to allow or deny merging.

Key Takeaway

Scaling agentic coding requires not just more agents, but structural changes: task-generation agents, PR stacking, automated risk classification, and a conscious shift of human attention from line-by-line review to architecture-level decisions. The $85K token bill is an investment in proving that the model works — but the hard problems (knowledge sharing, onboarding) remain unsolved.