The creator of Clawd: "I ship code I don't read"

SUMMARY

Gergely Orosz interviews Peter Steinberger, founder of PSPDFKit and creator of Moltbot, exploring his tech origins, company growth, burnout recovery, and AI-driven workflows revolutionizing solo software engineering.

STATEMENTS

Peter Steinberger grew up in rural Austria as an introvert and got hooked on computers at age 14 after tinkering with a summer guest's machine.
He financed his university studies through full-time work, starting with a six-month job in Vienna that lasted five years, where he modernized legacy systems using .NET without permission.
Steinberger discovered iOS development after frustration with a gay dating app's JavaScript issues on the iPhone, leading him to download Xcode and build his first app by parsing HTML.
His debut app, a native client for the dating site, earned $10,000 in the first month despite using beta technologies like iPhone OS 3 and backported blocks.
Apple rejected the app due to user-reported pictures, prompting Steinberger to freelance and move to the US after networking at dublinc.
While in San Francisco, he rewrote a crashing magazine viewer app into a robust PDF framework, taking two months instead of one due to performance optimizations under iPad's memory constraints.
Steinberger sold the PDF component to others, initially via a hacked WordPress site on GitHub Pages, earning $200 in the first week and feedback that spurred feature additions like text selection.
PDF rendering proved deceptively complex, involving edge cases like 500,000 links in a 50,000-page document that required redesigning data models for lazy loading without breaking the API.
He bootstrapped PSPDFKit remotely from Vienna, focusing on developer experience with insightful blog posts and conference talks to drive inbound sales.
The tech stack evolved from Objective-C to Swift, C++ for cross-platform rendering, and early WebAssembly support, including a benchmark that influenced Google, Microsoft, and Apple optimizations.
PSPDFKit's culture emphasized proposals for every feature, conservative API changes, and the Boy Scout rule, with a remote-first team growing to 70 under Steinberger's leadership.
Enterprise pricing was customized based on company size and value, avoiding fixed lists to balance accessibility for freelancers and appeal to Fortune 500 firms.
Selling to enterprises required building features like MCP for AI agents, highlighting the need for permissions, auditability, and security beyond traditional OAuth.
Steinberger burned out from overwork, managerial isolation, team conflicts, and crises like a major airline's planes grounding due to tampered code, leading him to sell shares after 13 years.
Post-exit, he decompressed for three years, avoiding computers and grappling with early retirement's mental toll before returning in April to build a Twitter analytics tool using AI.
He skipped early AI hype, starting with Claude Code's beta, which enabled rapid prototyping by generating specs and code, though initial runs crashed until loops were closed.
AI coding feels addictive like a slot machine, with prompts yielding mind-blowing results despite occasional failures, shifting focus from line-by-line details to architecture.
Steinberger uses multiple agents in parallel via tools like Cursor, Gemini, and especially Codex, which reads code silently for better context than Claude's quick assumptions.
Effective AI engineering demands closing feedback loops: agents must compile, test, debug, and verify output themselves, making code verifiable unlike creative writing.
He manages agents conversationally, discussing options and architecture before triggering builds, acting as a "builder" rather than hands-on coder.
Vibe coding frustrates those loving algorithmic challenges, but succeeds for product-focused builders who iterate and let go of perfectionism learned from managing teams.
Building Moltbot began as a WhatsApp relay for local automation, evolving into a hyper-personal AI assistant via voice, images, and proactive tasks like reservations.
Moltbot's magic stems from blending complexity: it hatches with user values, maintains evolving memory files, and accesses CLIs for emails, calendars, and home automation.
CLIs outperform MCPs for agents due to scripting flexibility, filtering, and chaining without bloating context, though MCPs pushed API openness.
The project exploded after adding Discord support, reaching 3,300 stars and 500 merged PRs in a week, with Steinberger reviewing prompts over code.
In larger companies, AI could shrink teams to 30% with senior agent-wranglers, but requires refactoring codebases and cultures for verifiable, iterative designs.
Pull requests become "prompt requests"; CI is local and agent-run for speed, emphasizing architecture discussions over code reviews.
New grads should cultivate curiosity, explore open-source with AI explanations, and build iteratively, unburdened by legacy habits.
Steinberger's workflow yields 600+ commits daily, shipping unread code via trusted loops, prioritizing taste and system feel over plumbing details.
AI democratizes personal assistants, evolving from reactive tools to proactive companions understanding patterns in emails, calendars, and social data.
Blogging about hard problems attracts talent and serves as living documentation, with PSPDFKit mandating monthly posts to foster insight-sharing.
Burnout arises not just from hours but disbelief in the work, amplified by democratic management mistakes and unresolved conflicts.
Returning to tech post-hiatus felt painful due to skill gaps in web tech, but AI bridged them, turning friction into symbiosis.
Optimizing for agents means designing testability upfront, yielding better architecture than manual coding's tedium.

IDEAS

Rural introverts can bootstrap global tech success through relentless tinkering and opportunistic hacks like HTML parsing for early apps.
Frustration with platform limitations, like no copy-paste on iPhone OS 2, sparks innovation, leading to native apps that monetize unexpectedly.
Beta technologies and forum-sourced knowledge enable solo developers to outpace incumbents, as seen in backporting blocks to iPhone OS 3.
Rejection by gatekeepers like Apple fuels independence, turning freelancers into founders via networking in unlikely places like 2 a.m. bars.
Rewriting legacy "house of cards" codebases reveals domain complexities, like PDF memory constraints on iPad, demanding surgical optimizations.
Informal sales via Dropbox links and Twitter evolve into businesses when feedback loops reveal unmet needs, like PDF text selection.
Deceptively simple specs hide madness; PDF's 500,000-link edge cases force lazy loading redesigns without API breaks.
Developer-centric marketing via blogs and conferences builds loyalty, as engineers lobby internally more effectively than cold emails.
Benchmarks can gamify improvements, pressuring competitors like Google to optimize your renderer indirectly.
Conservative cultures with proposals and Boy Scout rules sustain large APIs used by billions, prioritizing stability over novelty.
Custom enterprise pricing reflects value extraction, balancing freelancer access with Fortune 500 procurement thresholds.
Burnout stems from overwork plus existential doubt, exacerbated by CEO isolation and crises like client-induced outages.
Three-year decompressions rebuild purpose, but early financial independence triggers identity crises akin to premature retirement.
AI tools like Claude Code bypass tech-stack friction, letting experts prototype in unfamiliar languages via system understanding.
Prompting feels like casino economics: unpredictable rewards hook users, shifting from bike-shedding to architectural flow.
Parallel agents mimic team management, but demand mental juggling, turning solo work into exhausting symbiosis.
Closing loops—agent self-testing—elevates AI coding over creative tasks, enforcing verifiable architectures.
Vibe coding thrives for outcome-focused builders, but alienates algorithm purists who reject tool-assisted problem-solving.
Hyper-personal agents evolve Siri into proactive companions, analyzing Instagram for friend nudges or mood patterns from meetings.
CLIs enable resourceful agent scripting, filtering data dynamically unlike rigid MCP JSON blobs.
Open-sourcing risky features, like Discord bot access, virally explodes projects through live demos of magical interactions.
Prompts signal skill more than code; reviewing them reveals steering quality over output polish.
AI shrinks teams to high-agency architects, but demands cultural refactors, risking economic upheaval for mid-level roles.
Upfront planning diminishes as cheap iteration allows playful chiseling, like sculpting marble from rough ideas.
Bootstrapping agents with user souls creates emotional bonds, blending tech into friendly, evolving personas.
Weaving code via agents prioritizes taste and structure, rendering traditional PRs obsolete as prompt requests.
Local CI via agents accelerates merges, trading occasional main-branch slips for 10x speed over remote waits.
New grads' lack of baggage lets them innovate with agents, querying open-source for system insights patiently.
600-commit days prove AI enables company-like output from one person, if loops ensure non-sloppy results.

INSIGHTS

Solo hyper-productivity emerges when AI agents handle plumbing, freeing humans for architectural taste and iterative playfulness.
Feedback loops transform AI from frustrating autocomplete to reliable builders, as verifiability crushes untestable creativity.
Burnout recovery demands total disconnection, revealing purpose through rediscovered tinkering rather than forced reinvention.
Developer tools succeed via felt polish over features; AI amplifies this by automating tedium while preserving delight.
Enterprise value pricing mirrors AI's contextual adaptation: one-size-fits-all excludes extremes, custom fits extract true worth.
Legacy friction in new stacks hurts experts most; AI bridges gaps, turning pain into symbiotic learning acceleration.
Parallel agent management exhausts like leading a team, but scales output exponentially for outcome-driven architects.
Prompts outshine code reviews: they expose thinking processes, enabling direct agent handoffs for feature realization.
CLIs democratize agent empowerment over MCPs, enabling chained, filtered automation without context bloat.
Viral open-source magic hides engineering depth; live demos of proactive bots hook users beyond static descriptions.
Cultural refactors precede AI adoption: companies must evolve from siloed roles to high-agency builders or face shrinkage.
Curiosity trumps code volume for new grads; agent-assisted exploration of open-source builds irreplaceable system intuition.
Weaving supplants merging: AI integrates contributions fluidly, prioritizing architectural fit over line-by-line scrutiny.
Personal agents foreshadow soul-like companions, proactively weaving life data into insightful, boundary-blurring interactions.
Playful iteration erodes waterfall planning; cheap builds reveal truths upfront specs can't, spiraling toward optimal designs.
High-agency hiring favors open-source gamers over rote coders; AI rewards those who treat workflows as skill-building quests.

QUOTES

"From the commits, it might appear like it's a company. But it’s not. This is one dude sitting at home having fun."
"I stole an old DOS game from my school and then wrote a copy protection for the floppy disc so I could sell it."
"I typed this long message... and then an error message came but there was no copy paste. There was no screenshot. So I was just like... this is unacceptable."
"I put it in the app store. I charged five bucks for it and I made like 10k in the first month."
"Yeah, something is weird. Like I got this huge payment from Apple. This is mine. This is mine. Don't touch it."
"You're making a mistake. This is a fad. This will not go."
"That got me... a chip on your shoulder. One day I'm going to have a company that's worth more money than yours."
"PDF rendering is a good example. You look at it and think, how hard could it be? And then you spend months on edge cases."
"I know more about PDF than any sane human person ever should know. And I went to therapy. Good luck."
"Software is all about how it feels much more so than the feature set."
"I'm not going to find the people that I need in Vienna. So it was always just like remote first."
"As a CEO, you're basically the waste bin cuz everything that other people don't manage or can do or mess up, you have to fix."
"Burnout doesn't necessarily come from working too much. It comes more from when you work on something but you don't believe in it anymore."
"It's the same economics as you go to a casino. You press the trigger and ding ding ding ding ding."
"I ship code I don't read."
"Most apps are just chasing printers. The hard part is solved by Postgres 30 years ago by some nerd birds."
"To be effective with coding agent is always like you have to close the loop. It needs to be able to debug and test itself."
"I could easily run a company with 30% of the people."
"Pull requests should be called prompt requests."
"I don't care about CI."

HABITS

Tinkering daily since age 14, starting with DOS games and evolving to modern AI prototypes.
Financing self through relentless full-time work during university, prioritizing independence.
Modernizing legacy code silently, like switching to .NET without disclosure, to deliver results.
Downloading tools impulsively after frustrations, such as Xcode post-dating app mishap.
Prototyping with beta tech and forums for rapid iteration, despite initial failures.
Networking at late-night events like dublinc to land US opportunities.
Obsessing over details like page rotation animations, extending timelines for polish.
Upping prices incrementally as features grow, based on inbound demand.
Focusing marketing solely on developers via blogs and conferences for organic advocacy.
Mandating monthly full-day blog posts for the team to share insights and attract talent.
Handling support personally as CEO to build magical response times under five minutes.
Decompressing completely post-burnout, avoiding computers for months to rebuild.
Starting projects with AI specs from messy repos, dragging Markdown into tools like Claude Studio.
Prompting conversationally to explore options before builds, avoiding premature triggers.
Running multiple agents in parallel, switching contexts to maintain flow while tasks cook.
Closing loops by designing verifiable systems, ensuring agents self-test via CLIs.
Weaving community PRs into architecture discussions, prioritizing prompts over code.
Updating bots self via commands, letting agents fetch and integrate changes.
Leaving phone in locker during gym sessions for distraction-free presence.
Walking without phone to combat dependency, embracing temporary disconnection.

FACTS

PSPDFKit renders PDFs on over 1 billion devices globally.
Steinberger committed over 6,600 times in January alone as a solo developer.
Moltbot garnered more Google searches than Claude Code or Codex at launch.
He earned $10,000 in the first month from a $5 dating app in 2009.
PDF specs allow up to 500,000 links in a single 50,000-page document.
The company grew from solo to 70 employees under Steinberger, now nearly 200.
Early WebAssembly PDF benchmark influenced optimizations by Google, Microsoft, and Apple.
A single client crisis grounded an airline's planes due to tampered PSPDFKit code.
Three-year hiatus involved months without touching a computer.
Claude Code beta launched in February, with full release in May.
Steinberger achieved 600 commits in one day using AI agents.
Moltbot repository gained 3,300 stars and 500 merged PRs in a week.
AI survey: 82% of developers code faster with AI, but 96% distrust its accuracy.
Sonar analyzes 750 billion lines of code daily, or 8 million per second.
Notion scaled from single-digit to 300+ experiments quarterly using Statsig.
WorkOS introduced MCP for AI agent authentication with granular permissions.

REFERENCES

PSPDFKit: PDF framework built and scaled by Steinberger.
Moltbot (formerly Clawdbot/Claudebot): AI agent for personal assistance via messaging.
Xcode: Tool downloaded to build first iOS app.
iPhone OS 3 beta with Core Data: Used for early dating app.
Hacked GCC for blocks backport: Enabled advanced features prematurely.
WordPress template on GitHub Pages: Initial sales site for PDF component.
Dropbox: Hosted source code zips for buyers.
Twitter (now X): Platform for sharing project and networking.
Fastlane: Tool mentioned in sales flow.
Microsoft MFC book: Nightmare-inducing legacy tech at first job.
.NET 2.0 with generics: Switched to secretly for modernizations.
Objective-C: Primary language for early PSPDFKit.
Swift: Later adoption for iOS development.
C++ renderer: Cross-platform shift for bug reduction.
WebAssembly: Early PDF framework support with custom benchmark.
Statsig: Unified platform for flags, analytics, experiments.
SonarQube: Automated code review standard.
WorkOS: Enterprise readiness tools with MCP for AI.
Claude Code: Primary AI tool for initial prototyping.
Cursor: IDE phase for AI-assisted coding.
Gemini 1.5: Experimented with for coding tasks.
Codex (o1): Preferred for complex application building.
FFmpeg: Used by agent for voice conversion.
OpenAI Whisper: For voice-to-text in Moltbot.
Anthropic models: Core for Moltbot's reasoning.
Mario's plugin architecture: Inspired dynamic loading in TypeScript.
Doctor Who: Source of Claudius naming joke.
Black Mirror "Plaything": Episode evoking agent companionship.
Factorio: Game compared to building satisfaction.
Her: Movie inspiring hyper-personal AI vision.

HOW TO APPLY

Start tinkering young: Beg for a computer and experiment with games or scripts to build foundational curiosity.
Finance independence early: Work full-time during studies to avoid debt, using earnings for tools like an iPhone.
Hack frustrations into apps: When a platform fails (e.g., no copy-paste), parse sources like HTML to create native fixes.
Prototype with betas: Use unstable tech like iOS 3 betas and forums to iterate fast, accepting initial breakage.
Monetize quickly: Charge modestly ($5) for apps, deposit earnings securely, and scale prices with features.
Network opportunistically: Attend events like dublinc at odd hours to land gigs or moves abroad.
Rewrite legacies surgically: Stabilize crashing code first, then refactor fully, documenting assumptions.
Sell components modularly: Extract reusable parts (e.g., PDF viewer) and market via simple sites like GitHub Pages.
Gather feedback loops: Respond to complaints by adding features like text selection, turning users into advocates.
Optimize for constraints: Handle memory limits (e.g., 64MB on iPad) with careful background ops and animations.
Blog technical depths: Write about hard problems monthly to attract talent and create living docs.
Price enterprises custom: Assess company scale and value during calls, avoiding public lists to fit diverse needs.
Handle support CEO-style: Reply to tickets in minutes, disassembling apps for root causes like license tampering.
Decompress fully post-burnout: Avoid screens for months, catching up on life to rediscover spark.
Restart with AI specs: Convert repos to Markdown, prompt for 400-line specs, then build iteratively.
Prompt addictively: Treat as slots—input ideas, refine on outputs, closing loops with self-tests.
Parallelize agents: Launch 5-10 via Codex, switching contexts while tasks run, maintaining flow.
Design verifiable architectures: Build CLIs for fast loops, ensuring agents compile, lint, and verify.
Evolve personal bots: Bootstrap with user values, letting agents maintain memory and self-update.
Viralize via demos: Add public channels like Discord for live interactions, merging community PRs promptly.
Refactor for agents: Weave features into plugins, referencing past solves to inspire without re-explaining.
Hire high-agency: Seek open-source players who treat AI as a game, prioritizing curiosity over code volume.

ONE-SENTENCE TAKEAWAY

AI agents empower solo builders to scale company-level output through verifiable loops and architectural focus.

RECOMMENDATIONS

Embrace AI from hiatus: Dive into tools like Claude Code post-breaks to bridge stack gaps without pain.
Prioritize felt polish: Build as if Apple would, focusing on delights over raw features for developer loyalty.
Blog hard-won insights: Share edge cases monthly to document, inspire, and attract aligned talent.
Customize enterprise deals: Tailor pricing to value and scale, using calls to gauge willingness without lists.
Decompress radically: Go computer-free for months after burnout to rebuild belief and purpose.
Close every loop: Design systems for agent self-verification via tests and CLIs to ensure reliability.
Prompt conversationally: Discuss options before builds, treating models as architects for better explorations.
Parallelize ruthlessly: Juggle 5-10 agents to sustain flow, treating waits as opportunities for new tasks.
Weave over merge: Integrate PRs via prompts, prioritizing architecture and taste above line details.
Build CLI armies: Automate everything scriptably, outperforming MCPs for flexible, low-context chaining.
Bootstrap agent souls: Hatch bots with user values for evolving, emotional companionship beyond tools.
Viralize magically: Demo live in public channels to hook users, blending tech into friendly interactions.
Refactor cultures first: Trim to 30% high-agency builders before AI, redefining roles for product visionaries.
Iterate playfully: Underprompt for surprises, chiseling ideas cheaply to evolve designs spirally.
Review prompts foremost: Demand them in issues/PRs for signal on steering, handing off to agents directly.
Localize CI: Run gates via agents for speed, accepting minor slips over remote delays.
Cultivate curiosity: New grads, query open-source with AI for system understanding, building via pain.
Update self: Let agents fetch and integrate changes, minimizing manual onboarding friction.
Filter dynamically: Use CLIs for precise data pulls, avoiding MCP bloat in agent contexts.
Evolve proactivity: Weave life data (calendars, social) into agents for insightful, pattern-based nudges.
Optimize verifiably: Frontload testability in designs, yielding superior architecture over manual tedium.

MEMO

Peter Steinberger's journey from rural Austrian tinkerer to AI-powered solo phenom underscores a seismic shift in software creation. At 14, he begged for a computer after a summer guest's machine ignited his passion, leading to high school hacks like floppy-disk copy protection. University demanded self-finance through grueling Vienna jobs, where he quietly modernized MFC nightmares with .NET, honing a pragmatic edge. A 2009 subway frustration—no copy-paste on iPhone OS 2's dating app—sparked his iOS leap: parsing HTML into a $10,000/month native client, using betas and forums despite Apple's later rejection. Freelancing in San Francisco, he rewrote a crashing magazine app into PSPDFKit's core, battling PDF's arcane edge cases like 500,000-link tomes that demanded lazy-loading overhauls without API ruptures.

Scaling PSPDFKit to 70 remote souls, Steinberger obsessed over developer delight: insightful blogs drew talent, conferences built advocacy, and a C++ renderer with WebAssembly benchmarks goaded Google into speed-ups. Enterprise sales thrived on custom pricing—dice-rolling value for Fortune 500s—while culture enforced proposals and Boy Scout cleanliness for billion-device stability. Yet, 13 years eroded him: weekends blurred into crises, like an airline grounded by tampered code, and democratic mismanagement bred conflicts. Burnout hit not from hours alone, but disbelief amid isolation; selling shares yielded freedom, but three screen-free years wrestled premature retirement's void.

Reignited in April, Steinberger bypassed AI skepticism, dragging repos into Claude Code for specs and builds—crashing at first, but looping to self-debug. Addiction ensued: prompts as slot machines, yielding 600-commit days where he ships unread code, trusting verifiable architectures over bike-shedding. Parallel agents via Codex weave plumbing; he architects conversationally, closing loops with CLIs for compilation and tests, far surpassing Claude's hasty assumptions. Vibe coding suits outcome chasers like him, but repels algorithm purists—mentally taxing as juggling teams, yet exhilaratingly game-like.

Moltbot (ex-Clawdbot) embodies this: born as WhatsApp relay for Morocco automation—waking via SSH music, joking on voice memos—it evolved into a hyper-personal Siri-killer. Resourceful on betas like Opus, it hatches souls from user values, maintains evolving memories, and accesses CLIs for calendars, cams, even restaurant calls. Viral via Discord demos—DJing, screen-rants—it hit 3,300 stars weekly, with Steinberger merging 500 PRs as "prompt requests," weaving via agents over traditional reviews. CLIs trump MCPs for scriptable flexibility, hiding token-hungry magic in friendly chats.

For larger firms, AI portends 30% headcount via senior wranglers, but demands code and cultural refactors—pulls as prompts, local CI gates. New grads, unscarred by legacy, thrive querying open-source curiously, blending fundamentals with agent play. Steinberger's flow endures, more exhausting yet potent: one man emulating companies, proving AI's solo revolution while warning of economic fiascos for the unadapted. As prompts eclipse code, software's future chisels playfully from marble, verifiable and tasteful.