Why AI Coding Fails at Scale: The Organizational Mismatch Behind Limited Efficiency Gains

Introduction: The Real-World Laboratory

This analysis comes from a two-year experiment at Dida Chuxing, where a 1000-person R&D organization split into multiple squads to pilot different AI coding approaches. CEO Wang Xiaobo (also Tencent Cloud TVP) shares concrete results, dead-ends, and a fourth experimental path.

01 The Shift: Code Production Is No Longer Scarce

1.1 From Completion Tool to Production Mainstay

AI coding evolved from a completion aid (pre-2024) to production-ready (2024) to universal adoption (2025). By 2026, teams not using AI coding face obsolescence, triggering universal programmer anxiety about replacement.

1.2 The Core Disruption

For decades, programmers were scarce; companies fought for talent, CS majors boomed, million-yuan salaries became normal. The turning point: HR and admin staff began building functional systems with AI tools. The programmer's monopoly on code production vanished.

1.3 Three Emotional Phases in One Year

Early 2024: Excitement — "AI does my work, I can rest."

March–April: Realization — "My value is at risk."

May–June: New problem — Generated code creates worse "spaghetti code"; individual token consumption is high but overall throughput barely improves, some teams even regress into chaos.

1.4 Three Absurd On-the-Ground Scenes

Hallucination cascade: PM uses AI to write PRD → PRD fed to coding Agent → first AI's hallucinations become second AI's facts.

Review collapse: Leaders mandated full review of AI-generated code; volume became unmanageable, so they stopped reviewing — quality control evaporated.

Waiting for tokens: Developers sit idle waiting for AI to stream tokens; workflow inverted from "prepare then code" to "feed AI then wait."

Paradox: individuals feel more capable, but team-level efficiency stagnates.

02 Three Paths Tried, Each Hit a Ceiling

The 1000-person org was divided to pilot three distinct routes simultaneously.

2.1 Path 1: Legacy Renovation ("Old City Reconstruction")

Approach: Give every role an Agent + knowledge base, keep the old waterfall process (PM → Dev → QA → Release).

Execution: PMs use AI for drafts/interactions/PRDs; scheduling stays manual (leads become "scheduling engineers"); coding goes all-in on generation (repeatedly uploading repos for context); QA becomes more critical but degrades into a "prayer team" — last line of fear, not confidence.

Knowledge-graph effort: Abstracted code into knowledge graphs for upstream consumption. Looked promising: human brainwork turned into prompts/loops.

Ceiling: Point optimization only. Devs hit 90% AI-generated code but daily output unchanged. PMs produce AI drafts but workload grows. Devs now must review massive AI output they can't absorb. Knowledge graphs incomplete due to microservice isolation; LLM hallucinations amplified by unreliable business knowledge. Result: automation up, overall efficiency down, consistency and quality drop, judgment depends entirely on individual seniority. Seniors amplified; juniors produce volume but low quality — "illusory amplification."

2.2 Path 2: Lean Process — Slice Work into Knowledge Packets ("Nodes")

Approach: Break PM/Dev/QA boundaries; abstract business into "nodes" — self-contained units with business knowledge, curated context, auto-executed by AI.

Example: "Issue one airline ticket" as a complete work packet.

Initial win: High efficiency when packets are fresh.

Ceiling: Enumeration explosion. Packets proliferate, reuse near zero. Next task rarely matches existing packet; must modify or recreate. Can't trust packets built by others — 80% wrong after context shift. Packets become "e-waste." Live operational data (changing runtime state) cannot enter static packets, so end-to-end knowledge chain stays broken. Skills markets in Agent platforms suffer identical rot.

2.3 Path 3: Citizen Development — "Everyone Builds"

Approach: Give low-code/no-code AI tools to business users.

Early win: Airline crew-scheduling team (non-technical, low-priority for IT) built a Dispatch-like web app in weeks — drivers accept orders, fleet dispatched. Deployed and used.

Explosion: Admin, HR, fleet teams all build. System count multiplies.

Ceiling: Information silos return. No interoperability, no shared semantics. Same concept ("Order ID") means phone number in one system, employee ID in another. Cross-department workflows impossible. Ten years of integration undone. Verdict: useful for long-tail unmet needs, but without governance creates new silos and management chaos.

2.4 Common Impasse: Three Unanswered Questions

All three paths stall on: Who knows current facts? Who continuously orchestrates the next step? Who owns outcome and enactment? Stronger models, better Agents, bigger context windows cannot answer these. The fix is organizational: extract project facts from heads into machine-shareable context; unify business semantics via enterprise ontology; reorganize execution, verification, accountability around Agents.

03 Root Cause: The 30% / 70% Mismatch

3.1 Coding Is ~30%; All AI Investment Targets That 30%

Across teams, actual coding consumes ~30% of cycle time. The rest: requirement clarification, endless meetings, human negotiation, rework, back-and-forth. Information loss ~10% at each handoff (biz→PM, PM→arch, arch→dev, dev→QA, QA→deploy). Technical design debates (A vs B vs C), integration standoffs ("you open an API for me"), high QA rework, deployment friction.

Yet 100% of AI tooling budget goes to the 30% coding slice. Best teams see 30% gain; average 20%; worst zero or negative. All tooling operates at individual level, never team level.

3.2 Every Role Has AI, But They Don't Talk

Each role uses isolated AI. Issues detectable at intake still flow to PM; feasibility questions detectable at PM still flow to architecture. Each handoff degrades fidelity. Knowledge inevitably decays in transmission. Industry-wide, no one reports order-of-magnitude gains.

3.3 From Human-Centric to AI-Centric

Traditional R&D is human-centric: knowledge passes person-to-person; managers push schedules; everyone holds private context, stories, skills, mental models. Management = managing people (headcount, skills, communication standards, meeting rituals).

With AI, must shift to AI-centric: give AI context, knowledge, verification gates. The OPC (One-Person Company) fantasy fails because real orgs still need cross-department collaboration. Instead, every dept/role/person uses isolated AI + isolated knowledge + isolated context. The breakthrough: let 10 or 7 people share ONE AI, collectively feeding its knowledge gaps and making judgment calls at decision points.

04 Fourth Path: Extract Project Facts, Let Organization Orbit Them

Goal: whole-enterprise AI-native state, multiplicative throughput.

4.1 Solo AI Is Smooth; Multi-Party Is Painful

Single user: context engineering trivial — tools, knowledge, management all self-centered. Team: how to turn project facts into consistent requirements, design, architecture, test goals that keep refining? Each dept adds its own layer. Need people to own multiple project facts simultaneously.

In AI coding, what is the human? Not writing code/docs — AI does that. Human feeds context, confirms goals, makes key decisions. For teams: distribute confirmation and accountability across roles so each person validates, judges, accepts project facts in the flow.

4.2 First, Sink Knowledge and Fact Chains

Knowledge packets: Capture what each team did, needed, asked AI, produced. Abstract code state into code knowledge packets.

Fact chains: From requirement → proposal → task, record every role's action, who confirmed, who vouched for correctness. Build unified context per team per initiative. Process control integrated.

Agent orchestration, not construction: Best coding Agents come from model vendors (Codex, CodeBuddy, etc.). We become a scheduler (Harness): plug any Agent, dispatch work, write deliverables back into knowledge packets.

Redefined R&D flow: Requirement pool → auto-doc gen per stage → auto-task split (auto vs human) → human gates at decision points — all codified.

4.3 R&D Automation Alone Is Insufficient

R&D serves the whole business. Without real-time ops, admin, sales state, R&D's knowledge is incomplete → goals wrong → output misaligned. Must project the entire company digitally.

4.4 Enterprise Ontology: An 80s Idea Revived by AI

Ontology (TBox/ABox/Rule/Action) describes every business node, template, rule, action. Palantir proved it but kept closed. Pre-AI, building ontology was humanly infeasible (slow, stale). Now: use LLM to generate initial company-wide ontology.

Static ontology misses runtime data (e.g., two buggy orders right now). Must bind ontology to live systems, code blocks, in-flight tasks — make ABox queryable. (Materialization trade-offs deferred.)

Four abstractions: TBox (schema), ABox (instances), Rule (constraints), Action (operations). Unified semantics: customer→order→approval chain, rules per link, actions per node, backing IT system per action. New work pulls consistent semantics from here.

Immediate payoff: dubious requirements killed at intake — ontology simulation shows infeasibility or excessive process violation.

4.5 Govern the "Why": Business Change Entry Points

Historically, change triggers were uncontrolled: boss whim, competitor move, "lights on next door." Root causes never managed.

Now:

AI proactively surfaces anomalies/trends for human response.

Ingest planning signals (new product, competitor moves) into AI knowledge base.

Feed tech demands, production incidents, metric shifts.

Prerequisite: unified business-change semantics — whole company speaks same language ("Order" = same Order; metric = same metric).

4.6 Management Object Shift: People/Timelines → Goals/Context/Dependencies/Evidence

Old: manage people (10/100/1000 heads) to transmit goals/facts downwards. Manage tasks/timelines per person (senior 3 days, junior 6).

New: manage goals, context, dependencies, evidence chains . With massive AI participation, must retain evidence to know right/wrong; then assign accountability. Chain: people/tasks/timelines → goals/context/dependencies/evidence.

4.7 Status Source Shift: Stand-ups → Facts & Evidence

Old: progress via meetings, reports, asking. Devs admit "50% done" is guesswork; "maybe" compounds up the chain.

New: derive status from AI generation logs, fact chains, evidence — not meetings.

4.8 Advancement Mechanism: Human Pushing → Fact-Driven

Old: boss pushes lead pushes dev; senior pushes junior.

New: next step enters only when prior step's facts verified. AI cannot be yelled at; it only responds politely. Gates are fact-validation, not pressure.

4.9 Human Boundary Redefinition: Judge, Unblock, Repair, Escalate

Four human roles in AI flow:

Judgment: validate AI output/execution at critical points.

Dependency unblocking: cross-team/external gaps not in knowledge base.

Repair after verification failure.

Out-of-scope exceptions.

Align human+Agent, multi-human+multi-Agent cognition via open OKF protocol (minimal but better than nothing). Knowledge packets describe: who does what, knowledge needed per layer, who changed what, who confirmed, evidence — all in one packet. Semantic wholeness preserved (not shredded into fields). Packets compose into a workspace — a pipeline flowing forward.

05 After System Runs: Roles Fuse, Efficiency Becomes Measurable

5.1 One Project Fact, Two Chains, Six Production Lines

Example: Member coupon rule upgrade. Touches payment, discount issuance, multiple systems/depts/roles. Old way: scattered. New: fact defined → goal-driven + current-fact judgment → management system dispatches tasks. Enterprise ontology drives two parallel chains (e.g., benefit issuance ↔ benefit recognition). Human judgment at key nodes: tech lead decides placement; biz confirms scope & target. Workbench shows real-time failure/verification counts per node.

Perspective shift: six change points become six Engines running. Humans monitor multiple assembly lines — boundary between dev/test blurs; detection and implementation merge.

5.2 Role Fusion: Dev Steals QA's Work

Transition via dual tracks: management flow + AI execution flow. Clear tracks clarify human actions.

Observed fusion: biz/ops/PM blur; PM does biz work, ops does PM work. Most striking: Dev absorbs QA. Pre-AI: dev codes, self-tests, throws to QA to find bugs. Post-AI: dev didn't write code — AI generated from dev's knowledge. Dev must now verify AI output. Dev becomes tester. Work reaching QA shrinks; reverse fusion (QA doing dev) emerges because roles inseparable.

5.3 Architecture "Secret Sauce" Replaced by Industry Best Practices

Base models contain near-world public knowledge. When facts are explicit, model serves up industry best practices. Proprietary "secret" architectures (some wrong, some suboptimal) get replaced by fair, public best practices.

5.4 Quality Dips Then Rises

Early mass generation lowered quality ("spaghetti"). With standardized team adoption, quality in pilot teams now exceeds hand-written code.

5.5 Efficiency Finally Measurable — For the Next Cycle

Old metrics unreliable: based on human mood, interruptions, meeting overhead, unverified "done." PPT-ready but low confidence.

New: every clarification, coding, verification, rework, confirmation step recorded with fact chain. End-to-end cycle statistically traceable.

Why measure? Not to show speed for more work. Measured efficiency + captured knowledge = evidence & knowledge reserve for next iteration → faster, less human intervention next round.

Back to 30/70: coding (30%) now parallelized via pipelines. The scattered 70% (human confirmations) managed as pipeline stages. Theoretical multiplier = how many concurrent pipelines current headcount can judge/verify/confirm. Pilot shows multiplicative gains (not 10× yet — cognitive switching limits). Ontology completeness still improving. Layered view: task-level gain low; project-level higher; org-level (redefining PM/dev/QA/ops roles) higher still; enterprise-level (full business goals/facts in system) highest — full AI-native enterprise.

06 Software Industrialization: The 8th-Level Fitter's Metamorphosis

6.1 What Changes Isn't Programmers — It's Production Relations

AI coding transforms not individual skill but software production organization/relations. Craft → industry. Flow lines emerge. Sustainable operations. Industrial standards appear. Programmer's craft skills transmute.

6.2 A Kid Shattered the "Spaghetti Code" Dogma

Bay Area conference: youngster asked why seniors obsess over spaghetti code. Senior: "I've been burned." Kid: "You fear it because you read/write code. I use AI — AI doesn't fear spaghetti, doesn't worry about maintainability, I don't care." Premise of the taboo (human writes/maintains) is shifting.

6.3 First-Wave AI Coding Only Reached Mechanization

Industrial analogy: workshop (hand tools) → mechanization (machine tools) → assembly line → smart factory. Software stuck at workshop (whiteboard architecture = craftsmen around bench). First AI coding = mechanization (individual power tools). True assembly line = many Agents driving one pipeline. Multiple lines = automated software factory.

6.4 High-T Programmers = Yesterday's 8th-Level Fitters

Fitters hand-crafted precision screws; most valued. Today's high-P/T engineers = fitters. Modern factories: fitters don't stand at line; they encode expertise into CNC code. Fewer fitters needed on line; more needed to design the production lines. Line designers are just fitters in new form.

Future software factory: controllable parallel pipelines. Count of pipelines = degree of automation. Former elite devs become pipeline supervisors (high-skill confirmation, ambiguity resolution) — their leverage grows.

Already visible: without effective org, top devs get amplified most by AI. Future: amplified further.

6.5 Code Monkeys → Knowledge Engineers; Managers → Goal Definers

Glue-code grunts become knowledge engineers : curate enterprise ontology, confirm rules/flows, run evidence-chain retrospectives/monitoring.

Managers become goal definers : clarify business targets, feed software factory, validate output with users. When AI becomes a production factor, software engineering enters its industrial age.

07 Closing: Three Convictions

AI coding changes not individual skill but software production organization/relations — craft to industry transition underway.

Efficiency ceiling stems not from model/Agent limits but from using human-centric org for AI-centric work — facts stuck in heads, isolated AIs, massive token waste.

The fix isn't stronger tools but organizational capability to govern goals, context, dependencies, evidence chains — plus willingness to do the grunt work of enterprise knowledge engineering.

For every technologist: crossroads. Who first redeploys freed capacity into new frontiers wins. Programmers hold the new weapons first — take them to the new world, achieve dimensionality reduction.