A solo founder's playbook for maintaining a 300k-line codebase with AI agents

Peter Steinberger reportedly uses a specific stack of CLI tools and agentic principles to manage a complex, multi-platform application. The system relies on persistent context, structural linting, and scheduled refactoring.

Peter Steinberger, a solo founder, reportedly maintains a 300,000-line TypeScript React ecosystem using AI agents. The claim, from a presentation in London, encompasses a web app, Chrome extension, CLI tool, desktop client, and mobile app, all managed by one person.

His method is not a vague appeal to “AI copilots.” It is a specific, opinionated system of command-line tools, persistent development environments, and structured prompting designed to make AI a predictable, auditable contributor to a complex codebase.

A persistent, multi-agent environment

Steinberger’s workflow runs on tmux, a terminal multiplexer that keeps sessions alive. This is foundational. He runs what the source describes as three to eight parallel instances of Codex, allowing multiple agents to work on different tasks simultaneously without losing context. The principle is to avoid cold starts. Instead of resetting context between sessions, work is handed over, preserving momentum and reducing token waste.

Structural linting and atomic commits

To manage agent-generated code, Steinberger uses ast-grep as a pre-commit hook. Abstract Syntax Tree (AST) based linting provides structural analysis that regular expressions cannot, catching more sophisticated errors before they enter the codebase. Commits are small and atomic, containing only the changes made by a single agent task. This discipline makes agent contributions easy to review and, if necessary, revert. This turns the AI from an unpredictable black box into a contributor with a clear, auditable history.

Voice, vision, and validation

The primary interface is not typing. Steinberger uses voice input, citing Superwhisper and a tool called justspeaktoit as ways to dictate intent faster than typing. For front-end work, he provides screenshots directly to the model. The model actually understands layouts from screenshots better than from your description of the layout. Before executing a complex task, he prompts the model to present a list of options. This forces the agent to reason about its plan, allowing the developer to select the best path forward instead of correcting a flawed guess.

Scheduled, tool-assisted refactoring

Technical debt is managed proactively. Twenty percent of development time is reportedly allocated to refactoring. This is not an unstructured process. It is guided by specific tools: jscpd for detecting copy-pasted code, knip for finding unused files and exports, and oxlint for general code quality checks. This systematic approach prevents the gradual decay common in large, rapidly developed projects.

What we'd change

The playbook is a strong snapshot of solo development in 2026, but it has dependencies. The reliance on specific tools like ast-grep, knip, and jscpd creates a rigid stack. While effective, a developer adopting this would need to commit to this exact toolchain or find precise equivalents. The principles are more durable than the products.

The workflow is also highly model-dependent. It was built around Codex-family models, which have specific performance and cost characteristics. A switch to a more powerful but slower model, or a less capable but faster local model, would require significant adjustments to the “3-8 parallel instances” approach. The economics of running multiple agents constantly could also become prohibitive with different pricing structures.

Finally, the system excels at implementation and maintenance, but the source material does not address its use for high-level architectural decisions. The playbook details how to get agents to write and refactor code within an existing structure. It offers less guidance on how to use them to design that structure in the first place. This is a critical omission for anyone starting from a blank slate.

Landing

Steinberger's reported system is less about a single “10x” tool and more about creating a development environment where AI agents can function like a disciplined junior team. The combination of persistent context, atomic commits, and structured refactoring provides the guardrails necessary for managing AI-generated code at scale. While the specific tools will inevitably change, the underlying principles of auditability, context preservation, and systematic quality control offer a durable model for solo founders building complex products.

The investor read

This playbook signals a significant increase in capital efficiency for technical solo founders. The claim of maintaining a 300k-line multi-platform codebase solo, if accurate, redefines the scale achievable by a single engineer. This lowers the threshold for what constitutes an investable 'team,' particularly for developer tools and infrastructure products where deep technical execution is the primary moat. Investors should watch for founders who have not just adopted AI tools, but have implemented a rigorous system for managing AI contributions, as described here. The most valuable opportunities may be in the tooling layer that enables this kind of structured, auditable agentic workflow. This is a deliberate bootstrapped/lean-team play that can achieve venture scale.

Pull quote: “The model actually understands layouts from screenshots better than from your description of the layout.”