The first version of hunr got one big thing right and rested on one assumption that stopped being true. It got right that hiring should run on demonstrated work instead of resumes. Its assumption was that a submission which passes real tests proves its author's ability. Capable coding agents broke that assumption, and v2 is our answer to it.
This is the honest version of that story.
What was hunr v1?
v1 was built around a clean division of labor: AI generates, deterministic infrastructure grades.
An organization described the challenge they wanted in a prompt — "create a senior backend challenge around payments and idempotency," that kind of thing. The AI generated a structured assessment from it: a challenge brief, acceptance criteria, setup instructions, and a rubric. It also generated the evaluation assets: REST/API test cases for backend behavior and browser tests for frontend flows.
Then the AI stepped out of the loop, on purpose. The design principle we wrote down at the time was blunt: AI is used for generation, not for pass/fail execution. Candidates implemented the task locally, ran their own servers, and submitted the URLs of their running frontend and backend plus a link to their repository. hunr executed the generated tests against those live services with no AI inference anywhere in the verdict. Pass the functional gate and we cloned the repo for code-quality and architecture checks; the hiring team got a report with per-test results, logs, findings, and a score.
The scoring model was simple and weighted toward the thing we trusted most: functional correctness at 50%, browser correctness at 20%, code quality at 20%, architecture at 10%.
Candidates could browse live challenges and attempt any of them just by creating an account. No onboarding forms, no resume upload at the door. If you passed the threshold, then you applied. Work first, paperwork later.
What did v1 get right?
More than I expected, honestly, and the things it got right are all still load-bearing in the product today.
Proof of work beats resumes. The core bet held. Watching a hiring team look at a report built from a candidate's actual running service, instead of a resume, was the moment the thesis stopped being theoretical. Evaluation based on implementation quality instead of resume filtering worked.
Deterministic before AI. Keeping AI out of the pass/fail loop was the right instinct and we have never reversed it. A hiring decision needs a verdict a team can trust and a candidate can appeal to. Real tests, executed the same way for everyone, give you that. AI commentary layered on top can add context; it should not be the gate. That principle survives verbatim in v2's grading pipeline.
Auditability. v1 persisted every generated challenge as a versioned artifact — the prompt, the brief, the tests, the rubric, the generation metadata — so any evaluation could be reconstructed later. Boring, and exactly the kind of boring that makes a hiring signal defensible.
Candidate-first entry. Letting anyone attempt a challenge without gatekeeping was both fairer and better for the funnel. That is unchanged too.
What did the agent era expose?
The gap was not in what v1 checked. It was in what a passing check meant.
v1's implicit chain of reasoning went: the tests pass, therefore the candidate built a working system, therefore the candidate can build working systems. In 2023 that chain was solid. By 2025 the middle link had quietly dissolved. A capable coding agent, pointed at a well-specified brief with clear acceptance criteria, can produce a submission that passes every functional test. The artifact is real. The service runs. And the person who submitted it may or may not understand a line of it.
I want to be precise here, because it would be easy to spin this story as "we used to catch cheaters and then gave up." That is not what happened. v1 never had proctoring, never had anti-cheat, never tried to detect AI use. Our tests graded the behavior of running services and did not care who or what typed the code — a stance we chose deliberately. We never fought AI use. What changed is that AI got good enough to expose the difference between two things our grading had treated as one: the work is good and this person understands the work.
A passing artifact still proves the first. It no longer proves the second. And the second is what a hiring decision actually needs.
What changed in v2?
v2 keeps everything v1 proved and rebuilds the signal around understanding. hunr is now 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.
Concretely, three additions.
Challenge shape moved where agents are weak. v1's well-specified briefs were, in hindsight, agent-shaped: self-contained, explicit, greenfield. v2 challenges default to modifying realistic, messy codebases with ambiguity and judgment calls built in, so a one-shot agent run produces a low-signal result rather than a finished submission. The deterministic gateway is still there — hidden, framework-specific tests in a real sandbox — it is just no longer the whole story.
A reasoning defense verifies understanding. After the code is graded, candidates who clear the bar face time-boxed follow-up questions generated from their own submission: why this design, what breaks under load, what happens in the edge case you did or did not handle. You cannot pre-script answers about code you did not engage with.
Scoring weights what agents can't commoditize. Design and architecture judgment now carry heavy weight in the rubric, and the reasoning defense acts as a multiplier on the technical score rather than a bonus dimension. A polished artifact with a hollow defense drops sharply. That gap — between how good the work looks and how well its author can account for it — turned out to be the strongest signal we have, and it is the subject of its own post.
v1 taught us that proof of work is necessary. The agent era taught us it is not sufficient. v2 is what you build once you have learned both lessons in order.