Skip to content

How to Evaluate a Developer When You Can’t Read the Code

Judge a developer on how they think, not on what they claim — because you can’t read the code, but you can absolutely read reasoning. The single most reliable signal is this: can they explain a technical decision in plain language, including the trade-offs and what they’d do differently? A genuinely good developer makes their thinking legible to you. A weak or overconfident one hides behind jargon, has an answer for everything, and never names a downside. You don’t need to understand the implementation to tell those two apart. You need to listen for whether there’s real judgement underneath the confidence.

This is one of the hardest spots a non-technical founder is ever in — hiring for a skill you can’t directly assess — so let me give you the signals that actually work.

Why the obvious tests don’t work

The instinct is to look at credentials, years of experience, an impressive CV, a list of technologies, a portfolio of names. Almost none of it tells you what you need to know. Years of experience can mean one year repeated ten times. A list of technologies is a list of things they’ve been near, not things they’re good at. A portfolio shows you the outcome, not whether they caused it or how much they had to be carried. And the developer who interviews most smoothly — fast answers, total confidence, no hesitation — is often the one you should worry about most, because real expertise comes with knowing where the hard parts and the trade-offs are, and that knowledge makes people more measured, not less.

So stop trying to assess the code or the credentials directly. You can’t, and they don’t tell you the truth anyway. Assess the thinking, which you can read perfectly well even with no technical background.

What to actually look for

These are the signals that survive contact with reality:

  • They can explain it so you understand it. Ask them to walk you through a past technical decision in plain English. A good developer can make a non-technical person genuinely understand why they chose what they chose. If you come away more confused, or feeling talked down to, that’s not your failing — it’s either a gap in their understanding or an unwillingness to be understood. Both are problems. Real mastery simplifies.
  • They name trade-offs and downsides unprompted. Every real technical decision costs something. A developer who only ever tells you the upside, who has no downsides to anything they propose, either doesn’t understand it deeply or isn’t being straight. “I chose this, and here’s what it costs us” is the sound of someone who’s actually thought.
  • They say “I don’t know” — and what they’d do about it. Confidence about everything is a red flag. The good ones are precise about the limits of what they know and have a method for closing the gap. “I’m not sure, here’s how I’d find out” beats a confident wrong answer every time.
  • They ask about the business, not just the spec. A developer who wants to know why you need something, what it’s for, what success looks like, is one who’ll build the right thing. One who just takes the spec and runs will happily build exactly the wrong thing, perfectly.
  • They favour the simple solution. Watch whether they reach for the simplest thing that solves your real problem, or the most elaborate, impressive-sounding one. The instinct to over-engineer — to use the exciting new technology, to build for imaginary future scale — is a tell. The senior move is almost always the simpler one, and a developer who reaches for complexity to look clever is a developer who’ll cost you.
  • References that speak to how they work, not just that they exist. Ask a past client one question: when something went wrong, what did they do? Anyone competent has had something go wrong. How they handled it tells you more than a glowing one-liner.

What to ignore

Just as important is what to discount. Jargon density tells you nothing good — if anything, heavy unexplained jargon is a warning, because the people who understand things best can explain them simplest. Speed and certainty in the interview are weak signals and sometimes negative ones. A long technology list is breadth, not depth, and often neither. And the slickest-talking candidate is exactly the one to slow down on — charisma and competence are unrelated, and the gap between “sounds impressive” and “is good” is where a lot of money gets lost.

The honest limit — and what to do about it

Here’s the part most advice skips. Everything above genuinely helps, and a sharp non-technical founder can get a long way on it. But it has a ceiling: you can read thinking, and you should, but you cannot read the actual work. A developer can reason beautifully in an interview and still write fragile, debt-laden code — and you’d have no way of seeing it until it collapses, usually months later and expensively.

That gap is exactly why a cheap developer is the riskiest hire for someone who can’t assess the work — you can’t tell solid from rotten until the bill arrives. So for any hire or build that genuinely matters, the move is to have someone who can read the code do a short technical check — assess a code sample, sit in on one interview, review the work early before you’re in deep. An hour of senior technical eyes catches what no amount of plain-language reasoning can, and it’s a fraction of what a bad hire costs. That’s a small slice of advisory work and it pays for itself the first time it catches a problem.

Who this isn’t for

If you have solid in-house technical leadership already, you don’t need this — they can assess developers directly and far better than any checklist. This is for the founder or owner hiring technical people without a technical person on their side, which is the genuinely hard and genuinely common case. And if the real question is whether to hire one developer at all versus a team or a shop, that’s independent consultant vs dev shop, not this.

How I’d decide it

Run the conversation on reasoning: make them explain a real decision in plain words, watch for named trade-offs, honest “I don’t know”s, curiosity about your business, and a bias toward the simple. That filters most of the field on its own. Then, for anything that matters, get one short technical check from someone who can actually read the work — because thinking and code are different things, and you can only see one of them yourself.

If you’re about to make a hire or sign off a build and you’ve no way to judge the technical side, tell me about it — a short check before you commit is one of the cheapest ways I know to avoid an expensive mistake. For how this fits the wider set of hiring decisions, the comparisons index maps them out.