Shipping at Inference-Speed
A tutorial by Peter Steinberger. Featured in the OTF curated resource library.
The Speed Shift
For decades, the bottleneck in software development was writing code. Design a feature, plan the implementation, write the code, debug it, test it, deploy it. Each step took hours or days.
AI coding agents have compressed the "write the code" step from hours to minutes. A feature that took a senior developer an afternoon now takes 15 minutes with Claude Code or Cursor. But this speed increase doesn't just make coding faster—it changes the entire development loop.
When implementation is near-instant, the bottleneck shifts to decisions: what to build, how to prioritize, and how to validate that what you built is correct. The developers who thrive in this new world aren't the fastest typists—they're the clearest thinkers.
New Bottlenecks
Decision Speed > Coding Speed
If you can implement a feature in 15 minutes, spending 2 hours in a planning meeting is the real bottleneck. Move to shorter decision loops: quick Slack threads, 10-minute syncs, async approvals.
Review Throughput
When one developer produces 5x more code, the review process needs to scale. Use AI-assisted code review, smaller PRs, and trust-based approval for low-risk changes.
Testing and Validation
Shipping faster means bugs can reach users faster. Invest heavily in automated testing, staging environments, and feature flags. The cost of a mistake hasn't changed—the speed of making mistakes has.
Design Clarity
Vague requirements now cost more because they lead to rapid implementation of the wrong thing. Invest in clear specifications, reference designs, and acceptance criteria before starting an AI-assisted build.
Restructuring Your Workflow
Here's a practical framework for adapting your development workflow to inference-speed shipping.
Adopt 'Build → Validate → Ship' Micro-Loops
Replace long sprint cycles with tight feedback loops. Build a feature in 15-30 minutes, validate it immediately (visual check, automated tests, quick QA), and ship it behind a feature flag. The goal is deploying 5-10 small changes per day instead of one large change per week.
Front-Load Design and Specification
Spend more time upfront on clear requirements and design specs. When AI can build anything in minutes, the ROI on clear specifications skyrockets. A 30-minute design review saves hours of building the wrong thing.
Parallelize Exploration
Use AI to prototype 2-3 approaches simultaneously. Instead of debating which architecture is best, build all of them in 30 minutes and compare the real implementations. Data beats opinions.
Automate the Safety Net
As shipping velocity increases, invest proportionally in automated safety: CI/CD pipelines, type checking, linting, integration tests, and monitoring. The faster you ship, the more you need automated guardrails.
Maintaining Quality at Speed
The concern with shipping faster is quality regression. Here's the counter-intuitive truth: shipping faster can improve quality if you structure it correctly.
Smaller changes are easier to review and debug. Frequent deployments mean bugs affect fewer users for less time. Rapid iteration lets you fix UX issues within hours of user feedback instead of weeks.
The key is distinguishing between velocity (speed of shipping) and haste (speed without care). Velocity means fast with guardrails—automated tests, review processes, and monitoring. Haste means fast without guardrails—and that's where quality suffers.
Practical rules for quality at speed:
- Every feature ships with at least basic tests
- Visual changes get a screenshot review (AI can help here too)
- Database migrations get extra scrutiny regardless of speed
- Security-sensitive code always gets human review
Team and Culture Implications
Inference-speed shipping changes team dynamics in fundamental ways:
Individual contributors become more impactful. A single developer with strong AI skills can now ship what previously required a small team. This means smaller teams can tackle larger problems.
The value of taste increases. When anyone can build anything quickly, the differentiator becomes what you build and how well it's designed. Developers with strong product sense and design taste become disproportionately valuable.
Collaboration shifts from implementation to strategy. Team meetings should focus less on "how do we build this" and more on "what should we build" and "does this solve the user's problem." Implementation details become less contentious when you can try all approaches.
Continuous learning becomes mandatory. AI tools evolve monthly. Teams that dedicate time to exploring new capabilities and sharing workflow improvements maintain their edge.
