TB: Shipping at Inference-Speed (Steinberger)

Core Thesis

The bottleneck in software creation has shifted from coding ability to inference time and clear thinking. With GPT-5.2/codex, a solo developer can manage 3–8 simultaneous projects, ship features from two-sentence prompts, and run agents for 5+ hours unattended. The key unlock is not raw capability but a suite of workflow patterns — queueing, docs-as-context, oracle queries, cross-project referencing — that keep the developer at the steering wheel while agents do the driving.

Key Takeaways

The model shift: plan mode replaced by conversation

  • Codex reads files silently for 10–15 minutes before writing (improving accuracy on large refactors); Opus is eager but misses context in larger features.
  • Despite codex taking 4× longer per task, fewer corrections mean faster overall velocity.
  • "Codex eliminated the need for plan mode. Instead of removing edit tools, he now has conversations with the model — asking questions, exploring code together, and creating plans collaboratively before writing with simple commands like 'build.'"
  • ~5× more per codex session than Claude Code through superior context management; no session restarts needed with GPT-5.2.

The oracle pattern

  • When agents get stuck, write everything to markdown and query GPT-5 Pro with file upload + session management.
  • Used to happen multiple times daily; GPT-5.2's release reduced it to a few times weekly — 5.2 "one-shots almost anything."
  • Knowledge cutoff is a first-class concern: GPT-5.2 trained through August 2025 vs. Claude Opus mid-March — ~5 months when using latest tools/libraries.

Docs-as-context architecture

  • Feature/subsystem documentation lives in each project's docs/ folder; a global AGENTS file ensures models read relevant docs automatically.
  • Documentation stays updated; context improves with project size.
  • "Codebase design optimizes for agent efficiency rather than personal navigation. Fighting the model wastes time and tokens."

Workflow heuristics

  • Start with CLI before UI — validates core logic first; UI becomes a day's work afterward.
  • Cross-reference projects: "look in ../project-folder and do similarly" is extremely prompt-efficient.
  • Commit directly to main — no branch overhead for solo work; linear evolution of the codebase.
  • The mountain metaphor: building software = walking up a mountain, circling, backtracking, eventually reaching the destination.
  • Issue trackers are nearly useless solo: important ideas get attempted immediately; everything else gets remembered or wasn't important.

Concrete validation: VibeTunnel Zig conversion

  • A multi-component multiplexer refactor (Rust/Go/Zig) consistently failed with older models.
  • Codex completed it from a two-sentence prompt over 5 hours with multiple compactions — in a single attempt.

Mental Models

  • Compounding Returns — 5× session productivity gain compounds across dozens of concurrent projects; the return on better context management multiplies
  • Slow is Smooth and Smooth is Fast — codex takes 4× longer per task but requires fewer corrections; the slower path is the faster one
  • First Principles Thinking — start with CLI not UI; get the logic right before adding layers; strip the problem to its core

See also

Source

Peter Steinberger (steipete), December 28, 2025 Original post

Backlinks