The Developer
Implements products and systems on top of foundational technology. In peak demand in every cycle — but not every developer equally. The difference is visibility, and it compounds for years.
What the Developer does
The Developer builds the second layer of a technology wave: wallets, interfaces, tooling, integrations — everything that makes foundational technology usable. They're not inventing protocols or training frontier models; they're translating those breakthroughs into working products.
That translation gap is structural: in every cycle, the distance between research and usable software is large, and it reopens with every new capability. This is why the Developer is in demand across all phases — the application developer implementing LLM integrations today sits exactly where the wallet developer sat in the crypto wave and the driver developer sat in the Linux wave.
But not all developers are positioned equally. The one who only implements tickets is commoditized by time — and increasingly by AI codegen. The one who understands whytheir architecture makes sense, writes publicly about what they're learning, and contributes to the tools everyone else uses: that developer is irreplaceable, and converts the cycle into leverage.
Three subtypes
The Developer role splits into three subtypes with different economics and conversion paths:
Backend Developer
Durability: HighSystems, pipelines, infrastructure — the parts nobody sees until they break. Deepest technical moat, strongest path to Staff/Principal roles at infrastructure and AI-platform companies. The risk is invisibility: backend work is the easiest to under-communicate.
Frontend Developer
Durability: MediumOwns how the product feels. High demand in hype phases when every project needs a face — but routine implementation sits closest to what AI codegen commoditizes first. The durable version moves up the stack: design systems, product judgment, founding-engineer roles.
Designer-Developer
Durability: HighOwns a feature end-to-end, from Figma to deploy. Rare combination, awkward on large teams (neither a 'real' designer nor a 'real' engineer to specialists) — but the canonical solo path: this is the profile behind most successful micro-founders.
How the Developer earns
The Developer is primarily a direct-monetization role — one of the few in the ecosystem where competent work pays from day one. The compounding, however, is indirect: track record converts into the high-leverage positions.
Failure modes
Tutorial hell
Watching tutorials about building things instead of building things. Understanding an explanation is not the same as being able to build. After the first tutorial in any domain: close the browser, open an editor, build something adjacent.
No visibility
Code nobody reads has half the career impact of code people engage with. The portfolio without a README explaining the decisions, the contribution without a post about what you learned — all missed leverage. Two developers with equal skills will have systematically different careers within 2–3 years based on who builds in public.
Stack-hopping
A new framework ships every few weeks, each promising to fix the last. The developer who tries each one 'to stay current' builds neither depth nor a coherent portfolio. Pick one backend language, one frontend approach, one AI integration stack — and go deep.
Getting instrumentalized
Building products without seeing that the business model is extractive. The engineers who built the FTX/Alameda backdoors were developers too. Technical excellence doesn't launder what the system does.
Real examples
Same role, different costumes — the second-layer builder shows up in every cycle.
Linux / open-source cycle
- · Alan Cox (Red Hat)
- · Greg Kroah-Hartman (SUSE)
- · The salaried kernel engineers
Web / JS cycle
- · Guillermo Rauch (Next.js → Vercel)
- · Evan You (Vue → Vite)
- · The framework-era product devs
AI cycle
- · Simon Willison (LLM tooling)
- · Founding engineers at AI startups
- · The LLM-integration specialists
How to start
The gap for most developers is almost never technical skill — it's legibility. The market can't hire what it can't see. The developer who enters a cycle early with a clear specialization is a senior specialist by the time demand peaks; the one who waits enters at the peak, alongside everyone else.
Depth beats breadth, building beats watching, and visibility multiplies the value of both. That's the whole discipline.
First step from the playbook
Build a tool you personally need — and open-source it immediately. The README that explains your decisions matters more for your career than the code.
Is the Developer right for you?
The Developer suits people whose energy comes from the work itself rather than from recognition or momentum in a room — the profile where a Saturday spent building something until it works by evening counts as a great Saturday, and where infrastructure that people only notice when it breaks feels like the best kind of work.
It rewards deep-focus tolerance and punishes pure heads-down invisibility. The tension to watch: in AI, the most consequential work — pipelines, evaluation frameworks, deployment tooling — eventually requires coordinating with messy humans. If solitude is fuel, this role fits; if solitude is avoidance, the ceiling arrives early.
Find out if the Developer role fits your profile — scored across all five dimensions.
Take the Free Assessment →
Dr. Bastian Brand, Ph.D. — author of The Hype Cycle Playbook, the framework behind the roletype assessment and this blog. About the author →