---
title: "Cheap execution moves the bottleneck to judgment"
description: "AI agents can multiply parallel work, but speed does not erase the human costs of attention, review, and deciding what “done” means."
canonical: "https://www.symbaiex.com/newsletter/daily-signal-2026-10-27"
last-updated: "2026-10-27T14:31:04.674Z"
---
# Cheap execution moves the bottleneck to judgment

> AI agents can multiply parallel work, but speed does not erase the human costs of attention, review, and deciding what “done” means.

Edition: daily-signal  
Run date: 2026-10-27

## Thesis
Three first-person engineering accounts point to a specific trade: agents lower the cost of starting work, while people still absorb the resulting review, coordination, and context-switching load. The productivity question is not only how much code agents produce, but whether teams can inspect and integrate it without quietly expanding the workday.

An engineer using agents across his work says his week feels heavier because several tasks now arrive at once, each demanding attention at unpredictable moments. That is one person’s account, not a controlled productivity study—but it names a design problem worth taking seriously. The two other engineering essays in this issue describe the same pressure from different angles: code that still needs human judgment and agent teams that still need orchestration. More throughput can move the bottleneck, not remove it.

## Source briefing
### [AI promised less work. I've never worked more](https://oioannou.com/blog/ai-promised-less-work/)

Orestis Ioannou says using agents across his engineering work has left him busier, largely because several parallel tasks each return with decisions or results needing attention. His GitHub contribution history is a rough activity signal, not a measure of value.

**Why it matters:** If parallel agents are leaving you with a queue of small decisions, cap concurrency before adding more tools. Check where your day goes: agent handoffs, code review, or work that would not otherwise have been started.

**Takeaways:**
- Ioannou describes agents implementing, investigating, reviewing, and researching in parallel; each still needs occasional human input.
- His GitHub counts combine commits, pull requests, reviews, and issues, so they cannot isolate coding or productivity.
- He notes 2019 is an incomplete baseline because his job then used a self-hosted GitLab.
- The account is a personal retrospective, not evidence that every engineer’s workload increases with agents.
### [Here Be Monsters: What Do You Still Need to Know When Agents Do the Work?](https://blog.adrq.dev/here-be-monsters-what-do-you-still-need-to-know-when-agents-do-the-work)

Adrian Quiroga describes inspecting agent-written components after CI flagged complexity; he judged the business logic correct, then asked Codex to refactor the code into 10 files. The account is one engineering incident, not a general reliability test.

**Why it matters:** If your agents can produce code you have not seen before, preserve the ability to inspect and explain it before shipping. Check whether your review process exposes structure and behavior, not just a passing CI result.

**Takeaways:**
- The author reports that Codex had written components on single lines, prompting a SonarQube complexity warning.
- He inspected the code and considered its complexity warranted by the requirements before requesting a refactor.
- The refactor split the work into 10 files, after which CI passed and the change shipped.
- Quiroga’s broader argument is that engineers need enough knowledge to recognize when to investigate deeply.
### [The Mythical Man-Month in the Age of AI](https://j11g.com/the-mythical-man-month-in-the-age-of-ai)

Jan van den Berg argues that AI agents do not eliminate coordination costs: people still define “done,” review code, catch errors, and integrate the pieces. This is an essay’s analysis, not a measured comparison of agent teams.

**Why it matters:** If you are adding agents to a project, clarify requirements and integration responsibilities before increasing parallel work. Check how they coordinate edits to shared code; speed can amplify rework when boundaries are vague.

**Takeaways:**
- The essay applies Brooks’s Law to agents, arguing that parallelism cannot make sequential work happen simultaneously.
- Van den Berg identifies review, requirement-setting, and integration as continuing human responsibilities.
- He warns that agents sharing a codebase without clear orchestration may overwrite or redo one another’s work.
- The piece offers a conceptual argument, not reported experimental evidence.

## Practical moves
- Limit concurrent agent tasks and assign explicit review windows so interruptions do not set the pace of the day.
- Require agents to produce readable diffs, tests, and a concise explanation before a human review begins.
- Name one person to define completion and resolve conflicts before parallel agents edit shared code.
- Track review time and context switches alongside shipped work; adjust concurrency when attention becomes the constraint.

## What to watch
- Whether teams report review queues growing as agent output rises.
- How often parallel agents conflict on shared files or unclear requirements.
- Whether engineering leads measure interruption load, not just completion counts.

**Methodology:** Belle selected and synthesized this edition from the indexed Hacker News source packet. Signal scores are editorial comparisons, not measurements. Direct source and discussion links are preserved for verification.

**Disclosure:** Belle uses AI to research and synthesize a bounded source packet; every edition is source-linked and subject to editorial review.