Peter Steinberger: Shipping 6,600 Commits a Month as a Solo Developer with AI

⬅️ Back to Videos

▶️ Watch the Video

📝 VIDEO INFORMATION

• Content Type: Interview / Discussion
• Title: “Peter Steinberger: The Solo Developer Shipping Like a Company”
• Creator(s): Peter Steinberger (Interviewee), Interview Channel
• Platform: YouTube
• Duration: 1h 52m
• Publication Date: February 2025
• Link: https://www.youtube.com/watch?v=8lF7HmQ_RgY

E-E-A-T Assessment

• Experience: 5/5 - Peter built and scaled PSPDFKit into a global developer tools business, took a three-year break, and returned to ship OpenClaw (now one of the hottest AI projects). His 6,600 commits in January alone demonstrate firsthand mastery of AI-assisted development at scale.
• Expertise: 5/5 - Deep technical fluency across iOS development, AI agents, testing methodologies, and software architecture. Demonstrates sophisticated understanding of LLM capabilities, limitations, and optimal integration patterns.
• Authoritativeness: 5/5 - Founder of PSPDFKit, creator of OpenClaw/Clawdbot (now trending above Claude Code and Codex in search volume), recognized industry leader in developer tooling.
• Trust: 5/5 - Transparent about failures, burnout, and the learning curve with AI tools. Shares specific numbers (commits, timelines) and admits what he doesn’t know. No hidden agenda-genuinely sharing what works.

Verdict: Proceed with review - This is a primary source from a practitioner operating at the cutting edge of AI-assisted development. Peter’s track record, transparency, and specific operational details make this highly credible.

🎯 HOOK

One developer. 6,600 commits in a single month. Working from home. Having fun. Peter Steinberger isn’t just using AI to code, he’s reimagining what solo software development looks like when you fully embrace agents like Claude and Codex. This is what happens when one person operates with the velocity of an entire engineering team.

💡 ONE-SENTENCE TAKEAWAY

The future of software engineering belongs to developers who can orchestrate AI agents through tight feedback loops of code generation, automated testing, and rapid iteration, treating LLMs not as autocomplete but as collaborative teammates that require careful management and verification.

⚖️ VERDICT

Overall Rating: 9/10

This interview delivers exceptional value for anyone interested in the practical reality of AI-assisted development. Peter doesn’t theorize, he shares his actual workflow, commit counts, and hard-won lessons from shipping OpenClaw. The conversation spans technical implementation, business strategy, and personal philosophy. What’s missing is more detail on specific prompting techniques and agent orchestration code, though this may be intentional given OpenClaw is a competitive product. Essential viewing for developers wondering how to integrate AI into their workflow.

📊 EVALUATION CRITERIA

📖 SUMMARY

This nearly two-hour interview with Peter Steinberger offers a rare window into the workflow of a developer operating at the absolute frontier of AI-assisted software engineering. Peter, creator of OpenClaw (formerly Clawdbot) and founder of PSPDFKit, has become one of the most prolific individual contributors in tech-shipping 6,600 commits in January 2025 alone while working solo from home.

The conversation begins with Peter’s origin story: growing up in Austria, teaching himself programming, and eventually building PSPDFKit into a global developer tools business. This background is crucial context-Peter isn’t a novice who stumbled into AI productivity; he’s a seasoned engineer with deep experience building and scaling complex software systems. After selling PSPDFKit and taking a three-year break, he returned to building with a completely fresh perspective, this time with LLMs and AI agents at the center of his workflow.

The core of the interview explores what Peter calls “agentic engineering”-the practice of treating AI agents as collaborative teammates rather than fancy autocomplete. He explains how Claude and Codex have become integral to his development process, not just for writing code but for planning, testing, debugging, and even architectural decisions. The sheer velocity he achieves comes from tight feedback loops: generate code, automatically test, review results, and iterate. This approach requires rethinking many traditional software engineering practices.

A particularly compelling section covers Peter’s controversial stance on continuous integration and testing. His statement “I don’t care about CI” isn’t rejection of testing-it’s a doubling down on it. He runs extensive local testing before any push, using AI to generate comprehensive test suites. The goal is to catch issues before they reach CI, making the CI phase a formality rather than a debugging tool. This represents a fundamental shift: when AI can generate and run tests instantly, the economics of when and where testing happens change completely.

The interview also addresses the psychological and practical challenges of AI-assisted development. Peter discusses why many developers struggle with LLM coding-often due to prompting skills, verification discipline, or workflow integration issues. He shares his own learning curve and the habits he’s developed to work effectively with agents. The conversation touches on how planning has changed, how engineering judgment evolves when AI is involved, and what skills new graduates should focus on in this new paradigm.

Throughout, Peter maintains a grounded, practical perspective. He acknowledges AI’s limitations-hallucinations, context windows, the need for human verification-while demonstrating how to work within those constraints to achieve extraordinary results. The interview concludes with a rapid-fire round covering specific tools, workflows, and advice for developers at different stages of their careers.

What the Video Covers

The interview follows a clear chronological and topical structure:

(00:00) Introduction - Hook establishing Peter’s extraordinary productivity statistics and the central question: how does one person ship like an entire company?

(01:07) How Peter Got Into Tech - Origin story: Austrian childhood, self-taught programming, early developer jobs, and the path to founding PSPDFKit.

(08:27) PSPDFKit - Building and scaling a global developer tools business, lessons from enterprise sales, technical architecture decisions, and company culture.

(19:14) PSPDFKit’s Tech Stack and Culture - Technical details of building a PDF SDK, engineering practices, hiring philosophy, and what made the company successful.

(22:33) Enterprise Pricing - Psychology of pricing developer tools, the “contact us” model, and lessons learned from selling to large enterprises.

(29:42) Burnout - Peter’s experience with burnout after years of intense work, the warning signs, and why he ultimately stepped away from PSPDFKit.

(34:54) Peter Finding His Spark Again - The three-year break, what he learned from stepping away, and how he returned to building with a new perspective.

(43:02) Peter’s Workflow - The core section: detailed walkthrough of how he works with Claude and Codex, commit patterns, and daily routines.

(49:10) Managing Agents - How to treat AI agents as teammates, setting context, managing conversations, and maintaining coherence across long sessions.

(54:08) Agentic Engineering - Defining the discipline of working with AI agents, the skills required, and how it differs from traditional programming.

(59:01) Testing and Debugging - Peter’s testing philosophy, why he prioritizes local testing over CI, and how AI changes the testing equation.

(1:03:49) Why Devs Struggle with LLM Coding - Common pitfalls developers face when adopting AI tools and how to overcome them.

(1:07:20) How PSPDFKit Would Look If Built Today - Retrospective on architectural decisions and how AI would change the approach.

(1:11:10) How Planning Has Changed with AI - The evolution from detailed upfront planning to iterative, AI-assisted exploration.

(1:21:14) Building Clawdbot (Now: OpenClaw) - The genesis and development of Peter’s current project, an AI agent demonstrating the future of voice assistants.

(1:34:22) AI’s Impact on Large Companies - Observations on how established companies are (or aren’t) adapting to AI-assisted development.

(1:38:38) “I Don’t Care About CI” - Expanding on the controversial stance and what it reveals about testing in the AI age.

(1:40:01) Peter’s Process for New Features - Step-by-step walkthrough of how he approaches building new functionality with AI assistance.

(1:44:48) Advice for New Grads - Career guidance for developers entering the industry during the AI transition.

(1:50:18) Rapid Fire Round - Quick takes on tools, workflows, predictions, and personal preferences.

Who Created It & Why It Matters

This interview features Peter Steinberger as the primary subject, with an experienced technology interviewer guiding the conversation. Peter’s credentials are exceptional: he founded PSPDFKit, one of the most successful independent developer tools companies, bootstrapping it to global scale before selling. After a three-year sabbatical, he returned to building and immediately established himself as one of the most productive individual developers in the industry by any metric, commit count, feature velocity, or project impact.

What makes Peter’s perspective unique is the combination of deep traditional engineering experience with aggressive adoption of cutting-edge AI tools. He’s not a newcomer dazzled by AI hype; he’s a seasoned professional who has carefully integrated these tools into a proven workflow. His current project, OpenClaw (formerly Clawdbot), represents his vision for what AI agents can become, already generating more search interest than established tools like Claude Code or Codex.

The interview matters because it moves beyond speculation about AI’s impact on software development to concrete, operational details. Peter shares specific numbers, workflows, and failures. He demonstrates what’s possible when AI integration is done well, while being honest about the learning curve and limitations. For developers trying to navigate the transition to AI-assisted workflows, this is a masterclass from someone operating at the frontier.

Core Argument & Evidence

The central thesis is that AI-assisted development, done right, fundamentally changes the economics of software engineering, enabling individual developers to operate at the velocity previously requiring entire teams. This isn’t about AI replacing developers; it’s about developers who master AI tools operating at a different order of magnitude than those who don’t.

Evidence supporting this argument:

1. Commit volume: 6,600 commits in January 2025 alone, documented and verifiable
2. Project complexity: OpenClaw is a sophisticated AI agent, not a simple tool
3. Historical comparison: Peter’s previous success with PSPDFKit establishes baseline productivity without AI
4. Workflow specificity: Detailed explanation of how agents are integrated into daily work
5. Economic logic: When testing and iteration are essentially free (instant AI-generated tests), traditional bottlenecks disappear

Logical structure:

• Premise 1: Traditional development is bottlenecked by typing speed and testing overhead
• Premise 2: AI agents can generate code and tests at machine speed
• Premise 3: The limiting factor becomes verification and architectural decision-making
• Conclusion: Developers who master the verification/orchestration layer unlock 10x+ productivity

The argument is compelling because it’s grounded in specific operational details rather than abstract claims. Peter acknowledges counterarguments (AI hallucinations, context limitations, the need for human judgment) and explains how he works within those constraints.

Practical Applications

For experienced developers:

• Adopt agentic workflows gradually, starting with specific tasks like test generation
• Invest in local testing infrastructure to enable rapid iteration
• Develop prompting skills and context management techniques
• Rethink planning processes for AI-assisted exploration

For new developers:

• Focus on verification skills and architectural understanding over syntax memorization
• Learn to work with AI agents as collaborative tools
• Build traditional foundation while adopting AI workflows
• Prioritize problem decomposition and system design

For engineering managers:

• Consider how team structures change when individuals can ship like teams
• Evaluate which processes (like CI-heavy workflows) may become obsolete
• Invest in AI tooling and training for existing teams
• Watch for the productivity gap between AI-native and traditional developers

🔍 INSIGHTS

Core Insights

• The Commit Velocity Revelation: Peter’s 6,600 commits in January isn’t just a statistic, it’s proof of a new operational regime. When code generation and testing are instant, the limiting factor becomes decision-making speed, not typing speed. This fundamentally changes what “productivity” means in software engineering.

• Agent as Teammate, Not Tool: The most productive AI users treat agents as collaborative partners requiring context, management, and verification, not as fancy autocomplete. This shift in mental model changes everything from how you write prompts to how you structure work sessions.

• Testing Inversion: Peter’s “I don’t care about CI” stance represents a profound inversion. Instead of CI catching bugs, comprehensive local AI-generated testing makes CI a formality. The testing happens continuously during development, not after commits.

• The Verification Bottleneck: As AI generates code faster, human verification becomes the bottleneck. The skill that matters most shifts from writing correct code to quickly identifying incorrect code. This favors developers with strong architectural intuition and pattern recognition.

• Burnout as Signal: Peter’s three-year break and return with renewed energy suggests that AI-assisted development may actually be more sustainable than traditional approaches. The mental load shifts from implementation (tiring) to orchestration and verification (engaging).

• Planning vs. Exploration: Traditional detailed planning becomes less valuable when AI enables rapid exploration. The cost of trying an approach drops to near zero, making iteration cheaper than prediction.

• The Attention Economy of Context: LLMs have limited context windows, making context management a critical skill. What you include and exclude from the conversation increasingly determines output quality.

How This Connects to Broader Trends/Topics

• The Decade of Agents: This interview exemplifies Andrej Karpathy’s prediction that we’re in “the decade of agents.” Peter’s workflow shows what agentic software development looks like at scale, providing a concrete reference point for abstract predictions.

• Solo Developer Renaissance: AI is enabling a new generation of indie developers and small teams to compete with larger organizations. Peter’s productivity demonstrates the extreme end of this trend-what happens when one person can truly operate like a company.

• Software Engineering Skill Evolution: The skills that matter are shifting from syntax and API memorization toward architectural thinking, verification, and AI orchestration. This has implications for education, hiring, and career development.

• DevTool Disruption: Traditional developer tools (IDEs, CI/CD, testing frameworks) were built for human-speed development. Peter’s workflow suggests many of these may become obsolete or need fundamental redesign for AI-speed development.

• The Future of Work: Beyond software, Peter’s workflow offers a template for knowledge work in general, showing how human judgment and AI generation combine for maximum output. The pattern of human orchestration + AI execution likely generalizes across domains.

🛠️ FRAMEWORKS & MODELS

The Agentic Engineering Workflow

A framework for integrating AI agents into software development workflows at maximum velocity.

• Components:

  • Context packaging: Carefully curating what information goes into each agent session
  • Tight feedback loops: Generate → Test → Review → Iterate cycles measured in minutes, not hours
  • Local-first testing: Comprehensive test generation and execution before any commit
  • Verification discipline: Systematic human review of AI-generated output
  • Session management: Treating agent conversations as stateful collaborations

• How it Works: Rather than using AI for isolated tasks, the agent becomes a continuous collaborator throughout the development process. Context is carefully managed across sessions. Testing happens continuously at local speed. Human oversight focuses on architecture and verification rather than implementation details.

• Significance: This framework explains how individual developers can achieve team-level output. By optimizing the human-AI collaboration loop rather than just using AI as a tool, productivity increases by an order of magnitude.

• Evidence: Peter’s 6,600 monthly commits, the complexity of OpenClaw, and his description of daily workflows all support this model. The framework is descriptive (how he works) and potentially prescriptive (how others might adapt it).

The Testing Inversion Model

A reimagining of when and where testing happens in AI-assisted development.

• Components:

  • AI-generated test suites: Comprehensive tests created by agents before implementation
  • Local execution: Running tests immediately during development, not after commit
  • CI as formality: Continuous integration becomes verification of an already-tested system
  • Pre-commit quality gates: All quality checks happen before code leaves the local environment

• How it Works: Traditional development writes code, commits, then tests in CI. AI-assisted development generates tests first, writes code, tests continuously locally, and only commits when quality is assured. CI shifts from “find bugs” to “verify process was followed.”

• Significance: This inversion changes the economics of testing. When tests are instant and cheap to generate, there’s no reason to delay them. It also makes development more fluid, with no context-switching to fix CI failures hours after writing code.

• Evidence: Peter’s explicit “I don’t care about CI” statement and his description of local testing workflows. The model explains why his commit velocity is possible, as he’s not waiting on CI cycles.

The Attention Management Framework

A model for managing the critical resource in AI-assisted development: human attention and context.

• Components:

  • Context curation: Selecting what information to include in agent sessions
  • Conversation state: Maintaining coherence across long agent interactions
  • Verification focus: Allocating attention to highest-leverage verification points
  • Iteration pacing: Managing the speed of generate-test-review cycles

• How it Works: As AI generates code faster, human attention becomes the bottleneck. This framework treats attention as a resource to be actively managed, deciding what to verify, what to delegate, and what context to provide. The goal is optimal allocation of limited human cognition across unlimited AI generation capacity.

• Significance: Most developers struggle with AI tools because they don’t manage attention effectively, either micromanaging AI output or blindly accepting it. This framework provides a middle path of strategic oversight.

• Evidence: Peter’s discussion of managing agent conversations, why developers struggle with LLM coding, and his emphasis on verification skills over coding speed.

💬 NOTABLE QUOTES

1. “From the commits, it might appear like it’s a company. But it’s not. This is one dude sitting at home having fun.” Context: Peter describing his commit velocity and working style Significance: Captures the central theme-AI enables individual productivity at organizational scale. The “having fun” part is crucial; this isn’t grind, it’s flow state.

2. “I don’t care about CI.” Context: Peter’s controversial stance on continuous integration Significance: A deliberately provocative statement that forces reconsideration of testing norms. The deeper truth: when you test comprehensively before committing, CI becomes ceremonial.

3. “Closing the loop between code, tests, and feedback becomes a prerequisite for working effectively with AI.” Context: Discussing workflow requirements for AI-assisted development Significance: Identifies the core infrastructure need for agentic engineering-the tight feedback loop enables the velocity gains.

4. “Engineering judgment shifts with AI.” Context: How developer skills evolve when working with agents Significance: Acknowledges that the role of human developers changes-not eliminated, but elevated to judgment and verification.

5. “After about ten years I start to lose interest.” Context: Peter explaining his pattern of diving deep then moving on Significance: Reveals the psychology of a certain type of builder-driven by novelty and challenge rather than maintenance or recognition.

⚡ APPLICATIONS & HABITS

Practical Guidance

For Solo Developers:

• Start using Claude or Codex for 80%+ of new code. Force yourself to type less.
• Build local testing scripts that run in seconds, not CI pipelines that run in minutes
• Develop a “verify first” habit-always review AI output before accepting
• Keep agent context clean: start fresh sessions for new features, maintain context for iterations

For Engineering Teams:

• Pilot AI-assisted workflows with volunteers before mandating
• Invest in faster local development environments-latency kills AI-assisted flow
• Redefine code review to focus on architecture and verification, not style
• Consider whether your CI/CD investment still makes sense in an AI-first world

For Engineering Leaders:

• Track metrics that matter: feature velocity, not commits or lines of code
• Watch for the emerging productivity gap between AI-native and traditional developers
• Invest in training for prompting, verification, and agent management
• Prepare for organizational changes as individuals become more capable

Implementation Strategies

Week 1-2: Observation

• Document current workflow and identify highest-friction tasks
• Experiment with AI on isolated, low-stakes tasks
• Notice where you accept vs. reject AI suggestions

Week 3-4: Integration

• Use AI for 50% of new code in a specific module
• Build local test automation to enable rapid iteration
• Develop personal prompting patterns that work

Month 2: Optimization

• Achieve 80%+ AI-assisted code generation
• Establish tight feedback loop (< 2 minutes from prompt to verified code)
• Document what works for your specific context

Month 3+: Mastery

• Continuous refinement of context management
• Develop custom tools and workflows for your stack
• Consider open-sourcing or sharing your approach

Common Pitfalls to Avoid

Micromanaging the AI

• Don’t treat AI like a junior dev needing constant correction
• Give clear requirements, let it execute, then verify
• Resist the urge to rewrite AI code that works

Blind Acceptance

• Never commit AI-generated code without review
• Watch for subtle bugs that look correct at first glance
• Maintain mental model of what the code should do

Ignoring Context Limits

• LLMs have finite context-don’t dump entire codebases
• Learn to package relevant context efficiently
• Start fresh sessions when context gets polluted

Forgetting Fundamentals

• AI doesn’t replace understanding of architecture
• Verification requires knowing what correct looks like
• The better your engineering judgment, the more value AI provides

Workflow Friction

• If your local test suite takes > 30 seconds, optimize it
• Latency kills the tight feedback loop that makes AI productive
• Invest in development environment speed

📚 REFERENCES & SOURCES CITED

• PSPDFKit: Peter’s previous company, a PDF SDK for developers. Serves as evidence of his ability to build and scale developer tools independently.

• OpenClaw / Clawdbot: Peter’s current AI agent project, demonstrating “what the future of Siri could be like.” Currently trending above Claude Code and Codex in search volume.

• Claude (Anthropic): Primary AI tool Peter uses for coding, reasoning, and workflow assistance.

• Codex (OpenAI): Secondary AI coding tool in Peter’s workflow.

• Commit Statistics: Peter’s claim of 6,600 commits in January 2025-verifiable through his GitHub activity.

• ImageNet 2012: Referenced in the AI evolution discussion, the competition that sparked the deep learning revolution.

• Geoffrey Hinton: Mentioned in the broader context of AI development history.

⚠️ QUALITY & TRUSTWORTHINESS NOTES

• Accuracy Check: Peter’s claims about commit counts and project specifics are verifiable through public GitHub activity. His background with PSPDFKit is well-documented. The workflow descriptions are detailed enough to be falsifiable, as others can attempt to replicate and verify.

• Bias Assessment: Peter has clear enthusiasm for AI-assisted development, which is expected given his results. However, he’s transparent about limitations, failures, and the learning curve. No financial stake in promoting specific tools beyond genuine preference. Potential bias toward workflows that work for solo developers (may not generalize to large teams).

• Source Credibility: Primary source-this is Peter describing his own workflow. Highly credible for his personal experience. Less authoritative for claims about broader industry trends, though his track record suggests good judgment.

• Transparency: Excellent transparency about burnout, failures, and what he doesn’t know. Willing to share specific numbers and admit when he’s guessing. No undisclosed conflicts of interest apparent.

• Potential Harm: Low risk of harm. The “I don’t care about CI” stance could be misinterpreted by junior developers as advice to skip testing (the opposite of Peter’s actual practice). The productivity claims might discourage developers who don’t achieve similar results immediately. Neither constitutes serious harm.

🎯 AUDIENCE & RECOMMENDATION

Who Should Watch:

• Professional Software Developers: Essential viewing for understanding how AI changes the practice of software engineering. Peter’s workflow offers a concrete model to adapt.

• Engineering Managers: Critical for understanding how team productivity and structure may evolve. The interview suggests significant changes to traditional engineering management.

• Technical Founders and Indie Hackers: Highly relevant for those building with small teams. Peter demonstrates what’s possible with AI augmentation.

• Computer Science Students: Important for understanding how the field is changing and what skills to prioritize.

• AI Researchers and Product Builders: Useful for understanding real-world usage patterns and pain points from a sophisticated user.

Who Should Skip:

• Complete Programming Beginners: The discussion assumes familiarity with software engineering concepts, testing practices, and development workflows. May be overwhelming without that foundation.

• Those Seeking Entertainment: This is a technical interview, not a polished documentary. The value is in the information density, not production value.

• AI Skeptics Looking for Validation: Peter is clearly optimistic about AI’s impact. Skeptics won’t find arguments against AI-assisted development here.

Optimal Viewing Strategy:

• Speed: 1.25x-1.5x speed works well. The conversation is information-dense but not rushed.

• Sections to prioritize:

  • 43:02 - Peter’s Workflow (core content)
  • 54:08 - Agentic Engineering (key framework)
  • 59:01 - Testing and Debugging (controversial and thought-provoking)
  • 1:21:14 - Building OpenClaw (practical application)

• Note-taking: Consider taking notes on specific workflow details, tools mentioned, and the testing philosophy. These are actionable and specific.

• Follow-up: After watching, try implementing one aspect of Peter’s workflow (e.g., AI-generated tests) before returning to absorb more.

Meta Notes: Review written based on detailed transcript and content summary provided. The information density is high-this is a video that rewards multiple viewings or careful note-taking on the first pass.

Crepi il lupo! 🐺