Anush Elangovan and Charity Majors sound like they disagree about whether your old coding workflow is over. Anush Elangovan treats implementation as something agents burn through while he stays on plans and gates. Charity Majors says the job was never the typing. It was solving business problems with technology. Both can be true in the same week if you stop debating vibes and audit your calendar.
Controlled studies do not settle the fight for you. In a GitHub experiment, developers using Copilot built an HTTP server in JavaScript 55.8% faster than a control group (Peng et al., The Impact of AI on Developer Productivity). In a 2025 randomized trial, 16 experienced open-source developers on 246 tasks in mature codebases they knew well took 19% longer when AI tools were allowed, even though they had forecast a 24% speedup and afterward believed they had gained 20% (Becker et al., Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity). Usage is up while trust lags. Stack Overflow’s 2025 Developer Survey reports 84% of respondents using or planning to use AI tools, up from 76% a year earlier, and 51% of professional developers using them daily. More developers distrusted AI output accuracy (46%) than trusted it (33%). The top frustration was solutions that are almost right but not quite (66%). Seventy-six percent did not plan to use AI for deployment and monitoring. That pattern fits Anush’s delegate-the-typing story and Charity’s keep-the-problem story at the same time.
What am I actually doing when I “code”?
For one week, log tasks in 30-minute blocks. Tag each block as produce (text in an editor), decide (what should exist), prove (that it works), or operate (what shipped). Do not tag tools. Tag outcomes.
Produce-text blocks include greenfield implementation, refactors you could describe as a spec, merge conflict cleanup, and “make this compile.” Charity argues greenfield writing is often the fastest, easiest slice of the lifecycle compared with owning software over time. That is exactly the slice models eat first.
Decide blocks include picking the problem, scoping a change, writing the plan document Anush says he spends the most time on, and choosing what “done” means for the business.
Prove blocks include tests, CI rules, review of agent output, and the gates Anush treats as the sandbox boundary.
Operate blocks include deployment, monitoring, incident response, and debugging when nobody remembers who wrote the line that broke. Stack Overflow’s survey already shows most developers drawing the line before deployment and monitoring. Treat that caution as data.
Where does Anush’s workflow push work?
Elangovan’s public stance on Chain of Thought is blunt about who owns .rs files:
Sure, that's my agent's problem. And I'm not opening a file.rs ever.
Anush Elangovan, Corporate VP of AI Software at AMD, Chain of Thought ep 56
He also argues normal SDLC is dead in the agentic world, that testing is the new code review, and that he treats code as ephemeral iteration toward an outcome. In practice that means your audit should show produce-text time dropping while prove time rises. If your log still shows most hours in the editor with a chat sidebar, you are not running his workflow yet.
I'd map anything you can hand an agent with tight gates into delegate and verify: implementation from an approved plan, porting between languages when the tests are fixed, and git hygiene you used to do by hand. Elangovan says that in the past two or three months he has not touched Git manually, and asks agents to rebase and open review. That is produce-text plus light decide, with you at the verify step.
What does Charity say stays human?
Majors says it in the line the debate page quotes:
Software engineering is not about writing code. It is about solving business problems with technology, which has historically included a lot of writing code.
Charity Majors, co-founder and CTO of Honeycomb, Chain of Thought ep 18
She separates disposable generated code from the code that runs the world, where someone still has to understand banking, delivery, and transaction paths. She puts production, rather than the editor, at the center of gravity. She warns that supervising work without learning loops can erode skill, the same automation pattern with a faster UI.
Your audit's keep pile should grow when tags are decide or operate on consequential systems: ambiguous requirements, cross-team tradeoffs, production debugging when there is no expert, instrumentation choices, and anything where “almost right” (66% in Stack Overflow’s survey) becomes customer pain. Charity is not telling you to refuse agents. She is telling you not to confuse throughput in the IDE with engineering.
How do I score the week?
After five working days, sum hours per tag. Use this decision rule:
| Signal | Lean Anush (delegate + verify) | Lean Charity (keep + tighten feedback) |
|---|---|---|
| Produce-text share | High, but paired with rising prove hours | High with flat prove hours (risk) |
| Decide share | Stable or up (plans, scope) | Flat or down (you are coding instead of framing) |
| Operate share | Low for now if survey matches your team | Should not be zero on systems you ship |
| Trust gut | You can describe tests agents cannot game | You can explain production behavior without the agent |
If Copilot-style wins (55.8% on a bounded task) show up in your log as greenfield produce-text, agents are doing their job. If your mature-repo work looks more like Becker's result (19% longer with AI tools allowed), my hypothesis is that the delegation is costing you, and the log should show where.
Arguments about whether we are close to artificial general intelligence often turn into arguments about definitions. Today's models stay narrow: strong at specialized tasks, weak at arbitrary new problems. For this audit, ignore the finish line and watch trajectory. The question is whether your week moved problem ownership upstream while machines took typing volume.
Sketch: classify one ticket before you prompt
Label this a sketch, not production code.
# Sketch: bucket a task before you assign it to an agent
from enum import Enum
class Bucket(Enum):
DELEGATE = "agent implements; human verifies"
KEEP = "human owns outcome"
HYBRID = "human plans + tests; agent fills middle"
def classify(task: dict) -> Bucket:
if task["touches_production"] and task["blast_radius"] == "high":
return Bucket.KEEP
if task["acceptance_tests"] and task["spec_clear"]:
return Bucket.DELEGATE
if task["unknown_requirements"]:
return Bucket.KEEP
return Bucket.HYBRID
# Example: {"spec_clear": True, "acceptance_tests": True,
# "touches_production": False, "blast_radius": "low",
# "unknown_requirements": False} -> DELEGATE
Elangovan’s answer to agents going sneaky is more marathon gates, not more manual typing. Charity’s answer is tighter feedback loops in prod. The bucket call forces you to pick which failure mode you are preventing.
If you need a structured ramp for teammates who think in business outcomes first, AI, decoded walks technical AI in plain language across five levels, from how a language model works to running agents in production, with episodes cited on each page.
Checklist
- Log one week by outcome (produce, decide, prove, operate), not by tool.
- Delegate only when acceptance tests or CI gates are written first; otherwise you are funding “almost right” rework.
- Keep decide and operate hours on systems where nobody can be the expert-of-last-resort.
- Compare your gut speed estimate to Becker-style reality on mature repos; trust timers over feelings.
- Re-run the audit monthly. Writing code is changing fastest; checking it and owning what ships is where both guests say the job still lives.
The longer explainer, with the episode clips, is on Chain of Thought. It draws on this episode.
Subscribe to the Chain of Thought newsletter for new episodes and write-ups like this one.
Drafted with AI assistance from the episode transcripts.
Top comments (0)