The skill stack, side by side
1. How to read this
Below is the working skill stack of a senior IC, with each skill rated by how much weight it carries on a typical day. The scale is rough but useful: critical, high, medium, low.
Traditional weight is the 2015 column. AI-era weight is the 2026 column. Commentary is added only when the shift is worth a sentence.
2. The stack
| Skill | Traditional weight | AI-era weight | Comment |
|---|---|---|---|
| Typing speed | High | Low | The model writes the first draft. You're typing prompts and edits, not whole files. |
| Memorizing language syntax | High | Low | The model knows every standard library. Looking things up is free now. |
| Knowing algorithm patterns | Medium | Medium | Still useful to recognize one when the model uses it. Less useful as recall under pressure. |
| Specification clarity | Medium | Critical | The single skill that has gone up the most in weight. |
| Verification (does this actually work) | Medium | Critical | The model produces confident-looking code that's sometimes wrong. Catching that is the job. |
| Architecture (system-level thinking) | High | High | Same weight. Maybe slightly higher, because the model makes shipping code cheap and shipping the wrong thing easy. |
| Written communication | Medium | High | Specs, pull request descriptions, decision docs. All of it matters more. |
| Code review | Medium | High | More code is shipping per engineer. Each pull request needs a careful reader. |
| Debugging | High | High | Same weight. The bugs are different (model-generated edge cases instead of typos) but the skill carries. |
| Reading code fast and well | High | Critical | You read more code than you write now. Reading well is the highest-leverage skill in the day. |
| Picking the right tool (library, language, service) | Medium | High | The cost of starting in the wrong direction went up because the model lets you go there faster. |
| Knowing when to stop | Low | High | The model will keep generating. You need to know when the work is done. |
| Knowing what to build at all (taste) | Medium | High | Cheap building means more chances to build the wrong thing. Taste is the brake. |
| Domain knowledge (business, users, problem space) | Medium | High | The model has none of it. You're the only source. |
| Pair-programming and mentoring | Medium | High | Junior engineers need more help reading what the model produced. Mentoring is more of the senior's day. |
| Comfort with new tools | Medium | High | The tooling around the model shifts every six months. You'll be relearning more often. |
| Mathematical and statistical thinking | Low | Medium | Helpful when the work involves the model's own behavior, evaluation, or data pipelines. |
3. The pattern in one paragraph
The skills that lost weight are the mechanical ones: typing, syntax recall, pattern memorization. The skills that gained weight are the judgment ones: specification, verification, taste, reading, communication. Architecture and debugging held their weight because they were already judgment-heavy.
4. What this means for what to learn
If you're starting now, lean toward the right column. Spend time on:
- Writing clear specifications, the way you'd write to a colleague who has no context.
- Reading other people's code, including code the model produced, and catching the wrong things.
- Building and using a working sense of taste — when is this code good enough, when is it not.
- Communicating decisions in writing so future you and other engineers can follow them.
That doesn't mean ignore the left column. You still need to be able to read code, which means knowing what code looks like, which means having written some yourself. The point isn't that the old skills are useless — it's that they're table stakes now, not differentiators.
The next unit names what got easier, what got harder, and what disappeared.