How soon AI will start firing programmers?

Yegor Bugayenko · article · 2023-09-04 source ↗ Reader 🖥️

AI Labor Disruption Coding Agents Cognitive Load Pull Requests & Async Code Review

Writing in September 2023, weeks into the ChatGPT era and before any coding agent existed, Bugayenko predicts that AI 'robots' will progressively absorb a widening list of software-engineering tasks — starting with low-stakes, assistive work (bug reporting, pull-request review, refactoring, documentation, backlog grooming) and ending, as the furthest-off and most consequential item, with AI monitoring individual programmers' activity to appraise their productivity and determine 'which human contributors are most valuable to their projects' — so that the title's question about firing programmers is answered not by a date but by a position in the list: last.

theoretical · expository — A short, enumerated forecast (16 ordered predictions) written weeks after ChatGPT 3.5's public debut, not an argument for action. The piece asserts what will happen and in roughly what order, deliberately avoiding timelines ('items later on the list represent further-off predictions') despite the title's 'how soon' framing.

Structure

Part	Role
Framing: ChatGPT 3.5's release as the immediate trigger, with an explicit methodological note that the list orders predictions from nearer-term to further-off and deliberately avoids repeating GitHub Next's existing roadmap.	context
Items 1–7 (Bug Reporting, PR Review, Code Refactoring, Backlog Prioritization, Refinement of Bug Reports, Source Code Documentation, Bug Fixing): assistive and semi-autonomous tasks where the AI produces artifacts (reports, pull requests) that a human still accepts or merges.	evidence / near-term predictions
Items 8–14 (Requirements Formalization, Onboarding Assistance, Technical Debt Analysis, Documentation Cleanup, Feature Suggestions, Architectural Documentation, Complexity Estimation): tasks that require broader codebase and organizational context, placed further down the list as a result.	evidence / mid-term predictions
Items 15–16 (Behavioral Prediction, Performance Appraisal): the only two items that turn the AI's gaze onto people rather than code — placed last, culminating in AI determining which programmers are 'most valuable.'	climax / answer to the title's question
Closing line ('This list was constructed with the assistance of ChatGPT. What did we miss?'): discloses that ChatGPT itself helped generate the list and solicits reader additions.	meta-commentary / qualification

Key terms

Robots
Bugayenko's blanket term for AI systems (specifically, generative-AI-driven automation building on ChatGPT) that will act on a codebase and its surrounding project artifacts — filing reports, opening pull requests, commenting on code — largely indistinguishably from a human contributor ('the originators of the pull requests may remain unaware whether their reviewer is human or robotic').

Propositions

explicitAI 'robots' will inspect codebases, run tests, and file bug reports so well-crafted — with technical detail and supporting links — that programmers will come to prefer robot-filed reports over human-filed ones.conf: high
explicitAI will review pull requests from both humans and other AI, leaving annotated line-level critique and persisting its suggestions, to the point that a PR author may not know whether their reviewer was human or robotic.conf: high
supportsAgentic Code Review · p11 — Written in September 2023 before any coding agent existed, this prediction that PR authors might not know whether their reviewer was human or robotic anticipates almost exactly what this corpus's 2026 mining/survey evidence confirms: the machine is already reviewing more code than humans are.
explicitAI will autonomously select and submit micro-refactorings as pull requests, without compromising functionality or making sweeping changes, incrementally improving code primarily for machine (not human) readability over time.conf: high
explicitAI will generate fixes for registered bugs and submit them as pull requests that explain the fix's rationale, urgency, and alternatives, with the expectation that human developers will simply integrate the changes rather than author them.conf: high
explicitAI will take over several specific categories of work that human programmers tend to systematically neglect — keeping documentation synchronized with code, keeping requirements documents current, and standardizing documentation formatting — framed explicitly as compensating for a 'common human shortcoming.'conf: high
explicitThe predictions are ordered from nearer-term to further-off, and the two tasks placed last — Behavioral Prediction and Performance Appraisal — are the only two in the list that turn AI's analytical attention onto people's behavior and worth rather than onto code artifacts.conf: high
explicitcontestedAI will monitor each programmer's activity to evaluate their productivity, with appraisal outcomes published on GitHub or sent to project managers, ultimately determining which human contributors are most valuable to a project.conf: high
contradictsHow to measure AI developer productivity in 2025 | Nicole Forsgren · p1 — Bugayenko predicts AI will reliably monitor individual programmer activity and determine who is 'most valuable.' Forsgren's 2025 analysis argues the opposite premise: individual productivity metrics in the AI era are easily gamed and largely unreliable ('a lie'), undercutting the assumption that such AI-driven appraisal would be trustworthy even once technically possible.
explicitBy analyzing repository events — mood fluctuations in comments, activity spikes, CI/CD failures — AI will identify anomalies in human behavioral patterns and proactively recommend corrective or preventive action before problems fully manifest.conf: high
implicitThe title's question ('how soon will AI start firing programmers?') is answered implicitly, not explicitly: by placing Performance Appraisal last in an ordered-by-remoteness list, the article frames job-affecting evaluation of individual programmers as the most distant, hardest capability — later than fully autonomous bug-fixing, later than architectural documentation — rather than engaging the question's premise (whether, or on what basis, 'firing' would follow from such appraisal) directly.conf: medium
explicitThe list itself was constructed with ChatGPT's assistance, which the author discloses in the closing line rather than in the introduction — meaning the tool whose capabilities are being forecast also co-authored the forecast.conf: high

Arguments

AI taking over individual performance appraisal and determining programmers' relative value is a real, eventual capability, but one of the last capabilities to arrive — later than full code generation, review, and fixing. strength: low

Explicit premises:

The list is explicitly ordered from nearer-term to further-off predictions.
Performance Appraisal is the final item on the list.

Implicit premises:

Tasks requiring judgment about human behavior and worth are intrinsically harder for AI to perform reliably than tasks requiring judgment about code, and therefore arrive later.
The ordering reflects genuine technical difficulty rather than social/organizational reluctance to deploy AI for appraisal — i.e., the delay is a capability gap, not a deployment-choice gap.

Inferences:

If the real binding constraint on AI performance appraisal were organizational appetite rather than technical capability, the list's ordering-by-remoteness would systematically understate how soon such appraisal could actually arrive once the technical building blocks (which the list's earlier items describe) are in place.
Three years later, several of the article's 'nearer-term' predictions (PR review, bug fixing, refactoring) are documented in this corpus as operating at scale, which invites re-examining whether the 'further-off' items are still further off for the same reason, or have simply not been tried yet.

Questions addressed

⭕ How soon will AI start firing programmers?
Not answered directly or with a timeline; the article substitutes a different, answerable question (what sequence of tasks will AI take over, ordered by remoteness) and lets Performance Appraisal's position at the end of that sequence stand in for an answer to the title's question.
✅ What tasks currently performed by human programmers will generative AI take over, and in roughly what order?
A 16-item ordered list, from bug reporting and PR review through documentation, requirements formalization, and technical debt analysis, to behavioral prediction and performance appraisal.

Gaps

incompleteThe article never specifies what criterion separates a 'nearer-term' prediction from a 'further-off' one — is it required context window, required access to organizational/behavioral data, required trust from humans, or something else? Without a stated criterion, the ordering reads as intuition rather than a model, and it is impossible to tell whether Performance Appraisal is placed last because it is technically harder or because it is more consequential and uncomfortable to automate.
Read next: This corpus's material on AI-as-amplifier and AI-labor-disruption, for frameworks that do distinguish technical-capability constraints from organizational/social-adoption constraints on which AI capabilities actually get deployed.
incompletePerformance Appraisal is described purely as a measurement-and-ranking capability ('determine which human contributors are most valuable') with no engagement with whether the underlying metrics (activity volume, comment sentiment, CI/CD failure correlation) would be a reliable basis for that determination — the article treats measurability as equivalent to validity.
Read next: extract-lenny-forsgren-measure-ai-developer-productivity, which argues at length that individual productivity metrics are easily gamed and often misleading in the AI era — directly undercutting the premise that an AI monitoring 'each programmer's activity' would produce a trustworthy appraisal.
uninformedWritten before any agentic coding tool existed (ChatGPT 3.5 only, no tool use, no autonomous execution loop), the article has no way to anticipate that several of its 'assistive' predictions (PR review, bug fixing) would later be delivered not by discrete bot contributions to a repo but by persistent, scheduled, multi-run agent loops — a structural form this corpus's loop-engineering material shows is now central to how such capabilities are actually deployed.
Read next: extract-lulla-loop-engineering-building-blocks-adoption-impact and extract-osmani-loop-engineering, for how 'AI does code review' or 'AI fixes bugs' predictions cashed out structurally three years later.