Backpressure is all you need
AI coding agents are prompting software teams to rethink how work should flow between humans and machines, with many advocating strong automated test and validation loops so agents can catch more of their own mistakes before code review. Commenters debate whether long-running, largely autonomous agent workflows are worth the complexity and token cost compared to tighter, human-steered iterations, and whether practices like pre-commit hooks and exhaustive test suites can realistically make unreviewed agent output safe. Several note that ideas framed as novel “backpressure” are essentially established engineering concepts—structured feedback, shift-left testing, and rigorous requirements—being rediscovered in an AI context.
Concept of “Backpressure” and Terminology
- Several commenters argue the article misuses “backpressure”; the proposed checks are more like throttling, validation, or “shift-left” testing than true downstream capacity signaling.
- Alternatives suggested: lean concepts like single-piece flow, autonomation/jidoka, poka‑yoke, or just “structured feedback loops” or TDD.
- Some find the metaphor distraction-level wrong; others see it as a minor naming issue.
Agent Workflows and Feedback Loops
- Many say this “third approach” (agents validating their own work) is already common practice since early 2024.
- Typical pattern: orchestrated containers, build + unit + integration + end‑to‑end tests, performance metrics, and agents looping until constraints are met.
- Some run multiple agents in parallel, with one interactive “primary” agent and others working autonomously in separate worktrees.
- Others prefer shorter, tightly guided tasks (5–30 minutes) over long unattended runs; belief that maximalist autonomous agents are over-engineered and fragile.
Human-in-the-Loop, Quality, and Ethics
- Strong norm stated: never submit PRs you personally believe are low quality; code review is a second line of defense, not the first.
- Concern that relying on agents may dump low‑quality PRs on teammates or OSS maintainers; criticized as extractive behavior.
- Some defend automation as augmenting human review, not replacing it, but agreement that humans remain accountable.
Testing Strategy and Hooks
- Heavy emphasis on using tests as the agent’s “backpressure”: more comprehensive suites, performance objectives, invariant checks.
- Debate on whether tests can ever be comprehensive enough to safely skip code review; consensus that building such suites is slow and non-trivial.
- Hooks (git hooks, tool-specific hooks) and pre-commit checks are praised as deterministic guardrails that agents can’t ignore, versus relying on prompts the model may “forget.”
Costs, Tooling, and Token Economy
- Significant worry about API/token costs for deep agent loops; references to eye‑watering spend by some projects.
- Some argue productivity gains justify the cost; others question whether workflows are actually profitable.
- Changes in pricing for certain hosted agent features are cited as making automated harnesses much more expensive; suggestion to use cheaper/older models where possible.
Process Models and Overengineering
- Critique that “big plan to agent” workflows resemble waterfall; some prefer micro-iterations and lightweight LLM use.
- Others say real projects inevitably need planned phases, deadlines, and stronger specs, so “waterfall with feedback loops” is realistic.
- Several comments note that much of this is just rediscovering existing software and lean best practices, now being reframed as AI innovation.
Enthusiasm vs. Skepticism
- Enthusiasts report large productivity gains, especially for performance optimization and large integrated stacks.
- Skeptics highlight: increased system complexity, slower pipelines, maintenance burden of verification layers, and LLM flakiness on hard problems.
- Some believe fully autonomous agents can converge with enough scaffolding; others have tried and reversed course, finding guided, hands‑on workflows more effective.