Async Programming as a Workflow: Specify, Automate, Review

Async programming is reframed as a workflow where developers write precise specs, delegate implementation to agents, and review results later. It relies on clear problem definitions, automated verification in CI, and careful human code review. This shift lets teams parallelize work and focus on architecture and quality rather than typing.

Key Points

• Async programming here is a workflow shift: write precise specs, delegate implementation, and review later, rather than coding synchronously.
• Success depends on three pillars: clear problem definitions, automated verification (tests, types, benchmarks, linting), and thorough human code review.
• Automated checks—ideally in CI—let agents validate work independently, reducing manual edge-case testing.
• Developers can parallelize work, handling multiple background tasks while focusing on planning, architecture, and review.
• Braintrust applies this approach and builds tools like Loop to automate evaluation and iteration on AI systems.

Sentiment

Mixed-to-skeptical: some see promise for boilerplate and constrained tasks with strong automated checks, but most push back on the naming, the practicality of clear specs, review overhead, tech-debt risk, and skill atrophy.

In Agreement

• Spec-first, review-heavy development is valuable and aligns with classic programming practice (Lamport: define what, define how, then code).
• Agents can handle routine or boilerplate work (tests, scripts, benchmarks, dashboards), freeing humans for higher-level design and review.
• Automated verification (tests, types, CI, linters, benchmarks) is essential and already common; wiring agents into this loop can scale validation.
• Asynchronous delegation resembles effective offshoring when specs are clear; fast incremental cycles help catch issues earlier.
• Keeping one synchronous task while running multiple background agent tasks can mitigate skill atrophy and improve throughput.
• Works best for constrained or well-bounded tasks (e.g., endpoints, incremental changes) where requirements are clearer.
• Some practitioners report personal success using this approach across stack layers, citing faster iteration.

Opposed

• The title is misleading; people expected async/await content—better call it agent-based or asynchronous software development.
• Defining clear, stable specs is the hard part; real projects evolve and detailed specs become unwieldy and ignored by decision-makers.
• Reviewing AI-generated code can be slower than writing it; increased review burden undermines promised productivity gains.
• Risk of developer skill atrophy when offloading implementation; long-term quality and problem-solving ability may suffer.
• High likelihood of subtle AI errors and accumulating tech debt, especially where organizations can’t reliably judge output quality.
• The approach may only work for limited, tightly scoped tasks or when a single empowered owner can make trade-offs—rare in larger orgs.
• It drains enjoyment from programming for those who value solving implementation puzzles themselves.
• Analogous to reinventing compilers: a slow, unreliable natural-language ‘compiler’ that still requires humans to check the output.
• Business leaders already struggle to discern good from bad output; adding AI increases the gamble.