Hire for Judgment. The Tools Handle the Typing.

Two engineers, same seniority, same salary band. Give each of them the same AI tools and the same ticket. One ships a clean, tested change in an afternoon. The other ships three thousand lines of confident-looking code that costs the team a week to untangle. Same tools. Wildly different outcomes.

That gap is the entire story of engineering hiring right now. The tools are a multiplier, and a multiplier is only as good as the number you feed it. Judgment is the number. Everything else on the resume is increasingly decoration.

What judgment actually means

"Hire for judgment" risks becoming one of those phrases everyone nods at and nobody can act on, so let me break it into the specific behaviors I screen for. After vetting engineers for my own teams for twenty years, and now doing it for clients, I've found judgment shows up in four observable habits.

They treat plausible as a warning sign. Generated code fails differently than human code. It rarely looks wrong. It compiles, the names are sensible, the structure is textbook, and the bug is a quiet assumption three layers down. Engineers with judgment have recalibrated their suspicion: the cleaner the output looks, the harder they check the assumptions underneath it. Engineers without judgment read clean code as done code.

They know what not to build. When producing code was expensive, restraint was enforced by cost. Now that generating another abstraction layer is free, restraint has to come from taste. The best engineers I've hired lately are notable for how little code they ship. They delete the speculative flexibility the model added. They ask why the feature exists before improving how it works.

They decompose before they delegate. Working with agents is a management skill. You break the problem into pieces with clear contracts, hand off the pieces the tools do well, and keep the pieces where the risk lives. Watch a strong engineer run an agent and it looks like a good tech lead running a sprint. Watch a weak one and it looks like a wish.

They can descend the stack when it matters. Abstraction is wonderful until something breaks beneath it. The engineers worth hiring can drop below the generated layer, read what's actually happening, and come back up with the fix. This is where fundamentals still matter, just differently: less recall of algorithms, more the deep model of how systems behave.

The seniority illusion

Here's the uncomfortable part: years of experience predict this profile far less than you'd hope. I've screened fifteen-year veterans who use AI tools like a slot machine, pulling the lever until something passes the tests. I've screened engineers four years in who orchestrate agents with the discipline of a staff engineer, because they built their working habits in this era instead of retrofitting them.

Experience still matters. Someone has to have seen a database fall over on a holiday weekend to truly respect a migration. But the correlation between tenure and AI-era effectiveness is loose enough that title-based hiring is now genuinely risky. You have to test the actual behaviors, on actual work, or you're hiring the label on the tin.

Curiosity is a hiring criterion now

One more trait, and I've stopped treating it as a nice-to-have: genuine curiosity. The tools change quarterly. The engineer who treats their workflow as finished, whatever that workflow is, gets a little more outdated every month without noticing. The engineer who keeps poking at the new model, the new agent pattern, the new way to structure context, compounds instead.

In interviews this is easy to surface. I ask what they've changed about how they work in the last six months. People with real curiosity light up and get specific: they'll tell you what they tried, what failed, what stuck. People without it give you a tool name and a shrug. Six months from now, both answers will have compounded.

How to actually screen for this

None of these traits show up in a resume, and only weak echoes of them survive a conversational interview. You need to watch candidates work. My vetting for clients runs a realistic exercise with AI tools expected, and grades the process: what they questioned, what they caught, what they refused to ship, how they explained their reasoning afterward. The exercise is small. The signal is enormous.

And be honest with yourself about the bar. A team of people with this profile is smaller, more expensive per head, and dramatically cheaper per outcome. Which changes how many people you should hire in the first place, but that's its own essay.

If you want engineers vetted this way, by a CTO who has hired 75+ of them for his own teams, this is the service. Or just reach out →