Deep Dive: Shipping at Inference-Speed #

I. Article Overview #

1.1 Author Background #

Peter Steinberger (known as steipete) is a prominent figure in the iOS development world. In 2011, he founded PSPDFKit — a technology company focused on PDF processing SDKs. He bootstrapped it for ten years before a successful exit in 2021 (the company later received $116 million in funding). Prior to that, he worked as a senior iOS engineer in San Francisco and is an active open-source contributor and conference speaker, splitting his time between Vienna and London.

After exiting PSPDFKit, Steinberger shifted entirely to AI-native development, becoming one of the most influential individual developers in the 2025 “Agentic Engineering” movement. In a single month, he created over 6,600 git commits, and his AI agent project Clawdis briefly grew faster than Tailwind CSS on GitHub.

1.2 One-Sentence Summary #

A senior developer with 15 years of deep engineering experience spent 3 months and $51K in API costs to develop an extreme workflow for “shipping software at AI inference speed” — he barely reads AI-generated code anymore, instead focusing entirely on architecture design and system verification.

1.3 Writing Context #

This long-form piece was written at the end of December 2025, roughly half a year after GPT-5’s release and shortly after GPT-5.2. The author notes that in May 2025, he was still amazed that “prompts could generate working code” — by year’s end, this had become a baseline expectation. The article is a retrospective of his own half-year extreme practice — not theoretical speculation, but a distillation of extensive firsthand engineering experience.

II. Core Content Analysis #

2.1 Key Insights Breakdown #

Insight 1: Inference Speed = Shipping Speed #

Steinberger’s core thesis: “The amount of software I can create is now primarily limited by inference time and deep thinking.”

His argument: Most applications are essentially data flowing between forms, storage, and display — tasks with limited architectural complexity. When AI models can reliably handle coding execution, the human output bottleneck shifts from “writing code” to “waiting for model inference” and “making architectural decisions.” This is what “shipping at inference speed” means — your release cadence is tied to the model’s inference speed.

Insight 2: Model Transformation — GPT-5’s Key Unlock #

The author views GPT-5 as the turning point for “factory-scale building.” Before it, models were unstable on large refactoring tasks; after GPT-5, his work approach fundamentally changed:

“I no longer read code line by line — instead, I watch the output stream, occasionally focusing on key sections.”

His attention shifted from code details to system-level concerns: overall architecture, component relationships, structural design. This represents a role leap from “programmer” to “architect + AI conductor.”

Insight 3: The “No Longer Reading Code” Workflow #

This is the article’s most controversial point. Steinberger claims he ships large amounts of AI-generated code he has never fully read. His defense logic:

1. Extensive agent interaction builds intuition — he can sense by experience how long a task should take, and immediately notices when a model gets stuck
2. CLI-first strategy — all projects start as command-line tools, so agents can directly run and verify output, forming a closed testing loop
3. Code isn’t the goal, working functionality is — he focuses on whether features run correctly, not whether the code itself is elegant

Insight 4: Codex vs. Opus — Field Comparison #

One of the article’s most valuable firsthand comparisons:

Key insight: Codex’s “slow is fast” — it spends more time understanding the full codebase, achieving “one-shot” success on large tasks and avoiding iterative fix cycles.

Insight 5: Oracle — Using AI Research to Assist AI Coding #

Oracle is Steinberger’s dedicated CLI tool that calls GPT-5 Pro for deep research tasks. When coding agents get stuck on a technical issue, Oracle is automatically triggered:

• Can rapidly scan 50 websites
• Single analysis sessions can exceed an hour
• Answers most technical questions with high confidence

He writes research instructions in a global AGENTS.MD file, and models call Oracle on their own when needed. This “AI assisting AI” layered architecture is a unique design in his workflow.

Insight 6: Clawdis — The Full-System AI Agent Vision #

Clawdis is Steinberger’s main project, representing his vision of “ubiquitous AI assistants.” This agent has full system access to multiple computers:

• Communication: iMessage, Email
• Smart home: Lights (OpenHue), cameras (Camsnap), temperature (bed temperature control Eightctl)
• Entertainment: Music (Sonoscli), social media (custom tweet CLI)
• System control: Screen manipulation (Peekaboo), voice interaction

Clawdis even has its own “personality” (clawd.bot) and makes “snarky comments” while monitoring other agents. This goes beyond a coding tool — it’s more like a general AI butler with character.

2.2 Workflow Architecture Deep Dive #

Multi-Project Parallel Management #

Steinberger manages 3-8 projects simultaneously. Typical pattern: one primary project for focused work, remaining projects advanced autonomously by AI agents. Development rhythm: send initial prompt → 30-minute processing phase → iterative optimization, alternating between multiple projects.

Queue-Based Async Pipeline #

Heavy use of Codex’s queuing functionality, batch-sending prompts for async processing. He chose not to adopt complex multi-agent orchestration systems, opting instead for a simpler iterative exploration model.

His mountain climbing metaphor:

“Building software is like climbing a mountain. You don’t go straight up — you spiral upward, sometimes veering off course and needing to backtrack. The process isn’t perfect, but you eventually reach the destination.”

Version Control Strategy #

• Never rolls back code — instead, has the model modify on top of the current base
• Commits directly to main branch — no branch management (because he’s a solo developer)
• Large refactors run in background during attention-diverted moments (like while writing articles), 1-2 hours per session

Prompt Engineering Evolution #

As model capabilities improve, prompts have become shorter. Voice input increasingly replaces typing, with images supplementing text descriptions (especially in UI iteration). No longer manually referencing documentation files — instead using a custom docs:list script to automatically inject document context.

Documentation & Context Management #

• Maintains subsystem and feature documentation in project docs/ directories
• AGENTS.MD file contains global agent instructions
• Document structure prioritizes agent navigation efficiency over human readability — a notable paradigm shift
• After GPT 5.2, he no longer restarts sessions for each task, instead maintaining long-running sessions with context compression via the /compact endpoint

Codex Configuration Reference #

model = "gpt-5.2-codex"
model_reasoning_effort = "high"
tool_output_token_limit = 25000
model_auto_compact_token_limit = 233000  # 273000 - (25000 + 15000)

[features]
ghost_commit = false
unified_exec = true        # Replaces tmux and custom run scripts
apply_patch_freeform = true
web_search_request = true  # Not default but useful
skills = true
shell_snapshot = true

Core configuration philosophy: Increase tool_output_token_limit (default is too low, causing models to silently fail when they can’t see complete files); enable unified_exec for a unified execution environment; enable web search capability.

III. Deep Research & Analysis #

3.1 Community Feedback Landscape #

Hacker News Core Debates #

The article sparked intense discussion on Hacker News, with opinions clearly split into two camps:

Supporters’ arguments:

• Cost efficiency: User gwern noted that $51K over 3 months is less than a junior developer’s fully-loaded salary — the key is output density
• Industry transformation signal: User jeswin argued the article reveals industry-level change — spending $1,500 to build a TypeScript compiler with AI would have taken a year and been less complete before
• Verified savings: User CurleighBraces reported using Vibe Coding to build replacements for Duolingo, calorie tracking, and other tools — 2 months for only $3 in API costs

Critics’ arguments:

• “AI addiction” concern: User causal noticed the author was coding on his phone during friend gatherings, comparing it to slot machines — “pulling the lever and seeing results is fun, but the core challenge of judging what you actually need becomes harder”
• Output questioning: User rocmcd cited Feynman’s warning — “the easiest person to fool is yourself” — questioning $50K+ spent with no clear output to show
• Environmental cost: User ossa-ma estimated these API calls consumed energy equivalent to 450 American households’ annual electricity usage

Pragmatists’ insights:

• User elevation noted the real acceleration point: reducing tasks that would take days of repetitive work to 15 minutes
• User svantana raised a key reflection: “Does it really matter whether a prototype is built in 4 hours vs. 24 hours? What’s truly valuable is thoughtfully crafted, highly polished applications — that still takes person-years”

Twitter/X Community Response #

• Steinberger publicly shared the article on X, sparking widespread discussion
• Interview summary emphasized he uses “Agentic Engineering” rather than simple Vibe Coding — multi-agent parallelism + closed-loop test verification
• Analysis post viewed it as a landmark case of “AI shifting execution bottlenecks” — individual leverage massively amplified, entrepreneurship becoming more intention-driven

3.2 Critical Perspectives #

Code Quality & Maintainability Risks #

Multiple studies provide cautionary data for the “don’t read code” approach:

• CodeRabbit report: AI-generated code has a problem rate 1.7x higher than human code, with a greater proportion of high-severity issues (source)
• SonarSource analysis: Code quality decline is nearly inevitable in AI-accelerated codebases, with technical debt growing at an even faster rate (source)
• Forbes warning: Rapid AI code generation is creating a “tsunami of security risks” — AI replicates known vulnerabilities from training data (source)
• Academic research (arXiv): LLM agents significantly accelerate development but simultaneously cause notable code quality decline, raising long-term maintenance risks (source)

The “Verification Transfer” Theory #

Frederic Pattyn in The Vibe Coding Trap offers a profound insight:

The fundamental risk of AI coding isn’t “more bugs” — it’s that rework transfers from the code layer to the hidden supervision and verification layer.

Specific manifestations:

1. Supervision becomes the new bottleneck: AI accelerates production; human review becomes the limiting factor
2. Cross-layer error compounding: AI-generated errors don’t simply accumulate — they “infect and amplify” across architectural layers, harder to detect and more expensive to fix than traditional bugs
3. Deceptive first-pass completeness: AI output looks complete, but surface “polish” masks underlying fragility

3.3 Balanced Perspective #

Placing Steinberger’s practice in a broader context reveals several prerequisites:

The author’s unique advantages (not to be ignored):

• 15 years of iOS development and company management experience — he’s not “blindly trusting AI” but making judgments based on deep experience
• Personal projects, not team collaboration — no code reviews, merge conflicts, or knowledge sharing constraints
• All new projects — no legacy codebase maintenance complexity
• High risk tolerance — as an independent developer, bug business impact is limited

Real boundaries of the speed dividend:

• Highly effective for data-flow applications (CRUD, CLI tools, automation scripts)
• Diminishing returns for domains requiring deep domain knowledge, safety-critical systems, or high-performance computing
• A gap remains between “prototype speed” and “product quality”

IV. Extended Content #

4.1 Concept Evolution: Vibe Coding → Agentic Coding → Context Engineering #

The AI-assisted programming field experienced rapid conceptual evolution in 2025:

Vibe Coding (Early 2025)
|  Coined by Andrej Karpathy
|  Core idea: Describe "vibes" in natural language, AI generates code directly
|  Characteristics: Low control, creativity-first, suited for prototyping
|
|-- Agentic Coding (Mid 2025)
|    Core idea: AI agents autonomously complete subtasks; humans make architectural decisions
|    Characteristics: Closed-loop verification, multi-agent collaboration, task queuing
|    Key figure: Peter Steinberger
|
+-- Context Engineering (Late 2025)
     Defined as a new paradigm by MIT Technology Review
     Core idea: Precisely design and manage AI's input context
     Characteristics: Structured prompts, documentation-driven, reproducibility
     Focus shifts from "how to make AI write code" to "how to give AI the right information"

Steinberger’s practice sits precisely at the transition from Agentic Coding to Context Engineering — his AGENTS.MD, docs/ directory system, and custom document injection scripts are essentially context engineering in practice.

4.2 Industry Trend Comparison #

2025 AI Programming Tool Ecosystem #

Model Capability Leap Timeline (2025) #

• Q1: Claude 3.5 Opus, GPT-4 Turbo dominant; large refactoring still unreliable
• Q2: GPT-5 released; first achievement of “factory-scale building” — large task one-shot success rate significantly improved
• Q3-Q4: GPT-5.2 launched; “almost all problems solved in one shot”; Claude Opus continues to lead in conversational quality and creativity

4.3 Comparison with Traditional Software Engineering #

The Unchanged Core #

Fundamental Changes #

V. Practical Implementation Guide #

5.1 Individual Developers: 5 Immediately Applicable Practices #

Practice 1: CLI-First Development Strategy #

Approach: For any new project, build the command-line interface first, then GUI.

Rationale: CLI output is plain text — AI agents can directly run commands and verify results, forming an “code → run → verify → fix” automated loop. GUI projects require screenshots or manual inspection, making the feedback loop much slower.

Example: Steinberger’s Chrome extension project (YouTube summaries) started as a CLI tool summarize — all logic was proven in the command line first, then wrapped as a browser extension.

Practice 2: Queue-Based Batch Prompting #

Approach: Batch-send multiple tasks as prompts to an agent queue, asynchronously awaiting results.

Core idea: Don’t “watch” a single task. After sending a prompt, switch to other work or thinking, then come back in 30 minutes to check results. This pattern converts waiting time into productivity.

Practice 3: Multi-Model Collaboration #

Approach: Choose different models based on task nature.

Practice 4: Cross-Project Pattern Replication #

Approach: Use ../other-project paths to reference existing projects, letting agents learn and replicate successful patterns.

Use cases: Build configurations, CI/CD pipelines, test framework setup for new projects — no need to start from scratch; let agents follow established successful examples.

Practice 5: Documentation-Driven Agent Context #

Approach: Maintain AGENTS.MD (global agent instructions) and docs/ directories (subsystem documentation) in projects, ensuring agents receive correct context at every startup.

Key principle: Document structure should prioritize agent navigation efficiency. This means: clear directories, consistent naming conventions, and explicit module boundary descriptions.

5.2 Team Scenarios: Gradual Adoption Path #

Steinberger’s extreme workflow is an individual practice — team adoption requires a progressive approach:

Phase 1 — Assisted Coding

• Introduce code completion tools (Copilot / Cursor)
• Use AI for code explanation, documentation generation, test writing
• Manually review all AI output
• Goal: Team builds intuition about AI output quality

Phase 2 — Agentic Coding

• AI agents independently complete well-defined subtasks
• Establish AI code review checklists and acceptance criteria
• Introduce automated test coverage requirements
• Goal: Reliably delegate execution-level work

Phase 3 — Factory Mode

• Multi-agent parallel processing of different modules
• Architect role replaces traditional programmer role
• Context engineering becomes a core capability
• Goal: Approach Steinberger’s described “inference-speed shipping”

5.3 Risk Management Checklist #

Code Review Checklist #

• Security review: Are there injection vulnerabilities (SQL, XSS, command injection)?
• Dependency security: Are new dependencies from trusted sources? Any known vulnerabilities?
• Boundary validation: Is user input, API response, and other external data validated?
• Error handling: Are exception paths properly handled rather than silently ignored?
• Sensitive data: Are there hardcoded keys, tokens, or personal information?
• Performance impact: Are there N+1 queries, memory leaks, or unnecessary computations?

Technical Debt Monitoring Metrics #

• Code duplication rate changes: AI-generated code easily introduces similar-but-different implementations
• Dependency count growth: AI tends to introduce new dependencies rather than reuse existing ones
• Test coverage trends: Ensure coverage doesn’t decline due to rapid iteration
• Bug density: Defects per thousand lines of code, comparing AI-generated vs. human-written modules

5.4 Tool Chain Recommendations #

Model Selection Matrix #

Cost Control Recommendations #

1. Set monthly budget caps: Steinberger averaged ~$17K/month; individual developers should set based on actual needs (most can achieve significant efficiency gains at $100-500/month)
2. Match model tier to task: Use low-cost models for simple tasks; only deploy high-performance models for large refactoring
3. Use queuing to reduce real-time costs: Batch async processing is more economical than real-time interaction
4. Monitor token consumption: Watch cost changes when increasing tool_output_token_limit

VI. Summary & Reflections #

One-Sentence Summary #

This article demonstrates how a senior engineer pushed AI agents from “auxiliary tool” to “execution workhorse” — it doesn’t represent everyone’s future, but it illuminates a path worth serious study.

Three Key Takeaways #

1. The bottleneck has shifted: For experienced developers, coding execution is no longer the limiting factor. Architectural decisions, requirements understanding, verification strategies — these “soft skills” have had their value dramatically amplified.

2. Context engineering is the new core capability: Whether AI can work efficiently depends on whether you can provide it with the right context — project documentation, agent instructions, directory structure, reference projects. This is the most worthwhile capability investment in 2025.

3. Experience is more valuable, not less: Steinberger can “ship without reading code” precisely because he has 15 years of experience to judge when to trust AI and when to intervene. “Not reading code” without an experience foundation is just blindness.

Three Risks to Watch #

1. Hidden accumulation of technical debt: The faster the pace, the faster debt accumulates, but perception becomes duller. Research data shows AI code problem rates are 1.7x human rates — these issues don’t explode immediately but gradually manifest at scale and over time.

2. Atrophy of verification capability: If one goes too long without reading code, the developer’s intuition for code quality may gradually degrade. This forms a dangerous positive feedback loop: less code reading → more AI dependence → less ability to judge AI output quality.

3. Survivorship bias: Steinberger is a unique individual with 15 years of experience, financial freedom, working on personal projects. His workflow succeeds under these preconditions, but simply replicating it in team collaboration, legacy code maintenance, or security-sensitive systems could have serious consequences.

Outlook #

AI-assisted programming is at a turning point from “novel experience” to “infrastructure.” Steinberger’s practice is an extreme stress test — it demonstrates the ceiling while also exposing the boundaries.

The real question isn’t “can AI replace coding” (at the execution level, the answer increasingly points to “yes”), but “what kind of verification, governance, and quality assurance systems do we need to build to ensure that software shipped at inference speed is trustworthy.” The answer to this question will determine how far AI-native development can go.

References #