Jared Palmer
Short summary
As AI generates code faster than humans can write it, good taste in programming moves upstream—from judging individual lines to asking the right questions about what to build. The programmers who'll get most out of AI tools are those who already know what they want.
- Human taste during coding happens at typing speed, which constrains damage from bad decisions. AI removes that slowness, so taste becomes a reviewing filter—but reviewing is harder than writing and happens too late to catch fundamental design mistakes.
- The most important choices (what to build, how to split it, what to omit) happen before the model writes anything. A well-executed answer to the wrong question is still wrong.
- Models will get good at local code judgment (idioms, naming, structure) but can't learn domain-specific taste—knowing which complexity matters, how users will behave, where the system will change. That knowledge lives with the people who own the problem.
Full summary
When you code by hand, taste—the ability to make good design decisions—develops naturally because you're moving slowly enough to catch your mistakes. AI tools flip this. You can now generate hundreds of lines in seconds, which means the slowness that limited bad decisions is gone. Taste shifts from something you exercise while writing to something you exercise while reviewing. But here's the catch: reviewing is harder than writing because you have to reverse-engineer why each line exists. You're also judging way more code than you'd ever create yourself, so the filter gets stretched thin.
The real problem sits upstream of review. By the time you're looking at generated code, the crucial decisions are already made—what to build, how to split it up, what to skip entirely. If you ask an AI to build a caching layer when your actual problem is fetching the same data three times, you'll get a perfectly built cache that doesn't solve anything. Taste about your specific problem—which complexity matters, what users actually do, where the system will break next year—lives in the heads of the people who own it. Models learn local judgment (this loop should be a map) from examples easily enough, but they can't learn what the program is actually for.
This means the programmers who'll get the most from AI tools aren't the ones who become prompt engineers. They're the ones who already knew what they wanted to build before they started. The valuable skill is now thinking deeply about problems before writing anything, not optimizing code after it's generated. Taste about code quality matters less because tools handle that. Taste about what shape the program should have—the architectural decisions that every line of generated code inherits—matters more.