WCJ
The Perfectionist
It compiles, but is it right?
Who you are
You care how the code looks, not just whether it runs. A passing test doesn't relax you. You reread the thing until the shape feels right. You'd rather ship one clean function than five messy ones, and you mean it.
Where you shine
Taste for the shape. You see the wrong abstraction before anyone else feels the pain — the code that runs fine and still models the problem wrong. That's the failure AI makes most: something elegant that solves the wrong thing, and green tests won't flag it. In a world where everyone can generate working code, the person who knows when the design is actually right is the rare one.
Your blind spot
You polish past the point it pays. Ousterhout, in A Philosophy of Software Design, warns about complexity you carry in your head, but he never said carry it forever. And Knuth's old line still holds: premature optimization is the root of all evil. You tune the 97% that didn't need it while the ship waits at the dock.
In the AI age
Your eye is the edge. Agents produce more code, faster, and most of it tastes bad: wrong abstraction, wrong problem solved elegantly. You're built to catch that. The risk is the opposite: you slow the agent to a crawl reviewing every line, instead of pointing your judgment at the few places it truly matters.
Your move
Pick a 'good enough' line before you start, and stop there. Aim your taste at the critical path; let the agent run free on the boilerplate and dashboards where perfect doesn't pay. Spend the judgment you save on the one interface everyone else will have to live with.
How you're wired
Affinity. You love writing code.
Autonomy. You move slow and on purpose.
Trust. You trust your own eye.
Plays well with
Clashes with
Your shadow
The type wired opposite to yours — every instinct flipped.
The Inspector RAB compare →“I move fast because the checks have my back.”
Developers who share your type
- Donald Knuth Invented literate programming so the code would read right — and won't ship until the shape is.
- John Carmack Rereads it until the abstraction is correct, then rereads it again.
Premature optimization is the root of all evil.
Your ideal AI workflow
Write the spec before the agent writes the code: the interface, the invariants, the shape you already see in your head. Let it draft, then read the result the way you reread your own work — for the abstraction, not the syntax. Spend that eye on the one boundary that'll be hardest to walk back later, and let the agent run free on the boilerplate where perfect doesn't pay.
Who to pair with
Pair with the Builder — a WCB wires the tests and types that let you trust the shape without rereading every line, so your taste lands on the one interface that matters instead of all of them. The Scholar (RCJ) is your mirror: two careful judges can polish each other into paralysis, so split the call: you own the abstraction, they own the system map. You'll grind against the Driver (SAJ) and the Sprinter (WAB), who floor it past the wrongness you can feel; don't fight their speed, just claim the one boundary where your eye has to win and let them race everywhere else.
Where you'll struggle on a team
Because you trust your own eye over a passing test, your review becomes the gate nobody clears on the first try. Teammates ship something that works and you send it back over a shape only you can see. It reads as 'never good enough,' and people start dreading the PR more than the bug. Say which calls are taste you'll insist on and which are yours-to-prefer, so the team knows when a no does real work and when it's just you.
What to stop doing
- Re-reviewing the agent's boilerplate line by line when only the interface needed your eye.
- Sending work back over a shape preference and calling it a correctness bug.
- Polishing the abstraction before the second use case has shown up to judge it.
Wear it
Put your type in your GitHub README:
[](https://whatkindof.dev/type/wcj)