Latest / ELECTE's Podcast: AI Frontiers / Nobody Pays Programmers for Code

Transcript

Nobody Pays Programmers for Code · ELECTE's Podcast: AI Frontiers

• 0:00
  SPEAKER_00: This is AI Frontiers.
• 0:02
  SPEAKER_00: Today, who actually pays programmers and why?
• 0:06
  SPEAKER_00: Firms do not pay for coding skill.
• 0:08
  SPEAKER_00: They pay for proximity to revenue, control, and liability.
• 0:13
  SPEAKER_00: That is the core argument.
• 0:16
  SPEAKER_00: AI does not change the mechanism.
• 0:18
  SPEAKER_00: It makes it visible, and it widens the gap between those who define systems and those who execute inside them.
• 0:25
  SPEAKER_00: Start with the most cited productivity number.
• 0:28
  SPEAKER_00: The Peng et al.
• 0:29
  SPEAKER_00: controlled experiment on GitHub.
• 0:32
  SPEAKER_00: Copilot found that developers completed one bounded JavaScript task 55.8% faster than a control group of 95 professional developers.
• 0:42
  SPEAKER_00: That was a lab style task, not production telemetry.
• 0:46
  SPEAKER_00: Strategic depth and code quality did not rise at the same rate.
• 0:50
  SPEAKER_00: Routine implementation gets faster.
• 0:52
  SPEAKER_00: Judgment does not automatically compound with it.
• 0:56
  SPEAKER_00: A 2025 randomized trial by Meter found something sharper.
• 1:00
  SPEAKER_00: Experienced open source developers working in their own mature codebases were actually slower with early 2025 AI tools, while believing they had been faster.
• 1:11
  SPEAKER_00: The U.S.
• 1:11
  SPEAKER_00: Bureau of Labor Statistics projects software developer employment to grow 15% from 2024 to 2034, with roughly$129,200 openings per year.
• 1:24
  SPEAKER_00: Median annual pay for software developers was$130 in May 2024, large numbers.
• 1:33
  SPEAKER_00: But they flattened the difference between software as a core competitive asset and software as administrative overhead.
• 1:40
  SPEAKER_00: The useful taxonomy is not front-end versus back end, it is proximity to economic control.
• 1:47
  SPEAKER_00: System architects define boundaries and shape future option value.
• 1:51
  SPEAKER_00: Product engineers translate commercial ambiguity into coherent software under real constraints.
• 1:58
  SPEAKER_00: Implementation specialists execute bounded tasks inside established frameworks.
• 2:03
  SPEAKER_00: That last layer is easiest to benchmark, template, and compress.
• 2:08
  SPEAKER_00: AI accelerates that compression.
• 2:11
  SPEAKER_00: Generative tools are strongest on bounded work, where patterns are common and success can be checked quickly.
• 2:17
  SPEAKER_00: They are weakest where the task is choosing trade-offs under uncertainty and seeing second-order effects across systems.
• 2:24
  SPEAKER_00: For employers, faster output creates durable value only if someone still controls architecture, testing standards, security assumptions, and failure handling.
• 2:35
  SPEAKER_00: If that control layer is thin, AI raises the speed at which organizations accumulate technical debt and compliance risk.
• 2:42
  SPEAKER_00: The B plus trap applies directly.
• 2:45
  SPEAKER_00: AI lowers the cost of producing plausible looking code.
• 2:50
  SPEAKER_00: It does not lower the cost of being wrong in production.
• 2:53
  SPEAKER_00: One strong technical lead can now direct more implementation work than before, whether done by junior staff, contractors, or AI-assisted teams.
• 3:02
  SPEAKER_00: That increases the span of control at the top and weakens the position of workers whose contribution sits mainly in straightforward execution.
• 3:11
  SPEAKER_00: The most important shift may not happen in the editor at all.
• 3:15
  SPEAKER_00: It happens in procurement terms, liability clauses, security schedules, and model usage rules.
• 3:22
  SPEAKER_00: Contracts now determine more software behavior than many engineers want to admit.
• 3:26
  SPEAKER_00: That's AI frontiers.