What Engineers Still Need to Know When AI Agents Code

Open original

The author argues that as AI coding agents write more of the software, engineers need less of a hand-built mental model of every line and more of a high-level map of their systems, plus the ability to dive into any part when something breaks. He says the old path of learning by writing and debugging by hand isn't economically viable for juniors, so the industry needs a different way to build that understanding.

  • A coding agent (Codex) packed about 15 React components onto single lines and produced complex logic that tripped SonarQube's cyclomatic complexity check; the author reviewed it, found the complexity justified, and had the agent split it into 10 files.
  • Traditional ownership of a system came from years of writing, reading, and debugging code by hand. Agents break that link because code now often never passes through a human's hands.
  • Both camps are wrong: "read every line" doesn't scale and companies won't fund juniors to learn by hand, while "don't look at the code" leaves owners unable to handle production failures.
  • The proposed path is fundamentals plus breadth: a working map of system abstractions and failure modes, with just-in-time depth where the monsters actually live.

The author's CI pipeline failed on App.tsx, a file that had been about 30 lines of code, except that 15 of those lines were entire React components squashed onto single lines by Codex, the coding agent. SonarQube was flagging cyclomatic complexity. The author dug in and found the complexity was warranted: the components carried real business logic and handled edge cases a typical developer might have covered more loosely, with a bit of over-engineering. The fix was to ask Codex to split the file into 10 files, CI passed, and the code shipped. The author's point is that this went fine partly by luck, since they had never seen this code before, and it could have gone much worse. The core argument is that ownership of software is shifting. Traditionally you built a working mental model of a system by writing and debugging its code over years, and that model is what let you respond when something broke. Agents produce code faster than anyone can absorb it, and nobody in the chain may have hand-written it. The author frames the industry as split between Optimists, who trust agents to build and let the human focus on what to build, and Skeptics, who say you must read and be able to hand-write every line. The author thinks neither extreme holds up. The Skeptic route is an unrealistic training path, since companies won't pay juniors for years to learn by hand, and the Optimist route produces the horror stories the metaphor depicts: divebots that get lost, build grotesque structures, and leave them for the next generation to discard. The author's proposed direction is that what matters now is knowing enough to recognize when something is wrong, plus the willingness to go as deep as needed when it is. The analogy is a boat operator who doesn't need to dive every mine but must hold an accurate chart of the waters and know which spots need a closer look. The real open question, as the author frames it, is how much of the system an architect or lead needs in their head, and at what level of granularity. The piece is less a set of answers than a map of the problem, and it treats the training gap for the next generation of engineers as the hardest unsolved part.

Ask about this article