The Pragmatic Engineer · Published 2026-10-06

The state of the tech industry in 2026 - LDX3 New York

privateReview: unreviewedConfidence: high
ai-engineeringagentsHarnessescode-reviewsfuture-of-workagentic-harnesscode-reviewparallel-agentsevalsinfra-capacitysoftware-factoryai-fluency
Open on YouTube ↗

Summary

Overview

  • Speaker: Gergely Orosz
  • Channel: The Pragmatic Engineer
  • Main topic: The state of the software engineering industry in 2026 driven by AI adoption, agentic workflows, and structural shifts in developer tooling and teams.
  • Purpose: To provide a comprehensive pragmatic overview of how AI adoption is transforming software engineering workflows, team structures, tools, and leadership in 2026. Gergely Orosz shares insights from visiting AI labs, Big Tech, and startups over recent months, examining what changed, what stayed the same, what broke, and what comes next in software engineering. Key changes include near-universal AI-generated code, parallel agent workflows, the fading relevance of traditional IDEs, agentic software factories, compressed migration timelines, and rising agent-generated issues. Unchanged aspects include teams and planning for complex work, testing and validation, and the need for human engineering judgment. Major system breaks include code review bottlenecks, infrastructure capacity shortages (CPU and memory), and increased cognitive load and burnout among engineers and leaders.

Topic Map

What Changed: AI Coding & Parallel Agents

  • Explanation: Software engineering has shifted to near 100% AI-generated code and parallel agent workflows where engineers run 5 to 10 agent sessions concurrently.
  • Key claims:
    • Nobody writes code by hand anymore except a few exceptions.
    • Working with 5 to 10 parallel AI agents/worktrees is increasingly common among hardcore engineers.
    • Traditional heavy IDE usage is trending down as agentic interfaces like Codex, Antigravity, and Cursor take over.
  • Examples:
    • Boris Cherry running 5 terminal tabs and 5-10 cloud code sessions in parallel.
    • Dima Zaychev running 5-10 worktrees locally to rotate between agents.
  • Terminology:
    • agentic harness
    • worktree
    • parallel agents
    • IDE
  • Why it matters: Engineers are no longer bottlenecked by typing speed or single-task limitations, multiplying output and cognitive overhead.

The Agentic Software Factory & Migrations

  • Explanation: Companies are building custom AI coding harnesses and agent platforms in-house, drastically accelerating codebases and migrations.
  • Key claims:
    • Everyone is building their own AI coding harness/agent platform.
    • Development work frequently starts in Slack via bot tagging.
    • Migrations that used to take years now take weeks or months (e.g., Anthropic Zig-to-Rust in 11 days, Airbnb Enzyme-to-RTL in 6 weeks).
  • Examples:
    • OpenAI's agentic software factory using perf-factory agents to monitor production and raise PRs.
    • Anthropic migrating Zig to Rust in 11 days.
    • Asana migrating React testing libraries in 2 weeks.
  • Terminology:
    • agentic software factory
    • perf-factory
    • agent-generated PRs
    • agent skills
  • Why it matters: Technical debt cleanup and large-scale refactoring are no longer multi-year boondoggles.

What Did Not Change

  • Explanation: Despite AI acceleration, fundamental engineering units, planning needs, and validation standards remain robust.
  • Key claims:
    • Teams are still the fundamental unit of work, retaining two-pizza team sizes.
    • Planning remains essential for complex infrastructure and alignment.
    • Tests and validation are as important as ever to trust AI-generated code.
    • Non-engineers are still not shipping production-ready code.
  • Examples:
    • Katelyn Less (Anthropic) emphasizing that two-pizza teams still exist despite human-agent collaboration.
    • Jared Sumner noting that test writing ratio remains identical to pre-AI times.
  • Terminology:
    • two-pizza team
    • formal verification
    • tracer bullets
  • Why it matters: Human accountability, collaboration, and rigorous validation cannot be automated away.

What Broke

  • Explanation: Massive increases in code quantity and agent activity broke traditional processes like code reviews, infrastructure capacity, and developer focus.
  • Key claims:
    • Code quantity and frequency assumptions have exploded (5x-10x increases in PRs and commits).
    • Traditional code reviews have become 'theater' or 'zombie code reviews' due to high volume, leading teams to phase them out for non-critical code.
    • Infrastructure capacity has strained, leading to memory and CPU shortages in addition to GPUs.
    • Engineering leadership is experiencing a wave of exits due to unrealistic expectations and founder mode pressures.
  • Examples:
    • Linear data showing agent-generated issues and PRs spiking past human-generated ones.
    • Ramp and other startups phasing out code reviews for non-critical code.
    • Cloud providers facing CPU back-ordering times up to 6 months.
  • Terminology:
    • zombie code reviews
    • CPU backlog
    • cognitive load
    • fractional CTO
  • Why it matters: Velocity gains create severe downstream system friction across review pipelines, hardware availability, and talent retention.

What Comes Next

  • Explanation: The industry is moving toward cloud agents, abandoning manual code reading, establishing agentic CI/CD infra, and valuing deep domain knowledge over raw coding speed.
  • Key claims:
    • Cloud agents and harnesses will replace local developer setups due to hardware limits and better cloud tooling.
    • Engineers will stop reading raw code and rely entirely on test validation and agentic evaluations.
    • AI fluency and AI positivity are becoming baseline hiring requirements.
    • Engineers with deep domain knowledge (wisdom and charisma) are increasingly in-demand as intelligence becomes a commodity.
  • Examples:
    • Ramp building advanced cloud agent harnesses.
    • Titus Winters' framework on intelligence (how to do it), wisdom (what to do), and charisma (convincing others).
  • Terminology:
    • cloud agents
    • AI fluency
    • deep domain knowledge
    • evals
  • Why it matters: The definition of a software engineer shifts from writing code to orchestrating systems, validating intent, and applying deep domain wisdom.

Key Points

Nobody writes code by hand anymore

  • Explanation: Virtually all software development involves AI generation and prompting, shifting human effort to reviewing, prompting, and orchestrating.
  • Evidence: Observed switch to near 100% AI-generated code in startups and tech companies since early 2025.
  • Practical implication: Engineers must master prompt engineering, multi-agent management, and system architecture rather than syntax.

Code reviews are breaking down

  • Explanation: The sheer volume of agent-generated code has turned code reviews into a rubber-stamping theater, prompting companies to eliminate mandatory reviews for non-critical code.
  • Evidence: Linear data showing massive spikes in agent PRs; startup policies shifting to trust-and-verify.
  • Practical implication: Automated testing, evaluation suites (evals), and formal verification must replace human line-by-line code review.

Wisdom and charisma outperform raw intelligence

  • Explanation: As code generation becomes free and instant, knowing what to build and why matters more than knowing how to code.
  • Evidence: Titus Winters' formula: intelligence is cheap, but wisdom and charisma are scarce and valuable.
  • Practical implication: Engineers must cultivate deep domain expertise, product sense, and leadership skills.

Frameworks, Models & Processes

Titus Winters' Success Framework

  • How it works: Breaks down engineering capability into three pillars where intelligence is becoming a commodity and wisdom/charisma become paramount.
  • Components:
    • Intelligence (how to do it)
    • Wisdom (what to do)
    • Charisma (convince others to do it)
  • When to use: When evaluating career positioning and skill development in an AI-dominated engineering landscape.

Examples & Case Studies

Anthropic migrated from Zig to Rust in 11 days with a single engineer.

  • Illustrates: Massive acceleration of legacy migrations using AI agents.
  • Lesson: Refactoring and rewriting codebases is no longer cost-prohibitive or multi-year.

Linear data showing agent-generated tickets and PRs exceeding human-generated ones in mid-2026.

  • Illustrates: The emergence of the agentic software factory at scale.
  • Lesson: Issue trackers and PR pipelines must adapt to non-human contributors.

Actionable Takeaways

  • Immediate:
    • Adopt parallel agent workflows to multiply your output.
    • Integrate automated eval suites into CI/CD pipelines to replace broken human code reviews.
    • Embrace cloud-based development environments and harnesses.
  • Strategic:
    • Focus on deep domain knowledge and system design rather than syntax and implementation.
    • Future-proof your career by staying hands-on with building software while leveraging AI to remove friction.
    • Cultivate AI fluency and positivity as core competencies for hiring and leadership.
  • Questions to investigate:
    • How will quality and reliability be maintained as code volume explodes?
    • What does the career path for junior engineers look like when junior hiring is slowing down?
    • How will engineering leadership evolve as teams shrink and agent factories expand?

Claims Worth Verifying

  • Nearly 100% of code in startups is AI-generated. (statistical trend)
  • Anthropic migrated Zig to Rust in 11 days with one engineer. (case study)
  • Agent-generated PRs on GitHub increased nearly 10x between January and August. (industry metric)

Notable Quotes

"It used to be a simple world: one mouse, one keyboard, one screen. You physically can't work on more than one thing at once. Now, you no longer have that limitation." (at 3:14) "On the death of the IDE. It's not that we don't need more perspective & context for our human-based decisions. It's that the context has changed." (at 6:52) "If you've not built your own AI coding harness by now, are you even a serious tech company?" (at 7:12) "The AI writes pretty much all the code, but we have the AI write pretty much all the tests as well. Before AI, for production-ready software, we spent about the same time writing tests as we did on writing code. This is still the case with AI." (at 23:26) "Everyone is playing the theater of doing reviews, but with the volume of changes that get thrown your way I observed that people just find a path of least resistance - some teammate that gave up on reviews and just stamps everything with LGTM." (at 28:25) "What you need to succeed: intelligence, wisdom, and charisma. Intelligence means: how to do it. Wisdom means: what to do. Charisma means: convince others to do it. When intelligence becomes commonplace, wisdom and charisma become much more important." (at 44:10)

Compressed Summary

  • AI-generated code and parallel agent workflows are now the industry standard.
  • IDEs are fading in favor of agentic harnesses like Cursor and Codex.
  • Traditional code reviews are breaking down under massive PR volumes, replaced by automated evals.
  • Migrations and refactoring now take weeks instead of years.
  • Deep domain wisdom and system design are replacing raw coding speed as key engineering assets.
  • Keywords: ai-engineering, agents, harnesses, code-reviews, future-of-work
  • Core insight: Software engineering has shifted from manual coding to agent orchestration, making deep domain wisdom and automated validation more critical than ever.

Core insights

7
Failure Modehigh noveltymoderate evidence

The code review pipeline is the first subsystem to structurally break under agent-generated volume: a 5x-10x spike in PRs/commits turns line-by-line human review into rubber-stamping ('zombie code reviews'), and the observed response is to remove mandatory review for non-critical code, shifting the trust burden onto automated tests, evals, and formal verification.

Why it matters

Review was the last human gate between generated code and production. If it is phased out by policy rather than replaced by an equivalent-strength automated gate, the safety of the whole delivery pipeline depends on how well evals, tests, and formal methods can substitute for human judgment.

Generalization

Any human-in-the-loop gate placed on an agent throughput path will saturate and be bypassed rather than scaled; durable designs must replace the gate with an automated equivalent, not just increase reviewer headcount.

Traditional code reviews have become 'theater' or 'zombie code reviews' due to high volume, leading teams to phase them out for non-critical code.
Open source video
Ramp and other startups phasing out code reviews for non-critical code.
Open source video
Linear data showing agent-generated issues and PRs spiking past human-generated ones.
Open source video
Empirical Resulthigh noveltymoderate evidence

The binding compute constraint for AI-heavy engineering has drifted from GPUs to general-purpose infrastructure: memory and CPU shortages now appear alongside GPU scarcity, with cloud CPU back-order times of up to six months, which is what motivates moving agent workloads into the cloud instead of local machines.

Why it matters

Capacity planning and cost models for agentic workflows cannot assume GPU-only scarcity; sustained parallel agent sessions consume CPU/memory in ways that affect provisioning lead time, latency budgets, and the viability of local execution.

Generalization

Scaling agent concurrency shifts the bottleneck to the least elastic shared resource, so harness architectures should be designed around where the real queue (CPU/memory provisioning) is, not the headline accelerator.

Infrastructure capacity has strained, leading to memory and CPU shortages in addition to GPUs.
Open source video
Cloud providers facing CPU back-ordering times up to 6 months.
Open source video
Cloud agents and harnesses will replace local developer setups due to hardware limits and better cloud tooling.
Open source video
Architecturehigh noveltymoderate evidence

The 'agentic software factory' pattern places autonomous agents on production telemetry: perf-factory agents monitor production and raise PRs themselves, making production observation an agent input rather than a human-only feedback loop, with development also frequently initiated by tagging a bot in Slack.

Why it matters

It moves agents from request-driven code generation to event-driven, always-on actors with their own trigger surface (telemetry, chat), which changes where you place permissions, rate limits, observability, and dedup/backpressure for self-initiated work.

Generalization

Once agents can initiate work from their own signals, the harness needs admission control, provenance, and idempotency for machine-originated tasks, not just prompt routing.

OpenAI's agentic software factory using perf-factory agents to monitor production and raise PRs.
Open source video
Everyone is building their own AI coding harness/agent platform.
Open source video
Development work frequently starts in Slack via bot tagging.
Open source video
Practicemedium noveltymoderate evidence

Parallelism is the new individual workflow unit: engineers run 5-10 concurrent agent sessions, typically isolated by worktrees (local) or cloud sessions, and are rotating between them rather than driving one task; heavy IDE usage declines as agentic interfaces become the primary surface.

Why it matters

Concurrency at the individual level requires isolation primitives (worktrees, sandboxes), context switching discipline, and per-session state; it also multiplies review/merge contention, which is why it interacts directly with the review bottleneck.

Generalization

Raising agent concurrency converts the human bottleneck from generation to orchestration and merge, so the harness must own isolation, session state, and conflict surfacing.

Working with 5 to 10 parallel AI agents/worktrees is increasingly common among hardcore engineers.
Open source video
Traditional heavy IDE usage is trending down as agentic interfaces like Codex, Antigravity, and Cursor take over.
Open source video
Dima Zaychev running 5-10 worktrees locally to rotate between agents.
Open source video
Empirical Resulthigh noveltymoderate evidence

Migrations that were multi-year projects collapse to days or weeks under agent harnesses — Anthropic's Zig-to-Rust migration in 11 days, Airbnb's Enzyme-to-RTL in 6 weeks, Asana's React testing library migration in 2 weeks — indicating agents are disproportionately effective on large, mechanical, well-specified refactors.

Why it matters

It identifies a concrete, high-leverage class of work (codemod-like, high-volume, spec-checkable transformation) where agent investment pays off first, and reframes technical debt cleanup as an economically tractable activity.

Generalization

Agent value concentrates where the task is voluminous, repetitive, and verifiable by tests — a criterion for choosing which work to hand to harnesses first.

Anthropic migrating Zig to Rust in 11 days.
Open source video
Asana migrating React testing libraries in 2 weeks.
Open source video
Technical debt cleanup and large-scale refactoring are no longer multi-year boondoggles.
Open source video
Mental Modelhigh noveltymoderate evidence

The predicted endpoint is code-blind engineering: engineers stop reading raw code and rely entirely on test validation and agentic evaluations, while test-writing ratio reportedly stays the same as before AI — meaning validation effort is not reduced, only redistributed away from reading.

Why it matters

If reading is dropped, evals and tests become the sole specification of correctness, so their coverage, fidelity, and adversarial quality become the real reliability ceiling of the system; any gap in eval design becomes an unguarded production risk.

Generalization

Substituting automated validation for human inspection shifts risk from reviewer attention to evaluation completeness — an explicit, auditable artifact rather than tacit reviewer judgment.

Engineers will stop reading raw code and rely entirely on test validation and agentic evaluations.
Open source video
Jared Sumner noting that test writing ratio remains identical to pre-AI times.
Open source video
Tests and validation are as important as ever to trust AI-generated code.
Open source video
Mental Modelmedium noveltyweak evidence

As code generation is commoditized, the scarce inputs become judgment and influence: Titus Winters' split of intelligence (how to do it), wisdom (what to do), and charisma (convincing others) is used to argue deep domain knowledge and persuasion outrank raw coding speed in hiring and value.

Why it matters

It implies engineering leverage shifts toward problem selection, intent specification, and cross-team alignment — the parts of the loop that agents cannot self-source — which changes what to measure and hire for.

Generalization

When an execution capability becomes cheap, value migrates to the specification and adoption layers around it.

Engineers with deep domain knowledge (wisdom and charisma) are increasingly in-demand as intelligence becomes a commodity.
Open source video
Titus Winters' framework on intelligence (how to do it), wisdom (what to do), and charisma (convincing others).
Open source video
AI fluency and AI positivity are becoming baseline hiring requirements.
Open source video

Deep dives

5

Risk-tiering rubric for removing human code review

Research question

What operational criteria (blast radius, reversibility, data sensitivity, dependency centrality) reliably classify code as 'non-critical' such that auto-merge does not increase escaped-defect rates compared to human-reviewed paths?

Why

Removing mandatory review for non-critical code makes the criticality judgment the single point of failure; without an enforced rubric, misclassification silently ships unreviewed code and the trust burden shifts to tests/evals with no measurable guarantee of equivalence.

Traditional code reviews have become 'theater' or 'zombie code reviews' due to high volume, leading teams to phase them out for non-critical code.
Open source video
Ramp and other startups phasing out code reviews for non-critical code.
Open source video
Source video

Defect-escape equivalence of code-blind validation vs human reading

Research question

At matched change sets and eval coverage, do code-blind workflows (no human reads the diff; correctness asserted solely by tests and agentic evals) produce the same or lower escaped-defect rate as reading-based workflows, and which defect classes are uniquely missed?

Why

The predicted endpoint has engineers stop reading raw code while the test-writing ratio reportedly stays unchanged; if validation effort is only redistributed, not increased, eval coverage gaps become the system's reliability ceiling and are currently unmeasured.

Engineers will stop reading raw code and rely entirely on test validation and agentic evaluations.
Open source video
Jared Sumner noting that test writing ratio remains identical to pre-AI times.
Open source video
Tests and validation are as important as ever to trust AI-generated code.
Open source video
Source video

Throughput ceiling of per-engineer agent concurrency

Research question

As per-engineer concurrent agent sessions scale from 1 to 10, how do merge conflict rate, PR queue time, revert rate, and downstream review contention respond — is there a concurrency level beyond which team-level throughput saturates or declines?

Why

Parallel sessions are presented as the new individual workflow unit, but the same output volume saturates review/merge; without instrumentation, organizations can push concurrency higher and burn cognitive load for negative net throughput.

Working with 5 to 10 parallel AI agents/worktrees is increasingly common among hardcore engineers.
Open source video
Dima Zaychev running 5-10 worktrees locally to rotate between agents.
Open source video
Engineers are no longer bottlenecked by typing speed or single-task limitations, multiplying output and cognitive overhead.
Open source video
Source video

Isolation and least-privilege primitives for cloud agent harnesses

Research question

What per-session sandboxing, secret-scoping, network-egress control, and audit-logging primitives are required for a cloud agent harness to reach parity with local developer workflows under least-privilege constraints, and where does parity break?

Why

Cloud agents are expected to replace local setups on hardware and tooling grounds, but the prediction omits security and operational control; without designed isolation, a cloud harness becomes a high-throughput path to credential exposure and unreviewable execution.

Cloud agents and harnesses will replace local developer setups due to hardware limits and better cloud tooling.
Open source video
Everyone is building their own AI coding harness/agent platform.
Open source video
Infrastructure capacity has strained, leading to memory and CPU shortages in addition to GPUs.
Open source video
Source video

Admission control and provenance for machine-originated work

Research question

What admission-control, idempotency, deduplication, rate-limiting, and provenance-tagging mechanisms are needed when agents initiate PRs from production telemetry and Slack tags rather than human requests, and how do those mechanisms change queueing behavior in issue trackers and PR systems?

Why

The agentic software factory turns production observation into an agent input and chat into an origin surface; without machine-task admission control, self-initiated work can burst, duplicate, and starve human-originated work in shared queues.

OpenAI's agentic software factory using perf-factory agents to monitor production and raise PRs.
Open source video
Development work frequently starts in Slack via bot tagging.
Open source video
Linear data showing agent-generated issues and PRs spiking past human-generated ones.
Open source video
Source video

Article ideas

4

Zombie Reviews Are Not a Volume Problem: Why Agent-Era Code Review Needs an Automated Equivalent, Not a Headcount Increase

A human review gate placed on an agent throughput path will always saturate and be bypassed, so the durable fix is to replace mandatory review with an enforceable, auditable automated gate (tests plus evals plus formal verification) paired with an explicit criticality rubric — not to add reviewers.

Angle

Failure-mode analysis of the review bottleneck with a concrete migration path from human gate to automated gate, including the misclassification risk that becomes the new single point of failure.

Source video

The Agentic Software Factory Is an Event-Driven System: Design Admission Control Before You Auto-Merge Production PRs

Once agents initiate work from production telemetry and Slack tags, the harness stops being a prompt router and becomes an event-driven actor system that requires admission control, idempotency, deduplication, provenance, and backpressure for machine-originated tasks.

Angle

Architecture argument that treats agent-originated PRs and issues as untrusted event streams, with concrete primitives for permissions, rate limits, and dedup.

Source video

Code-Blind Engineering Shifts the Reliability Ceiling to Eval Coverage

If engineers stop reading raw code while test-writing ratio stays flat, then evals and tests become the sole specification of correctness and their coverage, fidelity, and adversarial quality become the actual reliability ceiling of the delivery pipeline.

Angle

Risk-transfer argument: moving risk from reviewer attention to evaluation completeness makes eval design an explicit, auditable artifact and exposes unguarded production risk where evals are incomplete.

Source video

The Agent Bottleneck Moved Off the GPU: CPU, Memory, and Six-Month Cloud Backorders

Sustained parallel agent sessions shift the binding compute constraint from GPUs to general-purpose CPU and memory, and this is what makes cloud agent harnesses economically and operationally necessary despite provisioning lead times up to six months.

Angle

Capacity-planning argument for agent workloads: model cost and latency around the least elastic shared resource, and design harness architecture around where the real queue is.

Source video

Project ideas

4

Criticality Gate

gatehouse

A blast-radius/reversibility/data-sensitivity rubric can classify changes as non-critical with a false-negative rate low enough that auto-merged non-critical PRs show escaped-defect rates statistically indistinguishable from human-reviewed PRs.

Proof of concept

Instrument a repo to compute the rubric for every PR, auto-merge rubric-negative changes after CI plus eval pass, keep human review for rubric-positive changes, and log all escapes with retrieval of missed defects.

Measurement

Escaped-defect rate per 1,000 merged PRs for auto-merged vs reviewed paths, plus rubric false-negative rate, over at least a quarter of production traffic.

Source video

Concurrency Ceiling Probe

movement-lab

Team-level throughput rises with per-engineer agent concurrency up to a crossover point, after which merge conflicts, PR queue time, and reverts increase faster than delivered change volume, producing negative marginal throughput.

Proof of concept

Instrument a team's monorepo and agent harness to record per-engineer concurrent session count, merge conflict rate, PR queue latency, revert rate, and merged-change throughput; run a controlled ramp from 1 to 10 sessions per engineer.

Measurement

Marginal throughput (merged changes per engineer-day) and queue/conflict/revert rates as a function of concurrency, with crossover point and confidence interval.

Source video

Eval-Coverage Escape Benchmark

beyond-evals

For matched change sets, code-blind workflows (no human reads the diff) have an escaped-defect rate that is a monotonic function of eval coverage, and below a measurable coverage threshold they produce defect classes that never surface in reading-based workflows because reviewers implicitly traced them.

Proof of concept

Build a benchmark harness that runs identical agent-generated changes through two pipelines — one with human diff reading plus CI, one with CI plus agentic evals only — varying eval coverage and logging defect escapes with classification.

Measurement

Escaped-defect rate and defect-class distribution as a function of eval coverage percentage, compared across the two pipelines.

Source video

Factory Admission Controller

new

A queue with provenance tags, idempotency keys, per-source rate limits, and deduplication for machine-originated tasks prevents telemetry- and Slack-triggered agents from starving human-originated work and duplicate-PR bursts, while preserving agent throughput.

Proof of concept

Prototype an admission-control layer in front of the agent harness that tags every task with origin (telemetry, Slack, human) and enforces idempotency and per-source quotas; replay a recorded burst of agent-originated PRs through controlled and uncontrolled queues.

Measurement

Duplicate-PR rate, human-task queue latency, and agent-task throughput with and without admission control during burst replay.

Source video

Architectural implications

3

Agentic harnesses are being built in-house by nearly every organization, and cloud agents are expected to displace local developer setups.

Before

Local IDE plus a laptop was the seat of development; tooling was purchased or open-sourced and standardized.

After

Organization-specific cloud harnesses own orchestration, isolation, and execution, replacing the local environment as the primary runtime.

Consequence

Harness design becomes an internal platform responsibility (sandboxing, secrets, resource scheduling, session state), and harness capability becomes a source of differentiation and lock-in.

Source video

Code review responsibility is being removed for non-critical code rather than scaled.

Before

Human reviewer approval was the standard gate before merge for all code.

After

Automated tests, evals, and formal verification carry the trust burden for designated non-critical paths; review persists only where risk justifies it.

Consequence

The pipeline needs an explicit, enforceable classification of critical vs non-critical code, and the CI/CD layer must become the primary trust artifact — a significant shift in where assurance lives.

Source video

Development initiates from chat (Slack bot tagging) and from production telemetry agents, not only from a developer's editor.

Before

Work originated in an IDE or ticket tracker with a human requester.

After

Agents are an entry point for work, with machine-originated PRs and issues competing with human-originated ones.

Consequence

Trigger surfaces, permissions, deduplication, and provenance tracking must be designed for non-human initiators; issue trackers and PR queues must handle machine-burst traffic.

Source video

Tradeoffs and failure modes

4

Parallel agent workflows (5-10 concurrent sessions per engineer)

Benefit

Removes single-task and typing-speed limits, multiplying individual output.

Cost or risk

Cognitive load and burnout rise, and the output pushes downstream merge/review contention.

Engineers are no longer bottlenecked by typing speed or single-task limitations, multiplying output and cognitive overhead.
Open source video
Source video

Phasing out code reviews for non-critical code

Benefit

Relieves a saturated review pipeline and preserves velocity as PR volume grows 5x-10x.

Cost or risk

The criticality judgment becomes the single point of failure; misclassification silently ships unreviewed code.

Traditional code reviews have become 'theater' or 'zombie code reviews' due to high volume, leading teams to phase them out for non-critical code.
Open source video
Source video

Massive increase in agent-generated code volume

Benefit

Compresses migrations from years to days/weeks and makes refactoring economically viable.

Cost or risk

Strains CPU and memory capacity, with cloud provisioning lead times up to six months.

Infrastructure capacity has strained, leading to memory and CPU shortages in addition to GPUs.
Open source video
Source video

Leadership under agent-era velocity expectations

Benefit

Founder-mode pressure pushes orgs to capture AI-driven speedups aggressively.

Cost or risk

A wave of engineering leadership exits from unrealistic expectations, thinning the human judgment layer that unbroken processes depend on.

Engineering leadership is experiencing a wave of exits due to unrealistic expectations and founder mode pressures.
Open source video
Source video

Open questions

4

What is the operational definition of 'non-critical code' that justifies removing human review, and who is accountable when that classification is wrong?

Why unresolved

The summary reports the policy shift but gives no criteria, thresholds, or error-handling for misclassified code.

Research direction

Design and test a risk-tiering rubric (blast radius, reversibility, data sensitivity) that gates review removal, and measure escaped-defect rates for auto-merged vs reviewed paths.

Source video

Can test suites and agentic evals actually substitute for human code reading at equivalent reliability, given the claim that test-writing ratio is unchanged?

Why unresolved

The summary asserts reliance on test validation and reports unchanged test ratio, but supplies no coverage or defect-escape data.

Research direction

Benchmark defect-escape rates for code-blind workflows against reading-based workflows on comparable change sets, with eval-coverage as the independent variable.

Source video

Does 5-10 parallel agent sessions scale from individual hardcore engineers to team-level throughput, or does merge and review contention cap the gain?

Why unresolved

The summary describes individual setups and separately describes saturated review pipelines, but never quantifies the interaction.

Research direction

Instrument merge conflict rate, queue time, and revert rate as a function of per-engineer agent concurrency to find the throughput ceiling.

Source video

What isolation, secret-management, and observability primitives are required for cloud agent harnesses to safely replace local developer setups?

Why unresolved

The summary predicts the shift to cloud agents on hardware and tooling grounds without addressing security or operational control.

Research direction

Prototype a cloud harness with per-session sandboxing and audit logging, and measure whether parity with local workflows is achievable under least-privilege constraints.

Source video

Key claims

8
factualVerification needed

Code quantity and frequency assumptions have exploded, with 5x-10x increases in PRs and commits.

Evidence

Code quantity and frequency assumptions have exploded (5x-10x increases in PRs and commits).

Question

Across which organizations and time windows were these 5x-10x PR/commit multipliers measured, and are they per-engineer or per-team?

Source video
factualVerification needed

Agent-generated issues and PRs have spiked past human-generated ones.

Evidence

Linear data showing agent-generated issues and PRs spiking past human-generated ones.

Question

What share of Linear issues and PRs are agent-originated, and how is provenance attributed?

Source video
causalVerification needed

Traditional code reviews have become theater due to high volume, leading teams to phase them out for non-critical code.

Evidence

Traditional code reviews have become 'theater' or 'zombie code reviews' due to high volume, leading teams to phase them out for non-critical code.

Question

Do teams that removed non-critical-code review show higher escaped-defect rates than those that retained it?

Source video
comparativeVerification needed

Migrations that used to take years now take weeks or months under agent harnesses.

Evidence

Migrations that used to take years now take weeks or months (e.g., Anthropic Zig-to-Rust in 11 days, Airbnb Enzyme-to-RTL in 6 weeks).

Question

Were these migrations functionally equivalent in scope and post-migration defect load to the multi-year baselines they are compared against?

Source video
causalVerification needed

Infrastructure capacity is strained by AI workloads, producing memory and CPU shortages in addition to GPUs.

Evidence

Infrastructure capacity has strained, leading to memory and CPU shortages in addition to GPUs.

Question

What proportion of the CPU/memory shortage is attributable to agent workloads versus general cloud demand?

Source video
factualVerification needed

Test-writing ratio remains identical to pre-AI times.

Evidence

Jared Sumner noting that test writing ratio remains identical to pre-AI times.

Question

Is the test-to-code ratio invariant across teams adopting agents, and does absolute test coverage per change hold constant?

Source video
predictionVerification needed

Engineers will stop reading raw code and rely entirely on test validation and agentic evaluations.

Evidence

Engineers will stop reading raw code and rely entirely on test validation and agentic evaluations.

Question

What evidence indicates code reading is declining, and what defect classes emerge that tests and evals fail to catch?

Source video
predictionVerification not requested

AI fluency and AI positivity are becoming baseline hiring requirements, while deep domain knowledge is increasingly in demand.

Evidence

AI fluency and AI positivity are becoming baseline hiring requirements.

Source video

Connections

5