Capstone: Mock Loop & Self-Exam

The recruiter screen sounds gentle and isn't. Inside thirty minutes a recruiter decides whether you are a real Cursor power user or someone who skimmed the docs last night and the people who fake it get caught fast.

Cursor's own hiring notes flag that candidates who haven't used the product heavily struggle disproportionately. For a Product Quality Engineer that is doubly true: the whole job is being the in-house expert who can field a deep question about Tab or indexing without flinching. So this drill runs the screen on yourself before a recruiter does.

Record the two-minute openerDrill 1

Hit record. In two minutes, answer why Cursor and why this role as if the recruiter just asked. No notes, one take, then play it back cold.

Self-test product depth, no notesDrill 2

Set a timer and explain each surface out loud as if to a non-Cursor engineer. If you stall, that surface is a study gap, not a nerves problem.

Your favorites and frustrationsDrill 3

Name your three favorite Cursor behaviors and your three most-frustrating ones, each with a one-line reason. This is the single most authentic signal you can carry into every round and it doubles as raw material for the product/craft round later.

If your usage story came out thin on any of these drills, that's the most impactful gap to close before you interview anywhere in this loop. No amount of debugging skill rescues a candidate who clearly doesn't live in the product.

The debugging screen is where support candidates and engineering-grade candidates separate. They hand you a gnarly Cursor bug and watch whether you investigate like a scientist or thrash like someone refreshing and hoping.

Set a hard 30-minute clock. Pick a scenario with the texture of a real Cursor escalation, then narrate the whole arc out loud or in a doc you can replay: context, reproduce, isolate, evidence, hypothesis. The deliverable at the end is a clean report an engineer could act on without asking you a follow-up.

A sample scenario to run on yourselfPick one and start the clock

TICKET #4471 - “Agent mode keeps deleting my imports”
Reporter: paid team user, macOS, Cursor latest
“Since this week, when I ask Agent to add a function, it sometimes
strips unrelated import lines at the top of the file. Not every time.
Happens more in big files. Started ~Tuesday.”
Attached: one screen recording, no logs, no repro steps.

1. 10–4 min · Context. Pin the facts: version, OS, when it started (Tuesday → suspect a release or model change), frequency (“sometimes,” “big files” → likely context-window truncation). Write what you don't yet know.
2. 24–14 min · Reproduce. Build a minimal repro: a large file, the same Agent ask, repeated runs. Vary one thing at a time - file size, model, with/without rules - until you can trigger it on demand. Intermittent bugs become tractable the moment you find the lever.
3. 314–20 min · Isolate the layer. Decide client vs server vs model. Does it happen offline-cached? On a different model? With a tiny file? Each answer collapses the search space.
4. 420–26 min · Gather evidence. Capture the bad diff, the exact prompt, the model name, a HAR/network trace if it's request-shaped and the developer-console logs. Evidence is what makes the report credible, not your conclusion.
5. 526–30 min · Hypothesis + report. State your leading hypothesis, your confidence and the one experiment that would confirm it. Then write the report.

Localize: client vs server vs modelThe discriminating questions

The deliverableEngineering-ready report

TITLE: Agent mode drops unrelated imports on large files (>~600 LOC)
SEVERITY: High - silent data loss in user's source
REPRO (3/5 runs):
  1. Open attached 700-LOC file
  2. Agent: “add a debounce helper”
  3. Observe: top import block truncated in returned diff
SCOPE: Reproduces on model X, not model Y. Started build 0.xx.
EVIDENCE: bad-diff.txt, request-id abc123, console.log attached
HYPOTHESIS: context truncation on large files drops the header region
           before the edit is composed. Confidence: medium-high.
NEXT: confirm by capping file size; ask backend for truncation logs.

The take-home tests the part of the job that scales: turning a pile of noisy signal into a ranked, quantified artifact a leader can act on without re-reading the raw tickets.

Simulate it with roughly fifteen mixed reports - drag real ones from a forum or Discord thread or write a believable batch. Give yourself 45 minutes to cluster, dedup and rank by severity times impact. The grader is checking your judgment and your writing, not whether you touched every ticket.

The 45-minute clockDrill protocol

1. 10–8 min · Cluster & dedup. Group the fifteen reports into themes. Five “Agent is slow today” tickets are one signal, not five. Note which are regressions vs new behavior.
2. 28–20 min · Score severity × impact. For each cluster, rate severity (data loss / security / outage at the top) and impact (users affected, ARR exposed, frequency). Multiply, don't average.
3. 320–32 min · Rank & sanity-check. Order the clusters. Then deliberately ask: is anything quiet but catastrophic ranked below something loud but trivial? Fix it.
4. 432–45 min · Write the one-pager. Top three themes, each with volume and ARR exposure, plus one clear recommendation per theme.

A worked severity × impact passWhat a ranked batch looks like

Sketch the agent-assisted pipelineTriage at scale

The role explicitly expects you to drive prioritization at scale using agent-assisted tools. Sketch the pipeline and, just as important, mark the human checkpoints where you'd refuse to trust the model.

1. 1Ingest. Pull tickets, forum, Discord, social into one queue.
2. 2Cluster (agent). LLM groups by theme and proposes dedup candidates.
3. 3Checkpoint (human). You verify the clusters - a model will happily merge two distinct bugs. This is where blind trust burns you.
4. 4Draft repros (agent). Model proposes a minimal repro per cluster; you confirm it actually triggers the bug.
5. 5Score & brief (agent + human). Model drafts the severity/impact table; you own the final ranking and the recommendation.

The one-page VoC briefDeliverable shape

The onsite is the decision round. Cursor's is famously a multi-day, hands-on project with the core team and it grades whether you operate like a teammate or wait to be told what to do.

You can't replicate two days alone, but you can rehearse the muscle. Take an open prompt, scope it in five minutes, work it for 60 to 90, then present a recommendation as if the core team is in the room. The point is to practice autonomy under ambiguity, not to produce a finished system.

The five-minute scopeBefore you build anything

1. 1State assumptions out loud. “I'll assume tickets, Discord and forum are the main inputs and there's no triage tooling yet.” Assumptions let you move; you can flag them for correction.
2. 2Name the outcome. What does success look like - faster time-to-resolution, fewer escaped regressions, a weekly brief leadership actually reads?
3. 3Pick your slice. You won't build the whole system. Choose the one vertical that proves the thesis end-to-end.

Work it like a teammate60–90 minutes

• Make decisions and record why - a defensible call beats a hedge every time.
• Bring the feedback-loop lens: show exactly how raw signal becomes a ranked, owned product decision.
• Build the thin vertical, even if parts are stubbed. A working slice you can demo beats a deep, broken layer.
• Keep a running list of what you'd do next if this were day three, so your gaps look deliberate, not forgotten.

Present like it's the real roomThe last 10 minutes

Close every rehearsal with a crisp recommendation: here's the problem as I scoped it, here's what I built, here's why, here's what I'd do next. Then self-score on the four dimensions this round actually grades.

The behavioral round probes a specific value set - ownership, comfort with a brutal pace, craft, customer empathy - and the craft round demands real, opinionated takes on Cursor versus its rivals. Rapid-fire both so the generic answers fall out.

Set a two-minute timer per prompt and answer back-to-back, no breaks. The constraint forces you to lead with a concrete story instead of warming up with filler. Record it, then hunt for the moments you reached for praise instead of a specific observation.

The values promptsTwo minutes each

The 90-second competitive takeCursor vs the field

Deliver a 90-second comparison of Cursor against Copilot, Windsurf and Claude Code, with a clear point of view. Honest opinion beats balanced mush - the round is checking whether you actually use these tools and have formed a stance.

A mock loop only pays off if it converts into a study plan. Score each round, find your two lowest and spend your remaining prep almost entirely there - the loop is graded on your floor, not your ceiling.

Treat the rubric as a gap finder, not a score to admire. Mark the weakest proof, turn it into one practice rep and keep the artifact you would show an interviewer.

Go back through the five drills and rate each one 1 to 5 on the dimension it grades. Be ruthless: a generous self-score is the most expensive mistake you can make this week.

The scorecardRate 1–5, lowest two win your attention

Map gaps to modulesWhere to go for each weakness

The pre-interview ritualThe two weeks before

1. 1Use Cursor for real, daily, 2+ weeks. Not a cram session - sustained use is what produces the lived texture the recruiter screens for.
2. 2Run a fresh competitive scan. Spend an hour each in Copilot, Windsurf and Claude Code so your 90-second take is current, not last quarter's.
3. 3Re-run your weakest drill until it's a 4+. Reps, not reading. A sub-3 on any round is a blocker a 5 elsewhere can't offset.
4. 4Draft your 90-day plan. It doubles as your onsite framing and your closer in the hiring-manager round.