How to Specialize When Anyone Can Ship (2026)
AI didn’t kill specialization — it split it. Here’s the new skill tree, and how to grow it.
I write about AI agents, product thinking, and what it actually looks like to build in the age of agentic systems.
In 1480, a hand-copied Bible took a year and cost the price of a house. By 1500, you could buy one for the price of a wheel of cheese.
The scribes didn’t all become beggars. But the ones who survived weren’t copying anymore.
I keep coming back to this because the same shape is playing out right now. Last month I shipped a feature in an afternoon that, two years ago, would have crossed four roles and three weeks. PM spec, design review, engineering sprint, QA pass, marketing push. Now it’s me, an agent, and a Stripe link.
So who got specialized out of a job? And what’s left worth specializing in?
Short answer: nobody got specialized out. Specialization itself got split in two. The surface (frameworks, syntax, templates) went free, the foundations (first principles, judgment, taste) got scarcer and more valuable. On top of those foundations, a new skill tree replaces the old one: three new relationships with the customer, the agent, and language itself. That’s the whole article.
The gap I watched widen
I used to think AI would make everyone a generalist. I was wrong.
I watched two patterns happen at once. Junior people got faster. And shipped more wrong things. The senior people I respect didn’t get displaced. They got louder. Their judgment compounded against AI speed.
The gap widened. Nobody got specialized out. Specialization itself got split in half.
The surface (frameworks, templates, syntax, the things bootcamps teach) became free. Any agent produces it.
The foundations (first principles, the basic science of your craft, judgment of what’s right) became the only thing left that separates senior from junior.
On top of those foundations, a new skill tree replaces the old one. It isn’t another craft. It’s three relationships: with the customer, with the agent, and with language itself.
Two illustrative archetypes on the five axes I think matter now. The Pre-AI Specialist (blue) won by going deep on one craft and shipping into a relay race; the Post-AI Producer (orange) wins by being balanced across all five and owning the chain end-to-end. The shapes are the argument. The specific values are picked to make the contrast legible, not measured from anyone.
This isn’t a job title. It’s a loadout. And the rest of this piece is how to grow each axis.
This isn’t new. It’s just fast.
Before I get to the how-to, the part that grounds it for me.
The printing press took roughly fifty years to do what AI is doing in five. The structural shape was the same. A surface specialty (copying text) collapsed in cost. By something like 99% in less than two generations. Hand-copied books gave way to print runs. Scribes, who’d been a respected guild for a thousand years, mostly disappeared from that role.
But the foundations didn’t disappear. Literacy, scholarship, editorial judgment, knowing what was worth printing. These got more valuable, not less, because the volume of text exploded and somebody had to curate it. The scribes who survived became editors, type designers, proofreaders. They moved from execution to judgment. Reviewer, not producer.
And three new relationships appeared. With the customer: the bookseller networks, with the Frankfurt Book Fair starting in 1454 as the original distribution moat. With the machine: typesetters and pressmen. The first generation of harness-fluent operators. With language: print forced the standardization of orthography, page numbers, indices, controlled vocabulary. The first shared language with the machine.
Compensation followed output, not seat. Scribes got paid per page. Publishers earned royalties on print runs they bet on. Booksellers earned the spread. The economics inverted from “paid for the work you did” to “paid for the work that sold.”
You can see the same shape in photography against painting after 1839. Cameras made literal accuracy free. Portrait painters who’d specialized in realism lost the market. The painters who survived (first the Impressionists, then everyone after) went where cameras couldn’t follow. They didn’t fight realism. They moved up the stack to what was irreducibly human: light, mood, abstraction, concept.
I’m not saying AI is the printing press, or that this time will be exactly like 1500. I’m saying the shape of the shift (surface goes free, foundations get more valuable, new relationships emerge, comp inverts) has happened before, and the people who recognized it early got rich and famous.
The ones who didn’t became Luddites.
Step 1: Sharpen the fundamentals
This is the part of specialization the printing press didn’t kill. Don’t kill it now either.
What it is. First principles plus the basic science of your craft. The thing that lets a senior engineer debug a system they’ve never seen before. The thing that lets a senior PM smell a fake demand signal across the table. The thing that lets a senior marketer rewrite a headline and have it convert three times.
Why it matters now, more than before. When execution is free, the only remaining variable is “is this the right thing to execute?” That question gets answered by fundamentals, not by frameworks. AI will write your React component. It will not tell you that you shouldn’t have built that feature.
There’s a study that captures this directly. METR ran a randomized trial in 2025 with sixteen experienced open-source developers, on real tasks in mature repositories they’d worked in for an average of five years. The developers predicted AI would make them 24% faster. After the experiment, they felt 20% faster. The actual measurement: they were 19% slower(paper).
The bottleneck wasn’t AI capability. It was the cost of reviewing AI output in a codebase where the model didn’t have enough context to be reliably right. Senior devs accepted less than 44% of suggestions, and spent the rest of their time reviewing, testing, fixing.
Read that again. The most expensive people in software, using the best AI of the moment, on a task they knew cold. Slower. Because the harness around the model was shallow and their judgment had to do all the work.
The lesson isn’t “AI is bad.” It’s: without fundamentals, you can’t tell if AI is wrong. Without harness fluency, telling it is wrong costs more than doing it yourself. Fundamentals and harness fluency are the two axes that turn raw AI capability into output.
Concrete moves:
Audit the last ten outputs an AI generated for you. For each, write one sentence explaining why it’s correct from first principles. If you can’t write the sentence, that’s your study list.
Replace “how would you build this?” with “why does this work?”When pairing with juniors. AI answers the first question for everyone. The second is the one it doesn’t.
Read the boring primary sources. Original RFCs. Original textbooks. The papers that things are named after. AI summaries skip the load-bearing nuance. And the load-bearing nuance is exactly the difference between senior and junior judgment.
I had a moment last month where a junior on a project I was advising generated two hundred lines of correct code to solve a problem first principles would have killed in one sentence: this state shouldn’t live on the client at all. The output was right. The decision was wrong. AI flattens the gap on the first. It widens the gap on the second.
Step 2: Grow the distribution skill tree
The scribes who survived didn’t just know how to spell. They knew which booksellers to stand next to. Same now. Sharp fundamentals tell you what’s right; they don’t tell anyone you built it. The next three layers all push outward into the relationships that turn output into impact, and distribution is where I’d start, because that’s where most builders today are weakest.
The new moat. Boring. Necessary. The reason most of the talented engineers I know aren’t paying their rent from what they build.
What it is. Networking, sales, customer development, partnerships, community, public writing. The work that used to belong to a sales function. Now it belongs to every producer.
Why it matters. Building is cheap. That’s the whole previous essay. The bottleneck moved.
Look at the numbers. The median SaaS company in 2024 spent $2.00 on sales and marketing to acquire $1.00 of new ARR. Up 14% in a single year. The average B2B SaaS now spends roughly $1,200 to acquire a single customer. Payback periods stretched to 23 months. Meanwhile, the cost of building a comparable product dropped by an order of magnitude: an MVP that ran $140K in 2022 can run $14K now, sometimes less.
Build cost down 90%. Acquire cost up 14% in one year, and still rising. The crossover point passed a while ago. Distribution is now more expensive than the thing being distributed.
What that looks like at the employee level: the engineers I know who can ship a SaaS in a weekend and can’t get to ten paying users in three months. The product was never the problem. The skill they don’t have is talk to thirty strangers a week and not flinch. Cold outbound. Public writing. Community presence. The boring reps.
Concrete moves:
Pick one distribution sub-skill. Cold outbound. Community presence. Partnerships. Public writing. Customer interviews. One, not all. Treat it like a real skill, not a side activity.
Run weekly reps. Thirty customer conversations a week is the new LeetCode. Track them in a spreadsheet. The compounding takes six months. The first month feels useless. Do it anyway.
Negotiate compensation that follows output. If you produce end-to-end and ship sales, share in the sales. Per-producer bonus, not per-role salary. The companies that resist this will lose their producers to the ones that don’t. (More on this below.)
If you’re reading this and recoiling (I’m an engineer, I don’t want to sell), keep reading. There’s a path for you too. But you should know that you’re picking it on purpose, not by default.
Step 3: Master the agent workspace
This is the longest section. It’s also where I think the biggest 10× lives.
What it is. Knowing the runtime. Not “I use Claude.” Knowing how Memory, Skills, Plugins, Hooks, Sub-agents, and the scheduler compose into something that does work while you sleep.
Why it matters. Two people use the same model. One gets 1× output. The other gets 10×. The model is identical. The harness fluency is not. This is the new keyboard-shortcut mastery. Except the leverage is two orders of magnitude higher.
There’s a survey number that captures the gap. Stack Overflow’s 2025 developer survey: 84% of professional developers use AI tools. Only 29% trust them. Down from 40% in 2024. The biggest single frustration, named by 66% of developers, is dealing with “AI solutions that are almost right, but not quite.” The second-biggest is debugging AI-generated code taking longer than writing it from scratch.
That gap between using AI and trusting it is the gap that harness fluency closes. The people who trust AI output aren’t smarter. They’ve built a workspace where AI output can be trusted by construction: scoped to one job, gated by hooks, reviewed against shared memory, executed by a sub-agent with clean context. The harness does the work that trust would otherwise have to do.
The agent workspace. One diagram
Six surfaces. Six things to learn. Most people only know one or two.
The difference between 1× and 10×
Most people prompt like this:
Can you help me write a competitor analysis? My company is [explains for
200 words]. The competitors are [pastes 5 URLs]. Please summarize their
positioning, pricing, and recent launches in a table.The agent does the job. You do it again next week. And the week after. Same context, same setup cost.
Here’s the same task, leveraging the workspace.
CLAUDE.md. Memory, written once:
## Company
Curiosity Insights. Practitioner newsletter on AI agents,
single author, voice: direct/curious/practitioner,
audience: Gary Tan-style builders.
## Competitors-to-watch (auto-updated)
- substack.com/@latentSpace
- techcrunch.com/category/ai
- ...
skills/competitor-watch/SKILL.md. Job description, written once:
---
name: competitor-watch
description: Use when the user wants a weekly competitor brief.
---
# Competitor Watch
## Inputs
- Read CLAUDE.md → Competitors-to-watch list.
## Output (always this exact shape)
| Competitor | What changed | Why it matters | Suggested move | Source |
## Schedule
Run every Monday 09:00 (scheduler).
## Handoff
Append to briefs/<YYYY-WW>.md. Notify via desktop hook.
Then, every Monday, without me touching it, the runtime fires:
/competitor-watchTwo words. The agent reads memory, the skill knows the format, the plugin fetches the URLs, the hook drops the file in the right place, the scheduler runs it again next Monday. Same model. Different harness fluency. Roughly 10× the leverage over the lifetime of the workflow.
Three patterns worth learning first
If you’re starting from zero, this is the order I’d grow harness fluency:
Memory before re-pasting context. Any time you catch yourself re-typing the same paragraph of company / project context, stop. Put it in
CLAUDE.md. The agent reads it for free on every session.Skills before re-prompting. Any time you re-type the same multi-paragraph prompt for a recurring task, turn it into a
SKILL.md. Reusable behaviour, no re-prompting.Sub-agents before mega-prompts. Long, branching tasks belong as a chain of
Explore → Plan → Tasksub-agents with clean context boundaries. Not one mega-prompt that loses track halfway through.
This isn’t an exhaustive list. It’s the cheapest 80% of the leverage.
Step 4: Build the shared language
The discipline that makes everything above work.
