Jane Street's Interviews Are Changing: What the New Rounds Test and How to Prepare
What Jane Street's November 2026 post on its software engineering interviews actually says, who it affects, why the firm is doing it, and how to practise design, code verification and LLM-assisted rounds.

On 2 November 2026 Jane Street published a short post titled Our software engineering interviews are changing (a little). It was three minutes long and travelled much further than that. Within days it was being passed around r/quant, LinkedIn and every Discord where people prepare for trading firms, usually with a stronger headline than the one Jane Street wrote: "Jane Street lets you use AI in interviews now," or "LeetCode is dead at Jane Street."
Neither is what the post says. The real change is smaller, more specific, and more useful to understand, because it tells you what one of the most selective employers in the industry now thinks a good engineer is. This guide breaks the post down line by line, separates what changed from what did not, explains why Jane Street is doing it, and turns each new kind of round into something you can practise this week.
What Jane Street actually said
The post is by Matthew Saffer, a software engineer who joined Jane Street in 2013. It starts from how the firm works now: most of its engineers use LLMs every day, "not only for writing code, but also for reading, debugging, and reviewing code, and plenty of things that aren't code at all."
Then it says something people skimmed past: the interviews themselves have not changed. Candidates still "sit down with an interviewer or two, program through a problem together, and talk as you go," and the goals are the same as ever: how you solve problems, structure your work, communicate and collaborate.
The change is a trial. In the post's words, "As generating code has become arguably cheaper than ever, other parts of the job have come to matter even more: taste about what to build, choosing abstractions that last, and making sure what got built is actually correct." So this summer Jane Street started trialling new kinds of interviews in campus onsites. They involve less writing code and sit at a higher level, focusing on:
- Software design.
- Verifying the quality, structure and intention of code.
- Using LLMs to produce code.
And then the sentence that matters most for your preparation: "Most rounds will continue to be traditional coding interviews, conducted without LLM assistance."
Here is the whole post as a before and after:
| Before | After the trial | |
|---|---|---|
| Who is affected | Software engineering candidates | Campus SWE candidates at onsites, and not every onsite yet |
| Most onsite rounds | Live coding with one or two engineers, no LLM | The same |
| Some onsite rounds | Live coding | Possibly a design, code-verification or LLM-assisted round |
| Phone interview and the rest of the process | As described in their 2020 post | Unchanged, and the 2020 post "still accurate" |
| Experienced candidates | Varied: building software, system design, past work | The same, "as has been the case for some time" |
| What they assess | Problem solving, structure, communication, collaboration | The same |
Jane Street is also deliberately vague about the new formats: "we'd rather not describe something in detail today that looks different in six months." Treat anyone who claims to know the exact new questions with suspicion. The firm itself does not want them pinned down yet, and Jane Street has always asked candidates not to share interview questions.
Who this actually affects
What changed, and for whom
Campus software engineering
Trialling new rounds- PhoneCoding
- OnsiteCoding
- OnsiteCoding
- OnsiteCoding
- New, some onsitesDesign · verify code · build with an LLM
Experienced software engineering
Unchanged- Building software
- System design
- Past work
Trading and research
Not in the post- Probability
- Mental math
- Games and EV
- Coding
Campus software engineers. You are the audience. If you are interviewing for a SWE internship or new grad role, you may get one of the new rounds at your onsite, and Jane Street says it will tell you in advance what to expect. Most of your day will still be live coding without an LLM, so that remains the bulk of your preparation.
Experienced engineers. Little changes. Your interviews were already a mix of building software, designing systems and discussing your past work.
Traders and researchers. The post does not mention you at all. Jane Street's 2020 interview post was explicit that "interviews for roles in trading, research, and other parts of the business will differ substantially" from software engineering, and nothing in the new post touches them. Your loop is still probability, expected value, mental math, estimation and market making games, run by traders. Our Jane Street interview guide covers that process in detail, and none of it is out of date.
Three misreadings are worth correcting directly:
- "You can use ChatGPT in the interview." Only in a round built around it, if your onsite has one. Everywhere else the rule is still no LLM assistance.
- "Coding interviews are going away." The post says the opposite: most rounds stay traditional coding.
- "You need an agentic workflow to get hired." Jane Street says plainly that "you shouldn't feel like you need to have a highly worked out methodology for working with agents in order to do well in our process," and that it does not "need an LLM to evaluate" good instincts for building software.
Why Jane Street is doing this
The post is short, but Jane Street has spent the last few months explaining its thinking at length elsewhere, and reading those sources tells you what the new rounds are really looking for.
Verification is now the bottleneck. In the October 2026 Signals and Threads episode The Changing Craft of Programming, Ron Minsky and John Crepezzi talk about how the firm's internal AI tooling grew from a chat prototype into firmwide agentic coding. Minsky's summary of what got harder: "I think in some ways it's harder to verify code that no person wrote." Crepezzi adds that model-written code "can be wrong in a very subtle way that isn't obvious when you first look at it," and that once it compiles and appears to work, "it's kind of tempting to not understand it. And there's a risk in that." He also describes how the job itself has moved: "your role has shifted a lot in a lot of cases more toward code review."
Generated code drifts towards complexity. In Formal methods and the future of programming, Yaron Minsky writes that agentic code is getting better but still "tends towards slop: overly complicated, full of weird bugs and corner cases, often not following essential invariants of the codebase that it's a part of." That is a list of exactly the things a reviewer has to catch.
Design decides what is easy to verify. The same post argues that types help "both for easing the verification bottleneck and providing agents with better feedback." Good abstractions are not decoration. They are what makes code checkable, whether a person or a model wrote it.
Put those together and the three new round types stop looking random. If writing code is cheap, Jane Street wants to know whether you can decide what to build, structure it so it stays correct, and tell whether something someone else (or something else) wrote is right. That is the job now, so that is the interview.
The industry is moving the same way. HackerRank, the company most associated with algorithm-puzzle screens, recently published an essay from its CEO titled Sorry, we made you grind LeetCode, arguing that developers "need to know when the code is good, when it needs another pass, and when it's completely wrong." Jane Street's version is more cautious: a trial, a few rounds, most of the old format intact.
The new rounds and how to prepare for each
Jane Street has not published the formats, so what follows is not a leak or a guess at specific questions. It is the skills each round type names, and practical ways to train them.
Software design
What it probably tests: given a problem, can you choose the pieces, the interfaces between them and the data representation, and explain the trade-offs? In Jane Street's words, "choosing abstractions that last."
The firm has a well-known design principle that is a good place to start. Yaron Minsky's Effective ML talk popularised the phrase "make illegal states unrepresentable": shape your data so that invalid combinations cannot be built at all. His example is a connection record full of optional fields (a session id, a last ping time, a disconnect time) where nothing stops a "disconnected" connection from carrying a session id. The fix is to give each state its own record, so a disconnected connection simply has no session id field.
How to practise:
- Pick a small system and write only the interface first. An order book, a rate limiter, a job scheduler, an LRU cache. Write the types and function signatures, with no bodies, then explain to a friend why each one exists.
- Hunt for illegal states. For each data type, ask which combinations of fields should be impossible, and whether your types prevent them.
- Argue the alternative. For every decision, say what the other option was and when it would win. Interviewers care about trade-offs, not one right answer.
- Keep it small. A design that fits in your head and on one screen is a better interview answer than a sprawling one.
Verifying code
What it probably tests: given code you did not write, can you tell whether it does what it claims, find the bugs, and judge whether it is well structured? Jane Street's phrase is "verifying the quality, structure, and intention of code."
The figure below is a practice round. An assistant was asked for a bounded memoisation helper, a cousin of the Memo question Jane Street once used in phone interviews and has since retired. The code runs and looks tidy. Flag every line you think is wrong, then check your review.
Practice round: review this assistant-written code
0 lines flaggedThe prompt was: “Write a Python helper that memoizes f and keeps only the max_size most recently used results.” Tap any line you would flag in review.
All three bugs pass a quick test. Call it a few times with small inputs and every answer is correct. They only appear when you ask what the code promises (the docstring says "most recently used"), what the library call actually does (popitem() removes the newest entry by default), and which inputs could share a key. That is the habit Jane Street is pointing at.
How to practise:
- Review before you run. Read a function, write down what you think it does and any bugs, and only then test it. Running first teaches you nothing about reading.
- Check the claim, not just the code. Docstrings, names and comments are promises. Bugs usually live in the gap between the promise and the code.
- Read the library docs for every call you are not sure about. Defaults like
popitem(last=True)are where plausible code goes wrong. - Ask what tests would catch it. Naming the test that would fail is half of a good review comment.
- Know when to delete code. Python already ships
functools.lru_cache. Sometimes the best review comment is "use the standard library," which is exactly the "when to reach for something else" judgment Jane Street describes. - Review real code. Read merged pull requests in an open-source project you use, and try to predict what the reviewers said before you read their comments.
Working with an LLM
What it probably tests: can you use a model to produce code while staying in charge of correctness? Jane Street's bar is that you "think clearly about the tools you use: what they're good at, where they fall short, and when to reach for something else." It explicitly does not expect a particular setup.
How to practise:
- Break the task down before you prompt. Decide the structure yourself, then ask for one piece at a time. A model that writes everything at once hands you everything to verify at once.
- Say what you are checking as you go. In an interview, "I'm reading this before I accept it, and I want a test for the empty case" is the signal. Pasting output and moving on is not.
- Notice when it is wrong and say so. Be ready to explain why a suggestion is wrong, or more complex than it needs to be, and what you would do instead.
- Know when to put it down. Some changes are faster to write than to describe. Doing them yourself is a valid choice, not a failure to use the tool.
- Practise without it too. The traditional rounds are still the majority and still LLM-free. If you rely on autocomplete, spend part of your practice in a plain editor.
We wrote a longer guide on preparing for quant interviews with AI, covering what models are good at, where they fail, and the one place you must not use them.
The traditional rounds still decide most of your onsite
It is easy to over-prepare for the novelty and under-prepare for the majority. Jane Street's standard software engineering interview is still the one it described in its 2017 walkthrough: write real code (not pseudo-code) in the language you know best, reason about its problems, and improve it as the interviewer extends the question. The firm says it might prefer a candidate who "wrote careful and clear code, communicated well and had good insights" to one who finished faster but was "sloppy and hard to follow."
The old guidance still applies too. Use your strongest language: there are "no bonus points for using OCaml." You do not need to know finance. For general software engineering, the 2020 post promised, "We won't ask you math or probability questions."
Notice that the old format already rewarded the new skills. Talking through trade-offs is design. Spotting your own memory leak in part two of Memo is verification. The new rounds just test those skills directly instead of as a side effect of writing code.
Where PuzzledQuant helps with the traditional rounds:
- Algorithms, with a judge. The Algorithms and Advanced Algorithms video courses come with judged problems, so you find out your code is wrong before an interviewer does.
- OCaml, if you are curious. You do not need it to interview, but if you want to read the language Jane Street writes, our OCaml exercises are a gentle way in. Reading idiomatic typed code is good design practice in any language.
- C++ for low-latency roles. If you are also applying to HFT firms, our C++ exercises cover what low-latency teams ask about.
- Jane Street's other tracks. If you are deciding between engineering and trading, the Jane Street-tagged problems show you what the trading loop feels like.
A two-week plan for a Jane Street SWE onsite
If your onsite is two weeks away, here is a schedule that weights each round by how likely it is to appear.
Days 1 to 5: traditional coding (60% of your time). One or two medium problems a day, talking out loud, in your strongest language and without an assistant. After each one, extend it yourself, the way Jane Street does: what breaks at scale, what happens with bad input, how would you make it faster?
Days 6 to 8: verification. Every day, review two pieces of code you did not write: a function from an open-source project, a classmate's solution, or code a model wrote for you. Write your review comments before running anything, then check them.
Days 9 to 11: design. Design one small system a day, interface first. Find the illegal states and remove them. Explain the design out loud in five minutes.
Days 12 to 13: LLM-assisted practice. Build one small feature with a model while narrating what you check and why. Record yourself and listen for moments where you accepted output without reading it.
Day 14: rest and logistics. Re-read Jane Street's posts, prepare questions for your interviewers, and sleep. If Jane Street told you which rounds to expect, do one final session on those.
What this means beyond Jane Street
Jane Street is one firm running one trial, and it says it will "keep iterating." But it is a firm other firms watch, and the idea behind the change is not specific to it. When code is cheap, the scarce skills are taste, design and verification. Those were always what separated strong engineers from fast ones. The interview is just catching up.
For trading and research candidates the lesson is similar, even though your loop has not changed. Jane Street has always cared more about how you reason than about the answer you reach, which is why its trading interviews reward explaining your thinking and correcting your own mistakes. Whatever the round, the skill being tested is judgment.
When you are ready to practise, create a free account and start with the problems tagged for the firm you are targeting. Premium unlocks every problem, course and game, and the pricing page has the details.
Frequently asked questions
Can I use ChatGPT or Claude in a Jane Street interview?
Only in a round designed for it. Jane Street is trialling some LLM-assisted rounds in campus software engineering onsites, but "most rounds will continue to be traditional coding interviews, conducted without LLM assistance." Jane Street says it will tell you in advance what to expect at your onsite.
Did Jane Street change its trading or quant research interviews?
No. The November 2026 post is about software engineering interviews only. Trading and research interviews are run differently and are not mentioned. They still focus on probability, expected value, mental math and decision making under uncertainty.
What are the new Jane Street interview rounds?
Jane Street describes them broadly as involving less code-writing and focusing on software design, on verifying the quality, structure and intention of code, and on using LLMs to produce code. It has deliberately not published detailed formats because they are still changing.
Do I need experience with AI coding agents to get hired at Jane Street?
No. Jane Street says you should not feel you need "a highly worked out methodology for working with agents" to do well, and that it does not expect any particular setup. What it wants is clear thinking about tools: what they are good at, where they fall short and when to use something else.
How should I prepare for Jane Street's software engineering interviews now?
Spend most of your time on traditional live coding without an assistant, since that is still most of the onsite. Then practise reviewing code you did not write, designing small systems interface first, and building with an LLM while explaining what you check. Use the language you know best; OCaml earns no bonus points.
Sources
- Jane Street, Our software engineering interviews are changing (a little), Matthew Saffer, 2 November 2026.
- Jane Street, The Jane Street Interview Process, 2020 Edition, Sam DeFabbia-Kane, 24 July 2020.
- Jane Street, What a Jane Street software engineering interview is like, Sebastian Funk, 28 February 2017.
- Signals and Threads, The Changing Craft of Programming, Ron Minsky with John Crepezzi, 16 October 2026.
- Jane Street, Formal methods and the future of programming, Yaron Minsky, 7 June 2026.
- Jane Street, Effective ML Revisited, Yaron Minsky.
- HackerRank, Sorry, we made you grind LeetCode.
- Python documentation, collections.OrderedDict and functools.lru_cache.