DeepSeek V4 Pro Hire: Skills Beyond the Interview Demo

01 · What the first AI hire owns once the pilot is over

Most teams hire for AI-heavy roles around a demo. A candidate wires up a chat interface, the panel is impressed by the polish, the offer goes out, and six weeks later the same engineer is staring at a spend line nobody can explain, a context window that has swollen past its usefulness, and a queue of internal teams asking for retries, fallbacks and usage caps. The skills that won the interview are rarely the ones that keep a heavy workload running. Before you write the job description, write down what this person will actually own at steady state.

• › Prompt and context architecture: versioned prompts, structured outputs, and a deliberate policy for what goes into the context window on every call.
• › Token economics: a working mental model of metered usage, including the fact that cache writes and cache reads are billed separately and behave differently under sustained load.
• › Routing and fallback logic: which model handles which task, and what happens when the primary path is slow, saturated or returning degraded output.
• › Evaluation: a repeatable harness that catches regressions before users do.
• › Operational hygiene: rate limits, retries, backoff, idempotency and spend guardrails that hold up when ten teams share one workload.

If a candidate cannot speak fluently about three of those five areas, they are a strong prototyper and a risky owner.

02 · Token budgets turn prompt craft into engineering

Prompt skill is easy to fake in a whiteboard session and hard to sustain under volume. Ask candidates how they would handle a pipeline that runs thousands of times a day on long, partly repetitive inputs. You are listening for three habits. First, they treat prompts as versioned artifacts with owners, changelogs and rollback, not as strings buried in application code. Second, they reason about context deliberately: what is retrieved, what is cached, what is trimmed, and what is reconstructed from prior turns rather than resent. Third, they understand that caching is a design lever, not an accident. A well-shaped request that writes a large reusable prefix once and reads it on every subsequent call behaves very differently from a request that rewrites its prefix each time, even when the visible text looks similar.

A good screening question is blunt: walk me through a single production call, token by token, and tell me which parts are cacheable and which are not. Candidates who have run sustained workloads answer this in seconds. Candidates who have only built demos answer in abstractions. Push for the mechanics.

03 · Routing is a judgment skill, not a config file

Teams with heavy, sustained traffic rarely run everything through one model. They split work: cheap, high-volume classification and summarisation on a fast tier, long-horizon reasoning and difficult generation on a stronger tier, and a deliberate policy for what escalates. The interesting question in an interview is not which model is best. It is how the candidate decides. Ask them to design a routing policy for a mixed workload and to justify where each class of task goes and what the fallback is when the first choice fails.

Listen for reasoning about quality thresholds, latency envelopes and cost ceilings rather than brand loyalty. A candidate who says they would benchmark a couple of options against your own data, set a quality floor, and route by task class is thinking like an operator. A candidate who names a favourite model and stops there is thinking like a user. When your team runs on one shared balance across many providers, that routing instinct is the difference between a predictable monthly bill and a surprise.

04 · Evals and cache hygiene reveal who has scaled anything

Anyone can eyeball twenty outputs and declare a system good. Scaling requires a harness: a fixed evaluation set drawn from real traffic, graders that match the task, and a gate that blocks a prompt change from shipping if quality slips. Ask candidates what their eval set contains, how often it is refreshed, and what happens when a model update degrades a task that used to pass. The strongest answers include golden examples, edge and failure cases, and a plan for detecting silent regressions on the long tail.

Pair that with failure handling. Under sustained load, the failure modes multiply: malformed structured output, partial responses, tool loops that never terminate, runaway context growth and slow saturation during peak windows. Ask how they would instrument a pipeline to see all of it. You want to hear about per-task token accounting, cache hit rates, retry budgets and alerts tied to cost as well as errors. Teams that meter real tokens per call can answer these questions precisely; teams that fly blind discover them at the end of the quarter.

05 · The interview loop that surfaces all of it

Structure the loop around evidence rather than conversation. A practical sequence works well: a design discussion about a realistic workload, a review of something the candidate has actually shipped, and a paid trial project with explicit constraints. Give the trial real teeth: a fixed token budget, a latency target, a required cache strategy, a quality bar measured against a small evaluation set, and a written note explaining the trade-offs. Then watch what they cut when the budget runs short, because that decision tells you more than any answer to a behavioural question.

Red flags are consistent: no versioning strategy, no evals, unlimited retries as a reliability plan, and no curiosity about what a request actually costs. Green flags are the opposite: questions about your traffic shape and peak windows, instinct to measure before optimising, and comfort saying a task does not need the most capable tier.

For the workload itself, give the new hire a single, metered surface instead of a stack of separate accounts. Quanta is a pay-as-you-go API relay built for exactly this situation: one balance covers a wide range of leading models, it works with Claude Code, Codex, Gemini CLI and any OpenAI SDK, and every call is metered on real tokens with cache writes and cache reads priced separately, so the accounting a candidate promises in an interview is the accounting you actually get in production. Open a Quanta account and point the trial project at it: the candidate's token discipline will show up on the first day, and your team will have one bill to reason about from the pilot through rollout.