// a field guide
developer archetypes
20 types, sorted by what each one optimizes for.
$ ls ./archetypes | wc -l
20
// the map
Five orientations
user’s outcome
shipper · sketcher · finisher · interpreter
system
cartographer · road builder · lighthouse keeper · gardener
craft
woodworker · tuner · deep diver · detective
people + ideas
bridge builder · teacher · scout · gatekeeper
mechanism
toolsmith · engine builder · alchemist · clockmaker
developer archetypes
02 / 23
// 01 · user’s outcome
🚢 The Shipper · product engineer
traits
Starts from the user’s problem, not the technology. Cuts scope, reads the metrics, talks to users. Code is disposable if the outcome isn’t there.
motivation
Seeing something they built change what a user can do.
failure modes
Debt piles up because “it works.” Mistakes shipping for impact. Neglects what users can’t see until it breaks.
neighbors
The Sketcher, but stays past the demo. The Finisher, but stops when the outcome is reached, not when the work is complete.
blind spot
Quality the user can’t see: security, operability.
growth state
Owns what happens after launch as much as the launch itself.
developer archetypes
03 / 23
// 02 · user’s outcome
✏️ The Sketcher · hacker / prototyper
traits
Fastest path from idea to something running. Thinks by building, tolerates mess, unafraid of unfamiliar stacks.
motivation
The moment an idea first becomes real enough to react to.
failure modes
The prototype becomes production. Loses interest once the question is answered. Leaves work others can’t pick up.
neighbors
The Scout explores what exists; the Sketcher explores what could. The Shipper cares about the user; the Sketcher about the proof.
blind spot
What it costs others to make the demo real.
growth state
Labels prototypes as throwaway and hands them over well.
developer archetypes
04 / 23
// 03 · user’s outcome
🏁 The Finisher
traits
Owns the last 20%: edge cases, error messages, docs, migrations, the empty state. Notices what’s missing rather than what’s there.
motivation
Something being actually done, with no asterisks.
failure modes
Polishes things that should have been cut. Slow to start. Can read as blocking when others want to move on.
neighbors
The Woodworker polishes the code; the Finisher polishes the experience. The Gardener tends over years; the Finisher closes out a release.
blind spot
The cost of completeness in time and lost options.
growth state
Knows which gaps matter and lets the rest go.
developer archetypes
05 / 23
// 04 · user’s outcome
🗣️ The Interpreter · domain expert
traits
Knows the business as well as the people running it: the pricing rules, the regulation, why the exception exists. Names things the way the domain does.
motivation
Software that says what the business means: code and people describing the same thing.
failure modes
Becomes the only one who knows why. Encodes today’s process as if it were permanent. Defends accidental complexity as essential.
neighbors
The Shipper asks whether it moved the metric; the Interpreter whether it’s correct. The Deep Diver is expert in a technology, the Interpreter in the problem.
blind spot
The domain’s own bad habits.
growth state
Spreads the domain knowledge and challenges the business.
developer archetypes
06 / 23
// 05 · system
🗺️ The Cartographer · architect
traits
Thinks in boundaries, contracts, and data ownership. Sorts decisions by how expensive they are to reverse. Writes things down.
motivation
A system whose shape makes the right change easy and the wrong one hard.
failure modes
Designs for a future that never arrives. Drifts away from the code. Maps that no longer match the territory.
neighbors
The Road Builder implements what the Cartographer charts. The Engine Builder loves one component; the Cartographer cares how they fit.
blind spot
What structure costs in delivery time.
growth state
Designs the minimum that keeps options open, and stays in the code.
developer archetypes
07 / 23
// 06 · system
🛣️ The Road Builder · platform engineer
traits
Builds the paved path for an organization: pipelines, templates, shared services. Treats other developers as customers. Values consistency.
motivation
Other teams moving faster without knowing why.
failure modes
A platform nobody asked for. Mandates the road instead of making it the best route. Abstractions that hide what teams need to see.
neighbors
The Toolsmith makes sharp personal instruments; the Road Builder makes organizational infrastructure. The Lighthouse Keeper watches the roads once built.
blind spot
Legitimate needs the road doesn’t serve.
growth state
Treats adoption as the measure and learns from teams that leave.
developer archetypes
08 / 23
// 07 · system
🔦 The Lighthouse Keeper · operator
traits
Judges software by how it behaves in production. Cares about observability, rollback, capacity, failure modes. Remembers every past incident.
motivation
Quiet nights, and systems that fail gracefully and explain themselves.
failure modes
Risk-aversion that blocks change. Heroics instead of fixes. Becomes the single point of failure for knowledge.
neighbors
The Detective enjoys the puzzle; the Keeper wants it never to recur. The Gatekeeper questions the idea; the Keeper questions the rollout.
blind spot
The cost of not changing.
growth state
Makes change safe instead of rare.
developer archetypes
09 / 23
// 08 · system
🌱 The Gardener · maintainer
traits
Keeps a codebase healthy over years: refactoring, dependency updates, deleting dead code. Patient, incremental, thinks in seasons.
motivation
A codebase that’s better to work in each year rather than worse.
failure modes
Endless tidying without new value. Resists the big change the system needs. Work that’s invisible until it stops.
neighbors
The Woodworker cares about each piece; the Gardener about the whole plot over time. The Finisher completes; the Gardener sustains.
blind spot
When a system is past tending.
growth state
Tends where the next change will land.
developer archetypes
10 / 23
// 09 · craft
🪚 The Woodworker · craftsperson
traits
Cares about code at the line level: naming, structure, tests, readability. Has strong taste and can explain it.
motivation
Code that a stranger can read and trust.
failure modes
Treats style as substance. Reviews that fight over preference. Perfects code that’s about to be thrown away.
neighbors
The Gardener tends the whole plot; the Woodworker each piece. The Tuner shares the precision, but aims it at the machine, not the reader.
blind spot
That good taste varies between readers.
growth state
Scales rigor to how long the code will live.
developer archetypes
11 / 23
// 10 · craft
🎛️ The Tuner · optimizer
traits
Drawn to latency, memory, and throughput. Measures before believing. Understands the layers beneath the code.
motivation
The measurable win: the same work at a fraction of the cost.
failure modes
Optimizes what isn’t the bottleneck. Trades away readability for gains nobody needed. Ignores the cheaper fix of doing less.
neighbors
The Deep Diver goes deep on a domain; the Tuner on a property. The Engine Builder shares the fascination with the machine itself.
blind spot
The complexity fast code leaves behind.
growth state
Optimizes what users and the bill actually feel.
developer archetypes
12 / 23
// 11 · craft
🤿 The Deep Diver · deep specialist
traits
Knows one domain thoroughly: databases, compilers, cryptography, identity. Reads the papers and the source. Knows where conventional wisdom is wrong.
motivation
Real understanding, and being the person who actually knows.
failure modes
Sees every problem as their domain’s problem. Impatient with pragmatic shortcuts. Becomes a bottleneck.
neighbors
The Teacher is what the Deep Diver becomes on a good day. The Detective is broad across the stack; the Deep Diver is deep in one layer.
blind spot
Constraints from neighboring domains.
growth state
Makes their depth usable by others.
developer archetypes
13 / 23
// 12 · craft
🔍 The Detective · debugger
traits
Thrives on the bug nobody else can find. Hypothesis-driven and patient. Follows evidence across layers and distrusts assumptions.
motivation
The click when an impossible symptom finally makes sense.
failure modes
More interested in the chase than in prevention. Solutions that live only in their head. Drawn to the interesting bug over the important one.
neighbors
The Lighthouse Keeper shares the incident but wants it gone for good. The Deep Diver lends the knowledge when the trail leads there.
blind spot
Boring, systemic causes.
growth state
Turns each case into prevention.
developer archetypes
14 / 23
// 13 · people + ideas
🌉 The Bridge Builder · glue person
traits
Unblocks, connects, and translates between teams and disciplines. Notices what’s falling between responsibilities and picks it up.
motivation
The whole effort landing, not just their own part.
failure modes
Contributions that go unseen and unrewarded. Spreads too thin. Technical skills atrophy.
neighbors
The Teacher grows individuals; the Bridge Builder connects groups. The Cartographer defines the boundaries the Bridge Builder helps people cross.
blind spot
Their own load.
growth state
Builds connections that work without them.
developer archetypes
15 / 23
// 14 · people + ideas
🎓 The Teacher · multiplier
traits
Raises everyone’s level through review, pairing, mentoring, and writing. Explains without condescension.
motivation
Watching someone do what they couldn’t do before.
failure modes
No longer ships their own work. Explains when doing would be faster. Creates dependence instead of independence.
neighbors
The Deep Diver is the source of much of what gets taught. The Bridge Builder connects groups; the Teacher grows individuals.
blind spot
That not everyone wants teaching.
growth state
Knows when to let people struggle.
developer archetypes
16 / 23
// 15 · people + ideas
🧭 The Scout · explorer
traits
First to try the new language, tool, or paradigm. Reads widely, experiments cheaply, reports back what’s worth adopting.
motivation
Curiosity, and the edge that comes from seeing what’s coming.
failure modes
Novelty-chasing. Abandoned experiments. Pushes adoption before the thing is ready.
neighbors
The Sketcher explores what could exist; the Scout what already does. The Gatekeeper is the natural counterweight: the pair is healthier than either alone.
blind spot
The migration cost others pay.
growth state
Brings back verdicts, including “not worth it.”
developer archetypes
17 / 23
// 16 · people + ideas
🚪 The Gatekeeper · skeptic
traits
Asks whether the thing is needed at all. Spots hidden costs, remembers what was tried before, comfortable being the dissent.
motivation
Protecting the team’s time and the system’s simplicity.
failure modes
Becomes the reflexive no. Criticism without alternatives. Discourages people from proposing anything.
neighbors
The Lighthouse Keeper questions the rollout; the Gatekeeper the idea. The Cartographer shares the worry about irreversible decisions, but proposes where the Gatekeeper vetoes.
blind spot
The cost of what never got built.
growth state
Says no with an alternative, or yes with conditions.
developer archetypes
18 / 23
// 17 · mechanism
🛠️ The Toolsmith · tool-builder
traits
Meets a problem twice and builds the thing that removes it. Works one level up, cares about interfaces, prefers small composable pieces. Their own first user.
motivation
Leverage, and the moment a tool disappears into the workflow.
failure modes
Builds the tool instead of doing the work. Generalizes too early. Tools that fit only their author. Loses interest before adoption and maintenance.
neighbors
The Road Builder builds for an organization; the Toolsmith for the moment. The Engine Builder shares the love of mechanism, but never has to use it.
blind spot
That the tool isn’t the work.
growth state
Builds for other people’s hands, and maintains it.
developer archetypes
19 / 23
// 18 · mechanism
⚙️ The Engine Builder
traits
Measures the product by the elegance of its core: runtime, protocol, data model. Defaults, examples, and bundled integrations are second-class.
motivation
Technical brilliance for its own sake: a core that is correct, general, and beautiful.
failure modes
Ships a ceiling with no floor. Never learns the primitives compose awkwardly, because they never wrote the batteries. Waits for an ecosystem that doesn’t come.
neighbors
The Tuner and the Deep Diver share the fascination with internals. The Shipper is the opposite, and the most useful partner.
blind spot
The user’s first hour.
growth state
Writes the first batteries themselves.
developer archetypes
20 / 23
// 19 · mechanism
⚗️ The Alchemist · unifier
traits
Looks for the single model everything reduces to: everything is an event, a graph, a file. Happiest when two unrelated things turn out to be the same thing.
motivation
The collapse: a hundred special cases become one general case, and whole categories of code disappear.
failure modes
Bends problems to fit the model. The last 10% gets awkward encodings or is declared out of scope. Keeps refining after it’s good enough.
neighbors
The Engine Builder loves the machine; the Alchemist the idea behind it. The Toolsmith builds a tool per problem; the Alchemist wants one for all of them.
blind spot
The cases that were bent to fit.
growth state
Holds the model loosely and knows where it stops.
developer archetypes
21 / 23
// 20 · mechanism
🕰️ The Clockmaker · automator
traits
Never does a task by hand twice. Builds pipelines, generators, schedulers, and bots. Trusts a process only once it runs without anyone watching.
motivation
The system that keeps working while everyone is asleep.
failure modes
Automates a process that should have been removed. Spends a day saving ten minutes. Machinery nobody understands when it stops.
neighbors
The Toolsmith makes an instrument a person uses; the Clockmaker removes the person. The Lighthouse Keeper gets the call when the clockwork jams.
blind spot
The judgment a person was quietly supplying.
growth state
Asks whether the process should exist before automating it.
developer archetypes
22 / 23
// nobody is one type
Most people are a primary and a secondary.
The mix shifts with context: work or hobby, the project’s phase, what the team is missing, and over a whole career.
$ exit 0