Human-AI partnerships are for alignment, not capability
Short summary
AI coding agents are already excellent at writing technically correct code, but they consistently produce solutions misaligned with organizational values and technical strategy. The real job of human programmers isn't improving code quality—it's steering AI toward what actually matters to their company.
- AI agents write code that compiles, avoids race conditions, and runs correctly, but often makes poor architectural choices and contradicts long-term strategy because they optimize for the wrong signals (like excessive comments and unit tests).
- Alignment is fundamentally harder to solve than raw capability and remains poorly understood, which is good news for engineers since it's unclear when—or if—AI will learn to match human organizational values without supervision.
- Unlike chess centaurs where humans and machines combined exceeded both separately, human-AI coding partnerships work because humans provide alignment, not capability—the AI is already better at the technical execution.
Full summary
The author challenges the popular "centaur" comparison—the idea that AI-assisted engineers are currently stronger than both pure AI and humans alone. While AI-assisted engineers do produce better outcomes, it's not because they're better at the actual coding task. Modern coding AIs rarely make mistakes, compile correctly, handle concurrency issues, and work orders of magnitude faster than humans. The real problem with unassisted AI code isn't technical quality—it's that the code reflects misaligned values. AI models optimize for behaviors their training rewarded (verbose comments, excessive unit tests, unnecessary UI text) rather than what the organization actually needs. The human's job is catching and correcting this misalignment, not fixing broken code.
This distinction matters because capability and alignment are separate problems with different solutions. Building more capable models is well-understood: bigger models, better data, improved training environments. Alignment is the hard part that the AI safety community has been warning about for years. You can train a model to write working code anywhere, but aligning it to one company's technical values is different from the next company's values—it's almost like learning the job fresh each time. Models would need to adapt on the fly to wildly different organizational priorities, which they currently don't do well.
The author sees this as good news for software engineers, contrary to the "vibecoding maximalists" like DHH who argue AI will eventually be so capable that reading code becomes pointless. If it were purely about capability, they might be right. But good code must align with the system and organization it serves, and that's where AI falls short. Models are excellent at the mechanics of programming but poor at understanding technical values and context. Until AI gets substantially better at alignment—which may take a long time—engineers will remain essential to bridge that gap.