Skills to Deepen and Skills to Stop Investing In

Learning time is finite, and some of what was worth learning five years ago isn't worth the same investment now. Being explicit about the divest list is harder than the invest list and more useful, because the default is to keep investing in what you're already good at.

Worth deepening

Reading and understanding unfamiliar systems. The ability to open something you've never seen and build a real model of it. This is what debugging and reviewing require, and it's the skill most directly threatened by delegation — which makes it the one most worth deliberately protecting.

Verification. Judging whether output is right, including whether it's the right output. Distinct from producing, and it's the constraint now.

Specification. Writing requirements precise enough to be implemented and executable enough to be tested. Increasingly the input to everything downstream.

Debugging from first principles. Reproduce, localize, form hypotheses, test them. Pattern-matching symptoms to fixes is what agents do; reasoning from how the system works is what's needed when the pattern doesn't apply.

Systems thinking. How components interact, where failures propagate, what's load-bearing. Appreciating as systems get more numerous and less individually understood.

Domain knowledge. The least replicated input available.

Writing. Specifications, decision records, explanations. As more work happens through written artifacts, the ability to write precisely is directly load-bearing rather than a soft skill.

Worth less than it was

Breadth of framework and API knowledge. Knowing many libraries' surfaces was valuable when that knowledge was scarce and hard to look up. It's now the most thoroughly replicated category there is. ⚠️ Enough to evaluate and debug: yes. Encyclopedic recall: no.

Speed of implementation. The specific thing that got automated.

Memorized syntax and idioms. Same reasoning.

Tool-specific proficiency as an identity. The tools change every few months. Use them well; don't build a career position on this month's one.

Writing boilerplate well. Real skill, now mechanized.

🔍 The test for anything you're considering learning

Two questions:

Is this knowledge or judgment? Knowledge is replicated. Judgment about when and whether isn't.

Does it accumulate in a place, or transfer generically? Generic knowledge is what everyone can get. Knowledge specific to your domain, your systems, your customers, is scarce because it can only be acquired by being there.

→ Both questions point the same direction: toward things that require being embedded somewhere over time and away from things that can be looked up.

💡 The uncomfortable case

The hardest divest is a skill you're excellent at that's on the depreciating list. Being fast and fluent at implementation is a genuine achievement that took years, and it's the most exposed thing in the bundle.

The instinct is to lean harder into it, because it's what you're good at and being good at things feels safe. That's the wrong direction, and it's an easy mistake because the skill still works — the feedback is fine right up until the market for it changes.

The transferable part is real, though: the taste that made your implementations good is exactly what's needed to evaluate generated ones. The judgment transfers even where the production doesn't.

✅ What to do this quarter

• Pick one system and learn it deeply, including its history. Depth in one beats breadth across many.
• Write one real specification, precise enough that someone could implement it without asking you anything. Notice what you had to decide.
• Review something properly, asking what it missed rather than whether it's well written.
• Learn one thing about your domain you didn't know — from a customer, from finance, from support.
• Stop learning a framework you don't currently need. That's the divest, and it's the part people skip.

The takeaway

Deepen the reading, verifying, specifying, debugging, systems thinking, domain knowledge, and writing. Reduce investment in framework breadth, implementation speed, memorized syntax, and tool-specific identity. The test is whether it's knowledge or judgment, and whether it accumulates in a place or can be looked up. And notice if the thing you're best at is on the wrong list — the judgment behind it transfers even when the output doesn't.