AI is changing developer work. Here are three skills to strengthen.

Directing AI is now a core engineering skill
The old flow for adding a feature looked like: create branch, write code, run tests, open pull request. With capable agents wired into the workflow, that same task becomes a coordination exercise — you spin up multiple agents, one handles the auth code, another drafts documentation, a third builds the test suite. You're still accountable for the result, but you're not typing every line. The real work is defining the problem scope tightly enough that agents don't wander, reviewing what comes back, and making the calls on what actually ships.
That's a different muscle. Writing code well doesn't automatically mean you can spec work for an agent well. The skill is in the prompt: giving enough context, constraints, and acceptance criteria that the agent doesn't need to guess. Vague instructions produce confident but wrong implementations.
Never ship the first answer
Models generate plausible solutions fast, but plausible isn't the same as correct. The blog's concrete suggestion: run the output past a second model as a critic before you trust it. Say you ask for a SQL query returning each customer's most recent order. The first model produces something that looks right. A second model reviewing it might flag duplicate timestamps, a missing index recommendation, or poor performance on large tables.
That's why Copilot has a built-in Rubber Duck agent — it uses a second model to critique plans, code, and tests before you proceed. Different models have different blind spots, so a second perspective catches what the first missed. Then you apply your own judgment on top of both. The point isn't to distrust AI entirely; it's to treat the first output as a draft, not a deliverable.
Use freed-up time for problems AI can't touch
When an agent handles the implementation, tests, and docs for something like adding dark mode (Issue #4821 in the example), the developer checklist shifts to what's left: validating the customer problem actually exists, reviewing architectural tradeoffs, checking accessibility, defining success metrics, and approving the solution.
That's the part AI can't do for you. It won't know whether the feature is worth building, whether the approach creates maintainability debt, or what "done" means for users. Those judgment calls are where engineering experience still matters most. The developers who thrive are the ones who use AI as leverage to spend more time on the decisions that shape the product.
None of this requires waiting for some future tooling update. You can start today — pick a small task, delegate it to an agent, and practice reviewing the output critically. The skills compound: better direction leads to better output, which frees more time for the judgment work that builds career value.
The bottom line is that the bar for engineering isn't lower now, it's different. Implementation chops still count, but they're table stakes. The differentiators are direction, evaluation, and judgment — and those are all trainable right now.