Interviews that look like real work — because they are.
Candidates get your codebase, a token budget, a set of models, and a task your team actually needs done. Taste records how they engineer it — the plans, the tradeoffs, the debugging — so you hire on judgment, not memorization.
Works with Claude Code, Cursor, Copilot, and any OpenAI- or Anthropic-compatible tool.
A genuine work sample, not a puzzle — inside a 48-hour self-paced window.
A metered model gateway and a git remote. No sandbox, no screen recording.
Every number points back to a commit, a CI run, or a transcript moment.
Senior engineers spot-check evidence instead of sitting through loops.
The interview is broken. Every engineer you want already knows it.
Interviews test recall. Jobs test judgment.
Whiteboards measure what you remember under pressure. Engineering measures what you decide when the constraints are real — and the constraint that matters most now is how you use your tools.
Candidates use AI every day. Except on your interview.
The people you want to hire already ship with AI agents. An interview that forbids them tests for skills you don't want and ignores the ones you're paying for.
Bad hires are expensive.
Recruiting, onboarding, ramp-up, and lost team velocity — a failed senior hire can cost six figures. The fix is a better signal before the offer.
Four steps from job requisition to evidence.
Define the work
Pick a template — bug hunt, feature build, migration, incident response — or drop in your own repo and a definition of done: tests pass, CI green, PR merged.
Set the constraints
Choose the model set, the token budget — a real resource limit, like a sprint — and the time window.
They engineer
The candidate connects their own AI tool with a one-time key, clones the task repo, and works on their own machine. Every commit pushes to a private Taste remote; CI runs on every push; the budget meter ticks live.
You decide
An evidence-linked scorecard across outcome, process, and quality. Replay the work — a commit-by-commit time-lapse with the agent transcript alongside. Decide in minutes, not days.
Three moments a résumé can't show you.
Every session is recorded as commits, CI runs, and the full agent transcript. These are the moments reviewers bookmark — the ones that separate a level, not a leetcode tier.
A task your team would actually write.
Tasks come from real production work — the kind of thing an engineer on your team would be asked to do on a Tuesday. The codebase is real. The acceptance criteria are real. The budget is real.
# A customer reports checkout fails intermittently at 8:00 PM ET.
# Find the root cause in this 40k-line codebase, fix it, add the
# regression test, and leave the codebase better than you found it.
Definition of done:
1. Root cause identified in the README
2. Fix merged to main with CI green
3. Regression test added and passing
4. No secrets, no dead code
Screen at scale without losing signal.
You can't tell from a coding-challenge score whether someone can ship — and you can't spend four hours of senior-engineer time on every candidate. Taste replaces the guesswork with a structured, auto-scored work sample.
Async and self-paced
Candidates work in a 48-hour window. No scheduling Tetris, no room booking, no coordinator calls.
Auto-scored reports
Every candidate gets an evidence-linked scorecard. Senior engineers spot-check the evidence, not the whole session.
Head-to-head comparison
Identical tasks, models, budgets, and rubrics for every candidate in a cohort. Compare apples to apples.
Defensible and auditable
Fixed rubrics, retained evidence, consistent process. A process you can stand behind — and show.
Watch them work — not talk about work.
The replay shows the plan, the tradeoffs, the debugging, the recovery from dead ends. The PR shows the code. The budget curve shows the judgment.
Task CI green · root-cause fix merged · regression test present.
Planned before editing · recovered from 2 dead ends in under 10 min each · used 38% of budget to ship.
Reviewer: “Small diff, correct, well-tested, review-ready.”
Every score links to timestamped evidence.
You verify the judgment in minutes, not hours: skip to the commit where the fix landed, see the CI history red-to-green, read what the candidate was doing at the moment that mattered.
- Commit-by-commit time-lapse with the agent transcript alongside
- The artifact they'd actually open — diff, commits, tests, CI results
- Budget efficiency — what they shipped vs. what they spent
- Seniority signal: autonomy, tradeoff judgment, recovery under constraint
- Rubrics calibrated IC3 → IC7; your notes next to AI pre-review
One bar across the org.
Stop letting every team reinvent the technical interview. Standardize assessment org-wide, cut the interview burden on your best engineers, and hire against tasks derived from your own production incidents.
Templates from real production work
On-call incidents, migrations, feature builds. Your incidents, your bar.
Calibration analytics
Which tasks separate an IC4 from an IC5 — not just pass/fail, but the dimensions that move.
Integrity controls
Identity verification, anomaly detection, immutable git history, full audit trail.
Built for the work, engineered for the scale.
OpenAI- and Anthropic-compatible gateway
One-time session keys, model alias allowlists (eco · standard · premium), and exact token metering on every request — streamed or not.
A git remote built into the platform
Push-only, per-session remotes with immutable history. Every commit runs CI; every CI run is evidence. No other workspace required.
LLM-judged, evidence-linked scoring
Outcome, process, and quality scored against your rubric by a judge model — every score pointing back to the replay.
Replay for every session
The commit timeline merged with the agent transcript and every CI result — immutable, evidence-linked, replayable at N× speed.
A process you can defend.
Ephemeral credentials
One-time session keys and per-session git passwords. Provider keys stay encrypted at rest; nothing to leak, nothing to reuse.
Immutable history
Force-pushes are rejected. The timeline candidates produce is the timeline reviewers see — dead ends included.
Full audit trail
Identity verification, anomaly detection, plagiarism checks, and session forensics when you need to dig deeper.
Every alternative trades away something you need.
| Whiteboard loop | Take-home | LeetCode screen | Taste | |
|---|---|---|---|---|
| Real codebase, real constraints | ✗ | ~ | ✗ | ✓ |
| AI tools allowed — and measured | ✗ | unverified | ✗ | ✓ metered |
| Verified authorship | ✓ | ✗ | ~ | ✓ |
| Identical conditions per cohort | varies by interviewer | ~ | ✓ | ✓ |
| Evidence retained | notes | final code only | a score | full replay + transcript |
| Senior time per candidate | 2–8 hours | 1–2 hours | ~0 (and ~0 signal) | minutes |
No sandbox, no surveillance — just the work.
You use your own tools on your own machine. Taste sees two things: the model traffic through the gateway and every commit you push. That's the entire artifact — and it's enough to judge real work.
- Bring Claude Code, Cursor, Copilot, or any OpenAI- or Anthropic-compatible tool
- Work on your machine, in your environment, on your schedule
- No AI required — tasks are completable without it; the budget just goes further
- Same task, same models, same budget for everyone in a cohort
- Your history is honest — and so is your score
export ANTHROPIC_BASE_URL=https://tasted.dev/v1
export ANTHROPIC_AUTH_TOKEN=sk-taste-…
export ANTHROPIC_MODEL=standard
claude
# …or any OpenAI-compatible tool
export OPENAI_BASE_URL=https://tasted.dev/v1
export OPENAI_API_KEY=sk-taste-…
Questions, answered.
Do candidates really use their own tools?
Yes — that's the point. Taste exposes OpenAI- and Anthropic-compatible endpoints, so Claude Code, Cursor, Copilot, and custom agents work with a one-time key. No new tooling to learn, no locked-down browser.
What if a candidate doesn't use AI tools?
Tasks are completable without AI — the budget just goes further. We score the outcome and the engineering, not the tool choice. (Though how a candidate spends their budget is informative either way.)
Where does the work happen?
On the candidate's own machine, in their own tools. Taste never touches their environment — we observe exactly two things: model traffic through our gateway and every commit pushed to the session remote. That's the entire artifact, and it's enough to evaluate on.
Is it fair?
Every candidate in a cohort gets the same task, models, budget, and rubric. Scores are calibrated per level and every result carries an audit trail.
How do you stop cheating?
Ephemeral credentials, a push-only remote with immutable history, identity verification, anomaly detection, and plagiarism checks — plus session forensics if you ever need to dig deeper.
How long does setup take?
For companies: pick a task, set the budget, send the invite — minutes, not a
procurement cycle. For candidates: two environment variables and a
git clone. The candidate guide walks through every tool.
Taste is building the evidence layer for hiring — so you decide on proof, not vibes.
Your next hire is already using AI at work. Interview them the same way. Book a demo and run a sample task against your own repo in under a day.