A team deleted almost all our agent code, and other lessons from 100k PRs

Lovable published an architectural breakdown of its platform evolution after logging more than 100,000 pull requests and serving users who created over 70 million projects, as detailed in lovable.dev's report. The engineering retrospection details how the startup shifted away from complex, open-ended autonomous agent loops after discovering that granting models more execution freedom caused them to stumble into technical rabbit holes. Instead of letting unconstrained agents delegate tasks endlessly, the team removed nearly all of its autonomous agent code in favor of a predictable single-turn tool pipeline, custom tagged edits, text-based retrieval, and deep computer state checkpointing.

This review examines Lovable's technical transitions from its open-source predecessor GPT Engineer in spring 2023 to its production stack in late 2024 and beyond. The analysis is aimed at software engineers, technical leads, and founders building generative coding workflows who are evaluating whether to train custom models, deploy autonomous subagents, or enforce strict environmental constraints. By detailing real-world performance trade-offs, context limits, and sandbox operations, this guide provides practical patterns for teams attempting to keep generative developer tools dependable as user projects scale in complexity.

A team deleted almost all our agent code: what actually changed

The transition began when Lovable abandoned an elaborate asynchronous system designed by company engineer Mårten Wiman, in which an autonomous agent created subtasks and delegated execution to autonomous subagents. While that architecture anticipated rapid improvements in foundation models, in practice the unconstrained agents frequently made cascading errors, explored irrelevant technical dead ends, and operated without predictable completion times. Management concluded that expanding agent freedom degraded product dependability for non-technical users who could not inspect or repair broken code. Consequently, engineers deleted the autonomous coordination framework and restored a direct interaction model where each user prompt maps to a deterministic chain of tools, paired with an interactive chat interface and an instant live preview.

By late 2024, Lovable restructured its core code editing flow around a single response that contained every requested file modification. Because vendor native tool calling was still inconsistent at that stage, the engineering team required the model to enclose code updates inside custom XML-like markers such as lov-write tags, parsing file diffs only after the model completed generation. The system preserved automatic retries and error parsing, but deliberately eliminated recursive self-directed loops where a model executed a tool, evaluated output independently, and decided its next action. Instead, the user remained directly in the loop, verifying visual changes in the live workspace and guiding subsequent revisions.

A team deleted almost all our agent code: how it works

To manage strict context windows without losing project context as user codebases grew, the team introduced fine-tuned tiny language models dedicated entirely to dependency mapping. These auxiliary models scan the project hierarchy to identify which files the pending edit depends on, including relevant files that do not require modifications, and feed that targeted context to the primary coding model. To prevent recurring programming mistakes, Lovable discarded plans to train custom foundation models on product generation logs. Instead, engineers manually reviewed error logs from broken user applications and codified corrective instructions into plain text knowledge files retrieved dynamically via retrieval-augmented generation whenever relevant patterns arose.

Execution speed was maintained through persistent sandboxes that kept project files and active development servers running during sessions, avoiding full production rebuilds on minor edits. Incremental TypeScript compiler checks ran in parallel, reusing earlier compilation passes so the agent could consume structural errors and formulate fixes without halting execution. At the infrastructure layer, Lovable developed Camille, an internal framework engineered to fork and merge entire running virtual computers. Camille checkpoints process memory, CPU registers, file storage, and connected database instances, allowing the platform to snapshot live applications and let coding models experiment with alternative implementations from an identical system state.

A team deleted almost all our agent code: why it matters

Lovable's architecture shift demonstrates that software engineering constraints often deliver higher real-world reliability than raw model autonomy in commercial AI products. When co-founder Fabian and the founding team translated the spring 2023 GPT Engineer concept into Lovable, they deliberately constrained the problem space to greenfield applications. By eliminating an early selector that permitted customers to choose between multiple frontend technologies, the platform established a single opinionated software stack. This standardization granted engineering teams complete visibility over libraries, runtime dependencies, and error signatures, turning edge-case debugging into systemic platform patches that improved outcomes across tens of millions of distinct user deployments.

The pivot from model fine-tuning to text-based retrieval files highlights practical operational efficiencies for AI software teams. Relying on simple knowledge rules, such as restricting icon imports strictly to existing names within the lucide-react package, allowed developers to eliminate recurring hallucination patterns instantly without waiting for training runs. Applying this retrieval mechanism to an internal system called Lovable Stack Overflow, which matched known software errors with proven solutions, reduced the platform rate of users getting stuck by five percent. Coupled with snapshotting runtime environments, rapid feedback cycles proved more impactful than speculative autonomous planning loops.

A team deleted almost all our agent code: who is affected

The primary beneficiaries of these architectural decisions are non-technical creators and product builders who lack the programming knowledge required to debug broken codebases or untangle broken dependencies. Because greenfield users rely on the platform to resolve build failures automatically, eliminating open-ended loops replaced unpredictable processing delays with steady, predictable response cycles. Users gain consistent uptime and responsive live editing, while developers building on the platform experience fewer broken interfaces caused by imaginary library imports or misconfigured external dependencies. Every user request produces a single traceable set of file modifications that can be evaluated immediately in the rendered preview.

For external engineering teams developing agentic systems, Lovable's production record serves as an empirical case study against premature autonomous abstraction. Teams attempting to build self-directing multi-agent networks face identical failure modes around infinite loops, context pollution, and unpredictable completion latency. Lovable's technical trajectory illustrates that structuring model tasks around strict schemas, fast local execution checks, deterministic file tagging, and targeted context retrieval yields a more stable customer experience than delegating project management decisions to unconstrained agents. Infrastructure engineers can also adopt similar patterns by decoupling state checkpointing from source code repositories to support instant rollbacks.

A team deleted almost all our agent code: what to watch

Lovable faces three major engineering hurdles as it attempts to move beyond initial application generation into long-term software maintenance. The first challenge centers on automating post-creation engineering operations, requiring platforms to manage testing, deployment pipelines, uptime, scaling, and security without human supervision. Operating production applications introduces significant data liability, as a single misunderstood user command could destroy production databases or corrupt irreversible business records. To establish operational trust, automated systems must prove capable of detecting and remediating software defects before end customers encounter them in production environments.

The second and third milestones involve expanding compatibility across diverse software environments while re-engineering the underlying software development stack. Lovable plans to extend its automated construction workflows beyond standard web frontends to accommodate mobile software, desktop programs, complex asynchronous workflows, realtime data processing pipelines, and enterprise systems with specialized deployment constraints. Achieving this breadth requires developing execution environments that isolate different failure modes while maintaining low-latency state synchronization. Observers should track whether Lovable's Camille virtualization framework can scale database state branching across high-throughput production workloads as more customer applications handle real financial transactions.