The Cursor Coding Interview
- Know how the Cursor coding screens run, from the starter template to the AI rule
- Know every reported problem, newest first, and which ones to prep before the rest
- Know what the interviewer scores and why working code beats clever code here
Cursor (Anysphere) runs its coding interview as a few short live screens before a project onsite. Each screen is 45 to 60 minutes of pairing with an engineer on a practical, backend-flavored problem. You get a small working piece going first. Then the interviewer adds requirements and you extend what you wrote. It isn't a LeetCode round, though plain data structures do most of the work.
What candidates report falls into a handful of families. A Merkle tree over a directory leads by a wide margin. Rate limiters that have to accept new rule types come next, and the second screen rotates among a few problems after that. Below is how the screens run, every reported problem with its date, and how you're judged. The lessons after this one work each problem in full.
How the Cursor coding interview works
Cursor's careers page gives the official shape: "2-3 short technicals," then an onsite in the office "where you'll work on a small project, discuss ideas, and meet the team." Real loops vary more than that. A Senior ML engineer in July 2026 sat four screens: the Merkle tree, an optimization task on an existing Python library, a project deep dive and a hiring-manager style conversation. No onsite followed. Another 2026 candidate was promised three rounds and a one-day onsite, did five rounds, and never got the onsite either.
The coding screens themselves are consistent. A January 2026 recruiter brief describes 60 minutes pairing with an engineer on a backend coding problem, starting from a template in Python, TypeScript, JavaScript, Ruby, Java, Go, C++ or C#. Other languages can be added on request. Python dominates the Merkle reports. Some screens run on real files rather than a browser pad. One candidate built the Merkle tree inside an actual repo, and the optimization task reportedly needs a local IDE. Have your editor ready and your language's file and hashing libraries fresh in your head.
The same brief spelled out what gets judged: "how you write and iterate on code, communicate your reasoning and understanding of product requirements, API design, and low-level systems design." Take the last two seriously. Several of these screens are small object-design problems with a test harness attached.
Not every screen is coding. Some 2026 loops included a design screen, like storing IDE settings for users and teams, and one ML engineer in October 2026 got to choose between a coding screen and a design screen. Those live in the system design section. The onsite is different again: a small project in Cursor's real codebase that ends in a demo. It has its own lesson.
Is there a Cursor OA?
Not in any 2026 report. Every recent candidate describes a live screen with an engineer on the call, and nobody describes an automated, timed test. Two reports from 2025 did call their first round an online test. One was a Merkle tree with client and server tasks, the other a streaming Markdown parser in TypeScript that took about an hour. Nothing like it has surfaced since. If a recruiter sends you a timed link, ask what it covers, because it would be a change.
One September 2025 candidate did the live screen in HackerRank, with the engineer on the line the whole time. HackerRank was just the shared editor there.
Can you use AI in the Cursor coding interview?
Cursor makes an AI code editor, so everyone asks. In the screens, AI doesn't write your code. CEO Michael Truell said in June 2025 that Cursor still interviews people "without allowing them to use AI, other than autocomplete" in its first technical screens. The January 2026 recruiter instructions said the same thing: "You can use the web to search for syntax, documentation, and examples, but you cannot use AI tools."
The edges move a little. An August 2026 candidate was allowed AI for syntax but not for the implementation. A 2025 new grad was allowed Google, GPT and Cursor "for targeted syntax help." So ask at the start of each screen, and plan to write every line yourself. Ask about the onsite project's rules separately.
What Cursor asks, newest first
Problems rotate, and many 2026 reports show only a short summary, so learn the shapes below rather than a script. Each one is dated by its newest report.
The Merkle tree (latest report September 2026). About a dozen reports from 2025 through September 2026, more than any other problem, and it's usually the first screen. You build a tree over a real directory, where a file's hash comes from its contents and a folder's hash comes from its children in a fixed order. You expose something like get_hash(path). Then you diff two trees into added, modified and removed paths, going down only into folders whose hashes differ.
Reported follow-ups include syncing only the changed subtrees between a client and a server, updating a cached tree after one file changes, and whether you trust a matching hash or compare bytes. One September 2026 candidate had to write all their own tests inside the hour.
Cursor didn't pick this at random. Its January 2026 engineering post, "Securely indexing large codebases," describes a Merkle tree with "a cryptographic hash of every file, along with hashes of each folder that are based on the hashes of its children." A 2025 new grad said the hash tree they built in their screen was one Cursor uses for real. Read the post before your screen. The core of the build is small:
import hashlibimport osdef tree_hash(path): if os.path.isfile(path): with open(path, "rb") as file: return hashlib.sha256(file.read()).hexdigest() digest = hashlib.sha256() for name in sorted(os.listdir(path)): # fixed order, or equal folders hash differently child_hash = tree_hash(os.path.join(path, name)) digest.update(f"{name}:{child_hash}\n".encode()) # the name goes in, so a rename shows up return digest.hexdigest()The diff is the same walk over two trees. Equal hashes mean you skip that whole folder, which is the point of the structure. The full build, with tests and the sync follow-up, is in the free Merkle lesson.
Optimize an existing library (latest report August 2026). You get working code and make it faster with better data structures and algorithms. The Senior ML engineer above got it as their second screen. Summer 2026 candidates describe Python and TypeScript versions that run in a local IDE. The library has never been named, so prep the skill itself: measure first, find the hot loop, replace the slow lookup, and keep the tests green.
The notification rate limiter (February to July 2026). Something like should_send_notification(user_id, timestamp) that returns true or false. Each user belongs to one team and each team to one company, and every level has its own rolling-window limit. A denied attempt counts against nobody. The second part makes the limiter accept new rule types, message size for example, without touching the core. One 2026 candidate failed because they didn't finish that extension.
The transactional key-value store (latest report mid-2026). An in-memory store with begin, commit and rollback, then questions about concurrency. The candidate who passed it in March 2026 said it felt like class design in an object-oriented language, closer to modeling than to a system design round. It was asked again as a second screen in mid-2026.
The streaming Markdown parser (May 2025 online test, seen again July 2026). Parse Markdown as it arrives in chunks, keeping state across chunk boundaries, with single-backtick inline code and triple-backtick fenced blocks. In May 2025 it was a one-hour TypeScript online test, and a July 2026 version framed it as a streaming code-fence parser. Prep it after the live-screen problems.
Fix a stacked PR, Graphite team (April 2026). Graphite joined Cursor in December 2025, and its team runs its own screens. One April 2026 phone screen had the candidate review a pull request and fix the bugs in it, about 30 minutes across three files with tests, then about 15 minutes on longer-term changes. The same screen was paired with an i18n design round.
The completions API rate limiter (January 2026). The input is a request log, with rows something like user ID, endpoint, body size and timestamp. Part one limits each user on one completions endpoint, and denied requests don't count. Part two turns that into an interface for several rule types: per-endpoint rates over a second, a minute or an hour, a byte budget per minute, and a global hourly cap. A request goes through only if every rule passes. The candidate passed with an interface and two concrete rule classes. It shares a free lesson with the notification limiter, since the shape is the same.
Older, from 2025. The 2025 Merkle online test added client and server tasks, and a March 2025 first round was a parser task run locally, likely the streaming parser's family. A pre-acquisition Graphite screen in late 2025 paired a short coding round with the same i18n design the team still asks.
How the screens are scored
The algorithms are rarely the hard part. Hashing a folder, counting events in a window or keeping a stack of pending writes is medium work at most. What makes these screens hard is finishing several parts in an hour with code clean enough to extend.
Two candidates set the bar between them. The one who passed in January 2026 wrote: "Goal from the interviewer was to get a working solution. Don't overindex on time and space complexity optimization." A September 2026 candidate finished every part of the Merkle problem with a bug or two and was still rejected: "Their bar is really high ... you need to get through with zero hiccups." So aim for working code early, and leave yourself very little to clean up at the end. The optimization screen is the exception, since making code fast is what it asks for.
Get part one working and tested before you design for part two, but leave room where part two will plug in. In the rate limiters that's a rule interface. In the Merkle tree it's a node that knows its path and its hash. Name things plainly and say your trade-offs out loud, since API design is on the scorecard.
ML and specialist roles
ML engineers get the general screens too. The Senior ML engineer's July 2026 loop opened with the Merkle tree and then the library optimization, so don't assume an ML role skips them. One early 2026 report describes a PyTorch coding screen for an ML role, with no detail visible beyond that. If you're interviewing for a model or data team, ask whether one of your screens is in PyTorch. Most open engineering roles in November 2026 sit on ML platform, pretraining data and research tooling teams, so this applies to more candidates than it used to.
Practice by problem family
Work through these in order. The two most reported families come first, and both are free. After them come the rotating second-screen problems and the onsite project, with the streaming parser last as an extra rep.
The Merkle Tree Screen: Hash, Diff & Sync
The most reported Cursor problem: hash a directory, diff two trees, then sync only what changed.
Rate Limiters with Pluggable Rules
User, team and company notification limits, plus the completions API limiter, each made extensible.
In-Memory Transactional Key-Value Store
Begin, commit and rollback in memory, then the concurrency follow-ups.
Existing Code: Optimize a Library & Fix a PR
Speed up working code without breaking it, and fix bugs across a pull request with tests.
The Onsite Project & Work Trial
A small project in the real codebase that ends in a demo, and how to scope it for one day.
Streaming Markdown Parser
The 2025 online test, seen again in 2026: inline code and fenced blocks split across chunks.
Common questions
What is the Cursor coding interview like?
A live screen of 45 to 60 minutes with an engineer, from a starter template in your language. You build a small working component, then extend it as the interviewer adds requirements. In 2026 the first screen is usually the Merkle tree. The second rotates among a rate limiter, a transactional key-value store and an optimization task on existing code.
Does Cursor have an OA?
No 2026 report describes one. Recent candidates all describe live screens with an engineer. Two 2025 candidates called their first round an online test, but nothing like it has come up since.
Is the Cursor interview LeetCode?
Not in the usual sense. The problems are practical builds, the kind of component you'd write at work. No LeetCode problem matches the Merkle screen exactly, and the rate limiters only share the sliding-window counting of problems like Logger Rate Limiter. One January 2026 interviewer said a working solution mattered more than optimal complexity.
Can I use AI in the Cursor coding interview?
Not to write your code. The CEO and a January 2026 recruiter brief both say no AI in the early screens, apart from autocomplete or web search for syntax. A couple of candidates were allowed AI for syntax questions only. Ask at the start of each screen.
What language should I use?
The one you're fastest in. The template comes in Python, TypeScript, JavaScript, Ruby, Java, Go, C++ and C#, and others can be added on request. Python is the most common choice for the Merkle screen, and the optimization task comes in Python and TypeScript.
How many coding rounds are there?
Officially two or three short technicals before the onsite. Reported loops run from one to five screens, and some mix in a design screen or a project deep dive. Two 2026 candidates did four and five screens and never reached the onsite, so treat every screen as the deciding one.
How hard is the Cursor coding interview?
Each part is medium-sized, but the bar on finishing is high. A September 2026 candidate completed every part with a bug or two and was still turned down. Speed with clean code is what separates people.
How do I prepare?
Build the Merkle tree end to end under time, with your own tests. Then build a rate limiter and turn it into pluggable rules. After that, do the key-value store with rollback and one round of speeding up someone else's code. Practice talking through your API choices as you write.
Key Takeaways
- ✓Cursor's coding screens are live, 45 to 60 minutes with an engineer, and you extend a small build as requirements grow.
- ✓The Merkle tree over a directory is the most reported problem. Rate limiters with pluggable rules come next.
- ✓AI can't write your code in the screens, and no 2026 report describes an automated OA.
- ✓Working, tested code that takes the next requirement cleanly beats clever complexity. API design is scored.
Free Cursor interview pages
Cursor interview guideKnow what Cursor asks before you walk in.
9 coding · 4 system design · 16 behavioral questions
Get their questions first.
InterviewLegend is independent and not affiliated with or endorsed by any company it covers.