RAJ
The Judge
I've seen this before. It's wrong.
Who you are
You read fast and you call it faster. One look at a pull request and you know: good, bad, wrong abstraction, ship it. You've read enough code that your gut is mostly right, and you don't apologise for trusting it. People bring you the hard review because you'll give a straight answer in two minutes.
Where you shine
Taste, at speed. You know something is wrong even when it passes every test, and you know it now, not after a week of analysis. That instinct is exactly what AI can't originate: it can mimic good code fluently, and you're the one who feels the wrongness underneath. In a world drowning in generated code, the fast, accurate read is gold.
Your blind spot
You can be confident and wrong at the same speed. Your taste is yours, and the Principle of Least Astonishment is the reminder that what feels obviously right to you can astonish the user who holds a different model. When your gut and the caller's expectation disagree, the bug isn't always theirs. Fast judgment skips the step where you check whose surprise actually matters.
In the AI age
Your read is the real advantage. Agents produce more code than anyone can review line by line, and your fast, trained eye is built to triage it: good enough, wrong shape, needs a human. The risk is the opposite of slowness: you wave through the agent's fluent, confident, wrong code because it matches your taste, when taste was the thing it learned to fake.
Your move
On the calls that surprise people, slow down once: would a reasonable user expect this? Keep the speed for everything else. Your taste is a real edge — just check it against the reader, not only your own model.
How you're wired
Affinity. You love reading code.
Autonomy. You move fast and decisively.
Trust. You trust your own taste.
Plays well with
Clashes with
Your shadow
The type wired opposite to yours — every instinct flipped.
The Builder WCB compare →“Tidy first, then build to last.”
Developers who share your type
- Joshua Bloch Effective Java is taste, codified — he knows it's wrong before you finish the sentence.
- Gregor Hohpe If you can't explain the design, he's already decided it's the design's fault.
A component of a system should behave in a way that most users will expect it to behave.
Your ideal AI workflow
Let the agent generate more than you could write, then do what you do best: triage it fast. One read per change — good enough, wrong shape, needs a human — and move on, because your trained eye is built for exactly this volume. The one trap is your own taste: the agent learned to fake it, so when a diff feels too clean to question, that's the one to slow down on.
Who to pair with
Pair with the Inspector — a RAB backs your gut call with the measurement, so when your taste says wrong the dashboard says why, and the team trusts the verdict instead of just your two-minute read. The Captain (SAB) gives your fast triage a fleet worth triaging, pointing autonomous work at you to judge. You'll clash with the Builder (WCB) and the Pilot (SCB), who want the slow careful process your instinct skips — let them own the cases where being confident-and-wrong is expensive, and keep your speed for the volume only a trained eye can clear.
Where you'll struggle on a team
Because you call it in two minutes and trust the call, your verdicts can land as dismissal. Someone's week of work gets a fast 'wrong shape' with no reasoning attached, and they hear judged, not helped. Even when you're right, a read that fast leaves no handle for them to learn from or push back on. Spend one extra sentence on the why behind the no, so your taste teaches instead of just lands.
What to stop doing
- Waving through the agent's fluent diff because it matches the taste it learned to fake.
- Dropping a 'wrong shape' verdict with no reasoning the author can learn from.
- Trusting your gut over the caller's expectation without checking whose surprise matters.
Wear it
Put your type in your GitHub README:
[](https://whatkindof.dev/type/raj)