01/7 — Why fundamentals still matter: your agents aren't dumb, they're amnesiac

On Monday, you explain to an agent that a 200-line function is not acceptable. On Tuesday, a fresh agent writes one with 250 lines. On Wednesday, you remind it not to add a dependency without asking. On Thursday, another one adds three. On Friday, you rewrite your system prompt for the fourth time. You’re not doing software development. You’re teaching the same class, every day, to a student who forgets everything between sessions.

Fast, tireless, tasteless

A coding agent has three properties that change everything.

It’s fast. Hundreds of lines in seconds. The cost of producing code has dropped to almost zero.

It never gets tired. It doesn’t feel the pain of a codebase that’s becoming miserable to work in. A human eventually refactors out of sheer exasperation. An agent never will.

It has no taste. No built-in preference for simple over complicated, readable over clever, deleted over added. It reproduces statistically common patterns, good and bad alike.

Put together, you get an amplifier. With good guardrails, it amplifies quality. Without them, it amplifies exactly the mistakes our industry spent decades learning to name.

Lessons we’ve already paid for

Almost every problem you hit with agents already has a name, a date, and a known fix: Gall and KISS, Dijkstra, Fagan, Parnas and Ousterhout, Hoare and Meyer, McIlroy, Brooks, Conway, Lehman, test-first and mutation testing, Knuth, Chesterton and Hyrum.

The industry paid for each of those lessons with failed projects and years of painful maintenance. Relearning them one agent at a time means paying twice.

The prompt is not a guardrail

Writing the lessons into the prompt helps, but an instruction gets diluted in context, competes with the immediate goal, and vanishes when a new agent shows up. What holds is structural:

• A linter set to error, not “write short functions.”
• Strict types and a compiler, not “validate your inputs.”
• Module boundaries checked in CI, not a diagram on a wiki.
• A separate critic agent with a checklist, not “double-check your work.”
• Mutation testing as a gate, not “write good tests.”

A structural guardrail applies to every agent, every task, every time. You encode the lesson once, in the environment.

The road ahead

The next five articles group these principles into steps: start right, make wrong code impossible, verify, scale without chaos, and don’t break what works. The last one is the toolkit: every Agent Skill from the series, on one page.

Takeaways

• An agent is fast, tireless, and tasteless: an amplifier of quality and mistakes alike.
• Almost every agent problem already has a name and a fix, from sixty years of software engineering.
• The prompt is not enough: encode lessons in linters, types, CI, and separate roles.
• The fundamentals aren’t nostalgia: agents make their constraints sharper, not obsolete.