As the novelty of AI coding assistants fades, a new paradigm is emerging: the deployment of autonomous, multi-agent swarms. Drawing from a groundbreaking case study at Lovable—where an individual engineer’s AI token spend hit $85,000 in six months, yielding a staggering 293 merged Pull Requests in a single week—this briefing dissects the architectural, economic, and cultural shifts required to manage synthetic workforces. For Singapore, a hyper-connected city-state constrained by population but rich in capital and digital infrastructure, mastering this transition from rote programming to cognitive management is the ultimate geopolitical and economic force multiplier.
It is a humid Tuesday morning in Tanjong Pagar. From a polished co-working space in Guoco Tower, one can watch the relentless choreography of the Port of Singapore below—a marvel of automated logistics where thousands of containers are routed, stacked, and shipped with minimal human intervention. It is a masterpiece of physical scale. Yet, on the screens glowing in this very room, a far more profound shift in scaling is quietly taking place. This is not the scaling of physical goods, but of pure cognition.
For the past year, the technology sector has been obsessed with the AI assistant—the polite, autocomplete co-pilot that helps a developer write a function a fraction faster. But the frontier has already moved. We are no longer talking about assistants; we are talking about synthetic swarms.
A recent dispatch from Alexander Lebedev, an engineer at the development platform Lovable, serves as a canonical text for this new era. Lebedev chronicled his transition from spending a modest $600 a month on personal AI API tokens to commanding a monthly budget of $25,000, totalling roughly $85,000 over six months. The resulting output was not just incrementally better; it was categorically different. A productive week shifted from 20 to 30 merged Pull Requests (PRs) to upwards of 150, peaking at nearly 300. The ratio shifted from one human paired with a few agents, to one human orchestrating a fleet of six to seven primary agents, each dispatching its own sub-agents.
This is the industrialisation of software development. And for Singapore—a nation that has anchored its Smart Nation 2.0 ambitions on moving up the intellectual value chain—understanding the mechanics, risks, and economic philosophy of the $85,000 synthetic swarm is not merely an exercise in technical curiosity. It is a blueprint for national competitiveness.
The Economics of Infinite Cognition
To understand the magnitude of Lebedev’s experiment at Lovable, one must first discard the traditional calculus of software engineering. In a conventional setup—the kind still pervasive in the glass-fronted tech parks of one-north—developer productivity is a linear function of time, caffeine, and raw talent.
When you introduce an unrestricted token budget, that linearity shatters. The $85,000 spent on tokens is, on the surface, a staggering sum for a single contributor. Yet, when evaluated against the output—a sustained velocity of hundreds of production-ready PRs a week with zero major defects—it becomes the cheapest labour in the history of the knowledge economy.
Lebedev’s spend structure is telling: 75% of tokens are deployed directly on implementation, while 25% (a figure that is rapidly growing) is spent on automation. This includes AI-driven code reviews, post-merge verifications, and routine repository maintenance. The developer is no longer a craftsman chipping away at the coalface of codebase; they are a capital allocator, deploying tokens to solve complex logical problems.
In Singapore, where the tech talent crunch is a perennial boardroom lament, this paradigm shift is revolutionary. Token-maximising—the act of trying to pinch pennies on API calls—is, as Lebedev rightly notes, a foolish and short-sighted behaviour. The optimal amount of attention devoted to token efficiency should hover around 5%. The remaining 95% of an organisation's energy must be ruthlessly directed toward finding new, complex problems to throw tokens at. The capability of models is expanding faster than our imagination to deploy them. In this environment, opportunity cost is the only cost that matters.
The New Abstraction Layer: The Death of Line-by-Line Review
If you are merging 200 PRs a week, you are not reading them.
The transition from human-written to AI-written code introduces a fascinating new level of abstraction. Lebedev aptly compares this to the historical shift from assembly language to higher-level programming languages like C or Python. Decades ago, programmers stubbornly reviewed the machine code output of their compilers, convinced that the machine could not be trusted. Today, doing so would be considered an absurd waste of time. The same phenomenon is unfolding with code review.
Reviewing AI-generated code line-by-line is an analogue habit in a digital epoch. It is not a sensible use of an elite engineer's time. Instead, the solution to the problems created by AI is to deploy more AI. At Lovable, the default has shifted to automated AI reviews. Human intellect is reserved exclusively for the highest-leverage activities: Request for Comments (RFCs), Architecture Decision Records (ADRs), and in-person whiteboard sessions to debug systemic, architectural flaws.
However, over a plate of Hainanese chicken rice at Amoy Street Food Centre last week, a local technical founder articulated the hidden cost of this shift to me. "Code review," he observed between bites, "was never just about finding bugs. It was how our junior devs learned the architecture. It was how our culture of engineering rigorousness spread."
When line-by-line review vanishes, we lose this automatic mechanism for knowledge diffusion. As a discipline, engineering teams must now actively architect new, deliberate ways to preserve these second-order effects—perhaps through more intensive paired-design sessions or mandatory architectural briefings—lest the institutional knowledge of the firm becomes entirely trapped within the weights and biases of a Large Language Model.
Algorithmic Governance and the Risk Stratification Engine
The cosmopolitan optimism of agentic swarms inevitably collides with the brutal reality of production environments. Can a system this autonomous be scaled to a large organisation, particularly one integrating new, enthusiastic hires who might not know what they don’t know? The short answer is no—not without robust, automated governance.
Singapore’s financial and tech sectors are culturally predisposed to rigorous risk management. The regulatory frameworks pioneered by the Monetary Authority of Singapore (MAS) regarding algorithmic decision-making find a fascinating micro-parallel in Lebedev’s approach to scaling AI coding.
To prevent an overzealous agent from bringing down a production database, Lovable engineered an AI workflow for PR risk classification. The core of this system is elegantly simple: a single Markdown policy file. An agent reads this policy, analyses the PR diff and metadata, and triages the change.
High Risk (e.g., core infrastructure, authentication systems): Hard-enforced human review.
Medium Risk: Slow, expensive, deep AI review.
Low Risk (e.g., copy changes, experimental feature flags): Fast, cheap AI review.
Once the policy is defined in plain English, designing the deterministic deterministic GitHub actions to enforce it is trivial. This creates a triage lane that applies human attention only where escalation is genuinely warranted, effectively marrying the speed of synthetic agents with the rigorous governance expected in enterprise-grade software.
The Anatomy of Synthetic Review and the Survival of the PR
In the breathless hype of the generative AI boom, provocateurs have repeatedly declared the Pull Request dead. They argue that if code is generated instantly in the IDE, the asynchronous friction of a PR is obsolete.
The data from the $85,000 experiment suggests otherwise. The PR will survive, not as a forum for human pedantry, but as the fundamental abstraction for unverified changes. Continuous Integration and Continuous Deployment (CI/CD) pipelines rely on the PR. It remains the essential checkpoint.
What is changing is the shape of the review itself. Lovable employs two distinct forms of AI review:
Local Review: This is the workhorse. Operating directly in the development environment, the main agent dispatches highly specialised sub-agents to review specific vectors—correctness, performance, security, and code reuse. The main agent aggregates the findings, deduplicates them, and immediately triages and fixes the root causes autonomously.
CI Review: This acts as the safety net. Teams can opt for quick, cheap checks or slow, exhaustive passes that may take 30 minutes to complete. Crucially, these slow, expensive AI reviews are already outperforming the median human reviewer.
Yet, a critical limitation remains: the context window. When a developer pushes a massive, 6,000-line PR, the AI reviewer hallucinates, loses the plot, and begins rubber-stamping. The solution is the "Stacked PR"—breaking massive changes into atomic, sequential, easily digestible chunks. If humans could never properly review a monolithic PR, we now know that current AI models cannot either. Proper context management and risk management require small, tightly bounded units of work.
Managing the Attention Economy: Human and Machine
When you possess a synthetic cognition machine capable of spewing an infinite volume of code, the ultimate bottleneck ceases to be keystrokes; it becomes human mental context switching.
Navigating this requires a strict taxonomy of attention. Lebedev splits his workflows into distinct modes. "Fast mode" is utilised for highly interactive, synchronous back-and-forth planning sessions. However, executing the actual code generation requires absolute "Task Autonomy." Agents must be granted a variant of "YOLO mode"—the ability to operate without constantly stopping to request human permission. Through carefully engineered tools, agents can even merge PRs autonomously, provided they pass a gauntlet of unit-tested safeguards (branch freshness, green CI checks, no open discussions).
Simultaneously, we must manage the agents' attention. Attempting to feed an entire project's context into a 1-million token window degrades quality and spikes costs. The Lovable framework champions the use of external task trackers specifically for agents.
Herein lies a crucial insight for operational hygiene: task tracking for humans and agents must remain fiercely segregated. Dumping an agent's verbose, ephemeral chain-of-thought into a Jira or Linear ticket turns a human management tool into unreadable slop. The digital exhaust of the synthetic swarm must be kept out of the human line of sight, preserving our dashboards for deliberate, strategic truth.
The Factory That Upgrades Itself
Perhaps the most startling revelation from the Lovable case study is the transition from a static tool to a self-improving factory.
Initially, human developers wrote the "skills" (the custom prompts and tool-use parameters) for their agents. By mid-year, the agents were writing their own skills. Through long-form reflection—where an engineer prompts an LLM to analyse the last 100 merged PRs, parse the comments, and suggest workflow improvements—the system begins to optimise itself. Every point of friction, every minor derailment, becomes fuel for a self-reflection loop.
This requires a cultural shift towards absolute transparency. Everything, from coding style guidelines to the nuances of system architecture, must be committed to Git. In the pre-AI era, rigorous documentation was a courtesy to remote human colleagues. In the agentic era, it is the fundamental nutrition for the synthetic workforce.
As Singapore continues its aggressive push to cement its status as a premier global tech hub, the lessons here are undeniable. We are moving from an era where value was created by writing code, to an era where value is created by managing the context and guardrails of those who write the code. The elite engineer of 2026 is a manager of synthetic specialists, an arbiter of algorithmic risk, and an architect of self-improving cognitive factories.
The initial $85,000 spent on tokens is merely the admission price to this new world. The next step is figuring out what to build when the friction of creation approaches zero.
Key Practical Takeaways
Stop Penny-Pinching Tokens: Token optimisation is a trap. Direct 95% of your organisational energy toward finding larger, more complex problems for your AI to solve, rather than trying to shave fractions of a cent off API calls.
Embrace the Risk Markdown: Do not treat all AI-generated code equally. Implement a deterministic, AI-driven classifier to sort Pull Requests into high, medium, and low risk, reserving human review strictly for the highest-risk infrastructural changes.
Mandate Stacked PRs: Large PRs break AI comprehension just as effectively as they break human comprehension. Train agents to deliver small, atomic, stacked PRs to maintain high-quality automated reviews.
Segregate Task Tracking: Never allow an agent's verbose chain-of-thought to pollute human management tools like Linear or Jira. Use dedicated, ephemeral tracking systems (like Beads) for agent workflows.
Automate Skill Creation: Stop writing agent instructions manually. Prompt your agents to review their own past performance over the last 100 PRs and autonomously generate new skills and efficiencies.
Frequently Asked Questions
Will AI coding agents make Pull Requests obsolete?
No. The Pull Request remains the essential, foundational abstraction for unverified changes. CI/CD pipelines and testing frameworks rely on this structure. While the review of the PR will be largely automated by AI, the PR itself will survive as the vital unit of context and risk management, provided changes are kept small and stacked.
How do we maintain engineering culture when humans stop reviewing code?
This remains one of the greatest unsolved challenges of the agentic era. Because AI code review removes the serendipitous learning and alignment that occurs when humans read each other's code, engineering teams must artificially inject alignment through other means. This includes prioritising Architecture Decision Records (ADRs), in-person whiteboard sessions, and high-level system design debates.
Is it safe to let AI merge its own code into production?
Yes, but only if you build the appropriate scaffolding. It requires shifting away from "human permission" to "systemic guardrails." By wrapping tools in unit-tested scripts and enforcing strict rules (e.g., allowing agents to merge only if the branch is fresh, CI checks are green, and the AI risk-classifier has deemed the change "low risk"), you can achieve safe, autonomous execution.
For further reading on the mechanics of scaling agentic teams and modern AI software development, explore the following resources:
No comments:
Post a Comment