Should AI Engineers Still Read Code in 2026? The Z/L Continuum — Alex Volkov, ThursdAI

Summary of technological concepts, product features, and analysis

• AI engineering shifted from hand-written code to agent-generated code

  • The speaker argues that “code got cheap, attention didn’t,” describing a world where engineers increasingly supervise rather than manually implement.
  • Examples:
    • Boris Cherny / Anthropic “Cloud Code”: claims Cloud Code authored 100% of his code at the time. He still ships many PRs, implying the engineering role shifts upward in abstraction.
    • Anthropic codegen proportion: cited ~80% of Anthropic’s code is AI-written (noted as a few months old; likely higher now).
    • GitHub commit growth: GitHub is projected to reach ~14B commits in a year, up from ~1B the previous year—attributed largely to AI-assisted coding.

• A specific “break point” in AI engineering (December 2025)

  • The talk claims that in Dec 2025, models began completing tasks that previously required >16 hours of engineer time, after which performance and throughput increased further (“way up the curve”).
  • Mentions an evidence hub: wtfhappened2025.com (described as humorous but used as documentation).

• Conflicting viewpoints on whether to read code (the “Z/L Continuum”)

  • The talk frames a tension with two viewpoints from the same AI Engineer EU conference:
    • “Code is free” / don’t get hung up on implementation (OpenAI speaker Ryan LeFebvre)
      • Tools are high-quality and can write real production code.
      • The priority is not the code itself, but prompting + guardrails to prevent “slop.”
      • Still requires short-term diligence: double-click when agents struggle.
    • “Read every line of code” / critical-path scrutiny (Pi creator Mario Zechner)
      • Agents can compound repeated errors (“compounding booboos”) without learning.
      • For critical code, read every line; for non-critical code, “write slop ahead.”
  • Speaker’s framing: the question shouldn’t be “Should we read code at all?” but rather “What proof does this specific change need?”

• Empirical/metrics concerns: speed without review harms quality

  • Cites multiple engineering survey/analysis results (including a survey said to be from April 2026; “Acceleration Whiplash”):
    • +861% increase in code deletion per PR (interpreted as teams aggressively iterating and removing code with agents).
    • +31% increase in merged PRs with no review (human or agentic), presented as a warning not to do this.
    • +242% increase in incidents per PR.
    • Bugs per developer up ~6x vs 2025.
  • Real-world example: Anthropic’s status page described as “Christmas tree”-like (because it was down at screenshot time), used to illustrate that heavy AI codegen at scale can correlate with stability/incident noise.
  • Core warning: “Output does not mean stability.”

• Key resolution: route review effort to “proof” that matters

  • The speaker’s central method is a routing table / “Monday artifact”:
    • For authentication, money movement, permissions, irreversible data: read every line / inspect critical path personally.
    • For other changes: rely more on system-level checks rather than line-by-line human review.
  • Emphasizes that the continuum is about tasks, not people:
    • The same engineer might be “hands-off” on some tasks and “read everything” on others.

• Actionable review/process techniques (tutorial/guide-like guidance)

  • Distilled advice into several practices:
    1. Decompose / split large PRs into small, reviewable chunks (agents can help with decomposition).
    2. Traces, evals, shadow mode (instrumentation and testing modes) to validate behavior.
    3. Separate roles: avoid a single agent that both writes code, inspects outputs, and writes tests—because it can become self-confirming (“like grading your own exam”).
    4. Observability, rollback, engineer the guardrails (“engineer makes the system remember” after humans review once).
  • Meta-guidance:
    • Use AI “clankers” (described as strong at scanning repos) to highlight which lines/areas are critical, then focus human attention there.

• Capability drift changes where “proof” must occur

  • Mentions that as model capabilities increase (e.g., “Fable,” “Mythos,” “Claude code”), evaluation focus shifts:
    • From checking “work is correct” → to checking “work is the right thing.”
  • Warns: even with more capable systems, don’t stop reviewing in production.
  • Introduces the idea of a “capability drift arrow”: review focus migrates (outputs → tasks → potentially loops), but the need for proof remains.

• “Loops” as the next primitive (automation that self-verifies)

  • Describes loops as a shift from one-shot prompting to system design:
    • “Fancy cron jobs” that run on a schedule.
    • They discover tasks, generate prompts from plans, execute, and crucially verify themselves; if verification fails, they retry.
  • Framing: loops reduce human involvement, but don’t eliminate judgment—they can hide review by letting the same system both build and grade.
  • References an Adi Olsmanyu point: if you let automated loops handle everything when a bug arises, quality can spiral downward because your product team may miss deeper quality degradation.

• Future-facing conclusion

  • The talk argues flexibility is required due to fast-changing agent/model ecosystems (e.g., coding agents, tools at OpenAI/Anthropic, “generalized agent” trend).
  • Final takeaway: not every line needs human eyes, but every system still needs human judgment.

Main speakers / sources mentioned

• Alex Volkov — host of Thursday AI podcast/newsletter; talk moderator
• Ryan LeFebvre (OpenAI) — “Code is free” viewpoint
• Mario Zechner (Pi creator) — “Read every line for critical code” viewpoint
• Andrejs Karpathy — quoted about temptation to stop looking at code, but not in production
• Jared S. Chipar (Anthropic) — quoted about checking “right work” with Fable
• Adi Olsmanyu (Google) — quoted about quality spiral risk with fully automated loop fixes
• Peter Steinberger — creator of Open Cloud; mentioned in loops context
• Boris Cherny (Anthropic) — mentioned in Cloud Code and loops context