hunr does not detect AI use, and never will. Candidates may use any coding agent, on any challenge, without penalty or disclosure. What we verify instead is understanding: whether the candidate can explain, defend, and extend the work they shipped. That is the durable hiring signal in the agent era, and it is the one thing an agent cannot supply on a candidate's behalf.
This post is the full argument, because it is the founding decision of the product and I want it written down where everyone can see it.
Why don't we detect AI?
Two reasons. The practical one: detection is a lost arms race. Cheating attempts on coding assessments roughly doubled in 2025, and even the vendors selling detection admit they cannot reliably catch AI assistance. Every serious player that tried has quietly repositioned. Building a hiring product on a control that demonstrably fails would be selling a comforting fiction. I've written up the industry evidence separately; the short version is that the market has already conceded this fight.
The principled reason matters more: detection answers the wrong question. Capable coding agents are now part of how engineering works. Your current team uses them. The candidate you hire will use them on their first day, with your blessing. A screen that bans the most important tool of the actual job is not measuring the job — it is measuring behavior under an artificial constraint that disappears the moment the candidate signs.
"Did a human type every line" was always a proxy anyway. What a hiring team needs to know is: can this person ship, reason about, and own real work in our stack — with or without an agent? That is the question we built hunr to answer. hunr is the agent-allowed, understanding-verified technical hiring platform: candidates ship real code against role-specific challenges using any AI agent they like, and hunr then verifies they understood what they shipped.
If AI is allowed, doesn't everyone just submit agent output?
They can try. The product is designed so that this strategy earns a low score, not a ban — which is a much more durable defense than any detector.
It works through two mechanisms that reinforce each other.
The challenge shape makes one-shotting low-signal. hunr challenges are not greenfield puzzles with tidy specs, because that is exactly the shape agents ace. The difficulty lives where agents are weak: realistic, messy codebases that must be read and respected; requirements with genuine ambiguity; multi-step work that chains decisions across stages; and at least one implicit-but-critical requirement a competent engineer infers but the brief never states — with a hidden test that only passes if it was honored. An unattended agent run into that terrain produces something that looks plausible and scores poorly.
The reasoning defense verifies understanding. After the code is graded, the candidate faces a short, time-boxed, unaided conversation about their own submission. The questions are generated from their actual repo — their files, their design choices, their handling (or not) of the unstated requirement. One question per turn, adaptive, impossible to pre-script. The take-home is open; the defense is unaided; the gap between the two is the signal. A candidate who directed an agent thoughtfully will close that gap without effort, because they can defend every decision. A candidate who merely prompted cannot.
Between those two stages sits deterministic grading — hidden, framework-specific tests running in a real sandbox, plus a design-weighted rubric analysis of the repo itself. The scoring composition reflects the thesis: design and architecture judgment weigh heavily, because knowing what to build and how to structure it is the skill that stays valuable when agents write the loops. And the defense doesn't just add points — it multiplies the technical score, with a floor. Polished code plus a hollow defense fails.
Is this fair to candidates?
Fairness is not a compliance afterthought here; it is most of why I started the company. The first screen in hiring has been unfair for decades — resumes filter on pedigree and polish, and great engineers disappear because their profile is less polished than their work. A work-sample screen is already fairer than that. But we hold ourselves to specifics:
No accusations. Because we do not detect AI, no candidate will ever be flagged, failed, or quietly deprioritized by a probabilistic classifier that thinks their code "looks generated." The false-positive injustice built into every detection regime simply does not exist on hunr. Even our light session-integrity signals never auto-fail or auto-score anyone; at most they route a session to human review.
Your GitHub can help you and never hurt you. Profile analysis is bonus-only, capped, and never reduces a score. Plenty of excellent engineers have sparse public profiles — closed-source employers, caregiving years, careers that didn't leave a public trail. GitHub can corroborate; it can never condemn.
Banded scores, not false precision. A 73 and a 71 are the same performance with noise on top. We show tier bands alongside the number so nobody gets rejected over decimal-point theater.
You see your own report. Candidates get their full, evidence-linked report — the same per-competency breakdown, code citations, and rationale the hiring team sees. If we score your work, you get to read why. A signal that cannot survive being shown to the person it judges is not a signal worth selling.
What does this mean if you're hiring?
It means the score means something again. Every candidate on a hunr leaderboard shipped working code against the same realistic challenge, passed the same hidden tests, and defended their own decisions unaided. The ranking reflects the competency weights you set for the role, and every number traces to evidence you can inspect: the code, the rubric rationale, the defense answers.
It also means you stop paying for theater. AI bans you cannot enforce, proctoring that candidates resent, detection reports that are confidently wrong — none of it buys signal. The honest question was never "did they use AI." It is "will they be able to do this job, in this stack, with the tools engineers actually use." That question has a measurable answer.
What does this mean if you're a candidate?
Work the way you actually work. Bring your agent, your editor, your workflow. Nobody is watching your keystrokes, and nothing about your process will be held against you.
Just stay in charge of the work — because you will be asked about it, alone, and the questions will be about your code, not textbook trivia. If you can walk into that conversation and explain what you built and why, it does not matter one bit how much of the typing an agent did. You understood what you shipped. In the end, that is the only thing we verify — and the only thing that was ever worth verifying.