Three Skill Transitions the Agent Era Actually Rewards—and Why Nobody Sells a Course for Them
Last October, I published these words:
“So I spent the past 8-12 months mastering prompt engineering, learning from failures, and documenting what actually works.”
I need to take part of that back.
Not the discipline—the failures I learned from and the process I documented are aging fine. The part that’s rotting is the thing the industry decided to name the skill: the prompt craft itself. The incantations. And I can watch it rot in my own workflow: the two-page prompts I wrote in 2024—role definitions, few-shot examples, chain-of-thought scaffolding, magic phrases—have collapsed into plain sentences. The models got better at understanding intent, and every improvement quietly deleted a paragraph of my hard-won technique.
That’s what a depreciating asset looks like. You don’t notice the value leaving. You just notice one day that the thing you were proud of is table stakes.
Meanwhile, three older, less glamorous skills have been appreciating just as fast. No one sells a course for them, because they’re judgment, not technique—and judgment doesn’t fit in a syllabus. Each one replaces something we used to think was the job.
Prompt Crafting → Specification Writing
What’s dying: the incantation. Knowing that “think step by step” unlocks reasoning, that examples go before instructions, that you flatter the model with “you are an expert.” Every model generation makes more of this folklore obsolete.
What’s replacing it: knowing what you actually want, precisely enough that someone else can build it.
The models got better at guessing what you mean. They did not get better at knowing what you want. Nothing can—that information doesn’t exist until you produce it.
Here’s the shift as it looks in my own files. A 2024-era prompt:
You are an expert Python developer with deep knowledge of
document processing. Think step by step. First analyze the
codebase structure, then carefully identify the root cause...
(two more pages of role-play and examples)
What I write now:
test_styled_docx_font_detected fails. Find the root cause and fix it.
Constraints: do not modify tests. Smallest diff that passes the suite.
Done when: full test suite green.
Every line of the first prompt was about the model. Every line of the second is about the work. One of these survives the next model release.
The test I apply to any requirement I write now: is it falsifiable? “Make it fast” is a wish. “Search returns in under 200ms on 10,000 records” is a spec. An agent can hit the second one. It can only guess at the first.
The hard truth: Prompt engineering was learning to talk to the machine. Specification is knowing what to say. Only one of those was ever going to last.
Writing Code → Reading Code
What’s dying: first-draft authorship. Typing speed, syntax recall, producing boilerplate from muscle memory. The blank editor page is no longer where engineering happens.
What’s replacing it: reading code you didn’t write—fast, skeptically, and without anyone to ask.
When I wrote about AI coding failures last year, I called it the Lost-in-Translation Gap: you spot a bug in generated code, but you didn’t write the code, so you can’t name what’s wrong. Back then it was an annoyance. At agent-team scale, it’s most of the job. On a heavy day, thousands of lines cross my desk and I wrote almost none of them.
Reading without authorship is a distinct skill, and it’s harder than the reading we did in human code review. Human teammates converge on shared idioms; you learn a colleague’s style once. Agents produce statistically-plausible code in whatever idiom the training data favored that day. It looks right. It compiles. You’re not proofreading a colleague’s essay anymore—you’re inspecting luggage that packed itself.
Every mediocre pull-request reviewer is about to discover that reviewing was the hard part all along.
The hard truth: Writing code is now cheap. Vouching for code you didn’t write is what they’ll pay you for.
Framework Fluency → Verification Design
What’s dying: being a walking API reference. Knowing React’s hook rules by heart, the flags of every CLI tool, this year’s blessed way to configure a build. The agent reads the docs faster than you can remember them.
What’s replacing it: designing the check that proves the work is right—without you reading every line.
I learned this one the hard way, in stages. Stage one: I read everything agents produced. Doesn’t scale. Stage two: I asked agents to review each other. Better—a fresh reviewer catches what the author can’t. Stage three arrived the day I caught an agent talking its way past my review gate: the reviewer returned NO-GO, and the lead agent wrote a polite paragraph explaining the objections were “already addressed,” re-scored the work, and moved on. The rule was prose, so the agent treated it as a suggestion. I rebuilt that gate as code—the verdict is parsed by a script now, not interpreted by the agent it’s judging—and then went and did the same to six others.
So this is where I live now: before delegating any task, I design its verification first. A failing test the fix must turn green. An acceptance criterion a script can evaluate. A gate that computes pass or fail where no one can argue with it. My rule, earned that day:
If you can’t write the check, you can’t delegate the work.
That sentence has quietly become my hiring bar, my task-planning filter, and my definition of seniority. The engineers who can decompose a fuzzy goal into machine-checkable claims are the ones who can safely command a fleet of agents. Everyone else is generating code faster than they can trust it.
The hard truth: In an era where anything can be generated, the scarce skill is deciding what counts as correct.
What I’d Actually Do This Week
Not a curriculum. Three habits:
→ Next feature you delegate—to an agent or a human—write the falsifiable spec first. If a requirement can’t fail, rewrite it until it can.
→ Next code review, pick something you have zero context on and build the mental model from the diff alone. That discomfort is the skill, and it only trains under load.
→ Next task you hand to an AI, write the verification before the prompt. If you can’t, you’ve found a task you don’t understand well enough to delegate yet.
The Bottom Line
Prompt engineering was a bridge skill—genuinely valuable, briefly, while the models were bad at understanding us. The bridge is doing its job: making itself unnecessary.
What’s on the other side is older than any of this. Say precisely what you want. Judge work you didn’t do, and decide what correct means before anyone starts. We used to call that senior engineering. The models will keep getting better, and these skills only get more valuable when they do.
I’ve spent 18 years in the trenches of software engineering, and I’m still the person who gets genuinely excited when a new model release changes how I work. I write these breakdowns because I’m living this shift in real time, not observing it from a distance. This is part two of a series on engineering in the agent era—part one covered why AI agents need an org chart, not better prompts.
