Hiring

We hire for understanding, not output. A candidate who executes cleanly but cannot explain why they made each choice is a no-hire, no matter how tidy the code, because what we are paying for is judgment under new conditions, not a transcription of a known pattern. One bad-fit hire costs the team far more than a slow search, so the bar stays high and the loop is built to catch the difference. This doc gives an interviewer two things: the non-negotiables (hard filters that end the conversation) and the rubric plus the bar per level (how to score what is left and place it).

The Non-Negotiables

These are hard filters. Fail one and it is a no-hire, at any level, regardless of rubric score.

Critical thinking, understands why. Asks why, challenges the prompt, and can re-derive and re-explain their solution from scratch. Tell: ask them to restate the problem and justify each decision; recognizing the right answer without being able to re-explain it is the red flag, because what you cannot re-explain, you do not understand. See The Illusion of Understanding and Find the Root.
Honesty and integrity. Says “I don’t know” instead of bluffing, and owns a mistake mid-interview. Tell: watch what they do when stuck or wrong; do they hand-wave and fake familiarity, or name the gap plainly. See The Illusion of Understanding.
Ownership and accountability. Treats the problem as theirs to solve, drives it forward, and does not wait to be led. Tell: between hints, do they push the problem forward themselves, or stall until spoon-fed. See Assume It Works Out.
Low ego, coachable. Takes a hint without defensiveness and updates, but can still defend a good decision with reasons. Tell: give one corrective hint and one wrong-headed hint; the good candidate absorbs the first and pushes back on the second with reasoning.
High agency, bias to action. When blocked, makes a reasonable assumption and moves rather than freezing. Tell: do they state an assumption and proceed, or stop dead. See Assume It Works Out.

Critical thinking is the filter the whole loop is built to detect.

The Rubric

The technical screen scores four dimensions:

Communication — understands the problem, asks the right questions, explains and visualizes the solution, and incorporates hints.
Problem Solving — breaks the problem down, moves from a brute-force to an optimal solution, and reasons about time and space.
Coding — translates the idea into readable, bug-free code.
Verification — checks that the code works: dry run, sample cases, unit tests, edge cases.

The hint mechanic: the interviewer offers hints, and the candidate’s level is read from how far they get and how little help it took. The bar below is calibrated to that: an Intern is expected to need substantial hints, while a Senior reaches the optimal solution with almost none.

How to Test

You do not ask “are you a critical thinker?” You engineer situations that force the signal out. The truth shows under pressure, never under a direct question: what someone cannot re-derive on the spot, they do not actually know.

The non-negotiables: probe and verdict. These surface inside the coding problem itself, not in a separate values interview.

Filter	The move that forces it out	Pass	Fail
Critical thinking	”Why does this work? What would break it?” Make them re-derive. Slip in a wrong premise and see if they catch it.	Re-explains from scratch, challenges the bad premise	Recites a pattern, cannot say why, accepts the wrong premise
Honesty	Push past the edge of what they know; ask them to explain something they claimed	Says “I don’t know” plainly	Bluffs, hand-waves with confidence
Ownership	Go quiet and give minimal guidance	Drives it forward, proposes the next step	Stalls, waits to be led
Low ego	Give one good hint and one wrong-headed hint	Takes the good, pushes back on the bad with reasoning	Defensive on the good, or blindly follows the bad
High agency	Inject a blocker or an ambiguity	States an assumption and proceeds	Freezes until unblocked

Digging deep on problem solving. You read level from how far they get and how hard you had to push, so push in steps and watch where they stall:

Restate, do not re-explain. Give the bare problem and stay quiet. Do they ask the clarifying questions that matter, or charge in?
Approach before code. Ask how they would approach it. If they jump to typing, pull them back; you are testing thinking, not typing.
Brute force first. “What is the simplest thing that works, even if slow?” Confirms they can actually solve it.
Push for optimal. “Can we do better? Where is the bottleneck?” The size of the nudge it takes is the level signal: a Senior needs almost none, an Intern needs you to point at the data structure.
Probe the why. “Why is that O(n log n)? What dominates?” Re-derivation, not recall. This is where pattern-matchers fall apart.
Curveball a constraint. “Now the input does not fit in memory.” Tests reasoning from structure versus a memorized answer; the memorizer freezes, the thinker adapts.
Withhold hints on purpose. Hint only when truly stuck, and note how big a hint was needed. That note is the score.

Probing the other three dimensions.

Communication: make them drive the explanation. If you have to ask “why” to follow along, that is a dropped point. Test hint-incorporation by giving a deliberately vague nudge and seeing whether they find the path from it.
Coding: watch them translate their own stated plan, not a fresh idea. Readable means you can follow it without narration. Let a small bug ride and see whether their verification catches it.
Verification: never prompt “did you test it?” The signal is whether they reach for a dry run and edge cases on their own. Having to prompt it tells you they will not do it on the job either.

The Bar per Level

The same signals, read at four levels. Cells describe what you actually see in the room.

Communication

Signal	Intern	Junior	Mid	Senior
Question understanding	Asks a clarifying question or two when prompted	Restates the problem in their own words before starting	Surfaces ambiguities and constraints unprompted	Reframes to the real requirement behind the prompt
Incorporating hints	Applies a direct hint	Corrects course from a nudge	Integrates feedback into the approach, not just the line	Often pre-empts the hint, asks for the constraint they need
Explaining and visualizing	Narrates what they are typing	Walks through the approach before coding	Sketches the data flow and explains tradeoffs	Explains so you never have to ask “why”

Problem Solving

Signal	Intern	Junior	Mid	Senior
Breaking it down	Needs the problem decomposed for them	Breaks it into steps with some guidance	Decomposes cleanly on their own	Finds the core sub-problem others miss
Brute force to optimal	Reaches a brute-force solution with some hints	Brute force on their own, optimal with hints	Reaches optimal with light hints	Reaches optimal largely unaided, weighs alternatives
Time and space	States complexity when asked	Analyzes time and space when prompted	Reasons about complexity unprompted	Optimizes against the real constraint, knows when good enough is right

Coding

Signal	Intern	Junior	Mid	Senior
Idea to code	Turns a clear, given plan into working code	Codes the plan with minor stumbles	Smoothly turns the approach into working code	Code matches the stated plan on the first try
Readability	Works, but messy naming and structure	Reasonable names and structure	Clean, idiomatic, easy to follow	Reads like prose, the next engineer needs no explanation
Bug-free	Some bugs, finds them on a dry run	A few bugs, catches most on review	Mostly correct, handles the common cases	Correct by construction, few bugs even at the edges

Verification

Signal	Intern	Junior	Mid	Senior
Dry run	Runs the happy path when prompted	Dry-runs the main path on their own	Traces the code against several inputs	Verifies the invariant, not just the example
Test cases	Tries the given example	Adds a couple of sample cases	Writes cases that cover the branches	Writes the test that would catch the subtle bug
Edge cases	Misses most edge cases	Names the obvious ones (empty, null) with a nudge	Enumerates edge cases unprompted	Finds the edge case that breaks the naive solution

Lead and above: hiring shifts from the coding screen to scope, judgment, and influence, a different loop run by leadership, not scored on this rubric.

Making the Call

Score with evidence, not vibes. For each dimension, write the specific moment that justifies the score. “Felt strong” is not a score.
A failed non-negotiable ends it. Any hard filter failed is a no-hire, even with a great rubric score. Note where it showed so the debrief stays concrete.
Hire at the level the evidence supports, not the one they applied for. The hint-amount calibrates it: Senior-level hints with Mid-level performance is a Mid.
When genuinely torn, no-hire. A wrong hire costs the team more than a slow search, and that cost lands on everyone around them.

How It Maps to Growth

Each rubric dimension predicts a capability in the competency matrix, so a strong screen is also an early read on where the person will grow.

Rubric dimension	Predicts (in the matrix)
Problem Solving	Discover’s “Getting to the root” and Define’s “Solution design”
Communication	The cross-cutting “Communication”
Coding	Build’s “Standards and quality”
Verification	Build’s “Ship discipline” and Launch’s “Watching and mitigation”

The competency matrix is where a hired engineer then grows, dimension by dimension, from the bar they cleared on the way in.