Your Applied Intuition Prep Plan

You've seen how the Applied Intuition loop is built and judged, so this lesson turns that into a week-by-week plan. One split shapes the order more than anything, and most guides miss it: the loop is mid-transition on AI tooling. The phone screen is kept deliberately AI-free to prove you can write correct, working code with your own hands. The onsite now includes a timed prototyping sprint where you may reach for any AI model or framework. Preparing for one doesn't prepare you for the other. The rest of the loop has a systems-engineering accent, with coding colored by the autonomy and simulation domain and a design bar that leans on C++ and clean object-oriented reasoning.

The Applied Intuition angle

Before you drill anything, get the frame right, because the AI policy is evolving and older advice describes earlier versions. Read the interview process and how leveling and decisions work. The "generative AI is banned outright" read is stale; it holds only for the phone screen. The newer onsite hands you a roughly two-hour build sprint with AI allowed, then grades your judgment, your decisions, and how you present them. Prepare the screen and the sprint separately. C++ with clean OOP is emphasized but not a hard requirement; some candidates code the screen in other languages, while the low-level-design and onsite bar reward memory-aware, well-structured C++.

• The floor: Correct, unaided coding on the AI-free screen. one live medium-to-hard problem on a shared editor, almost always a familiar algorithm with a twist or an added constraint. It's kept AI-free to establish that you code cleanly without assistance, and it scores a full working solution with edge cases and tests
• The accent: Autonomy-flavored problems and a C++ low-level-design bar. the coding is colored by the domain: lane-segment geometry, multi-agent kinematics collision sims, sensor and TLV message parsing, coordinate grouping. The design surface runs to low-level design in C++, like a transactional key-value store with nested transactions or a small interpreter
• The differentiator: A timed AI-allowed prototyping sprint you present. the onsite adds a roughly two-hour sprint where any AI tooling is fair game, then a panel demo and a walkthrough of your decisions. The grade is technical judgment, communication and fit under direct push-back, plus a concrete why-Applied-Intuition tied to the autonomy mission

The plan, week by week

Each phase has one focus and a checkpoint that tells you when you've earned the next. A phase is a share of your prep time, so the plan holds for a month or for one hard week. Unaided coding comes first, because the AI-free screen earns the onsite; drill the autonomy-flavored variations alongside abstract puzzles. C++ low-level design comes next, since a transactional store or a small interpreter under a clock is a skill graph problems won't build. The AI-allowed sprint gets its own block, because building and presenting a prototype fast is rehearsable and most candidates never practice it. System design and behavioral run lighter, though the push-back and the why question are real gates. Don't step past a checkpoint until you can clear it without notes.

Here's a five-week runway with the phases stacked in order. Week one is the unaided screen: complete, correct solutions with no assistant open, until finishing under time is routine. Week two adds the domain (lane geometry, coordinate grouping, message parsing, a kinematics collision sim), so a driving-flavored wrapper no longer slows you down. Week three is C++ low-level design, the nested transactional store and a small interpreter, built and defended out loud. Week four rehearses the two-hour AI-allowed sprint and demo, with a few timed builds you present; the last stretch goes to AV system design, behavioral and a specific why. On a shorter runway, compress without reordering, because the AI-free screen earns the onsite and the sprint plus systems design win it.

The Applied Intuition angle

Treat the autonomy costume on the coding problems as presentation. A prompt about lane segments to merge, a byte stream to parse, or agents stepping forward under a kinematic model tests whether you can find the clean structure inside a domain-shaped description. The code after that is ordinary. The failure mode is freezing on the scenario and never reaching the interval merge, union-find, breadth-first search or state machine underneath. So practice the translation as its own skill: say out loud what data structure and algorithm a prompt reduces to, and only then code. Candidates who drilled abstract puzzles but never stripped a simulation prompt down lose time exactly where this loop watches.

Why the AI split decides it

The weighting tracks where this loop departs from a generic one. At a large product company, the algorithm rounds filter and the design round is a familiar design-a-social-app exercise. Here, coding is split by tooling: the phone screen is unaided to prove a baseline, and the onsite sprint welcomes AI and puts your judgment on trial. Most candidates prepare only the first and walk into the second cold. The systems accent is also real. A nested transactional store or a small interpreter in clean C++, and design prompts steered to sensor pipelines and replay systems, need memory-aware engineering that hard graph problems don't build.

The Applied Intuition angle

The trap is preparing for the wrong Applied Intuition. The coding bar tops out around medium-hard-with-a-twist, so a month of the nastiest dynamic-programming problems aims well past it. Meanwhile the AI-allowed sprint and the C++ low-level design, which separate candidates, go unrehearsed. "AI is banned" is half the story: unaided on the screen, welcomed and judged on the sprint. The cultural-fit read is direct, so a candidate who folds under push-back or wings the why question stalls. Spend your marginal hour on the sprint demo you fumbled or the transactional store you couldn't finish, and skip a fifth hard puzzle the loop won't pose.

In the room

• Clear the AI-free screen unaided. One live medium-to-hard problem, usually a familiar algorithm with a twist, coded to a full working solution with edge cases and a quick test, no assistant open. Make clean, memory-aware C++ your default, knowing it's emphasized but not strictly required.
• Practice the autonomy and simulation flavor. Lane-segment and collinear merges, coordinate grouping by union-find or flood fill, sensor and TLV message parsing, and a multi-agent unicycle-kinematics collision sim all wrap ordinary structures. Read the wrapper, name the algorithm, then code it.
• Build clean OOP low-level design in C++. A transactional key-value store with nested begin, commit and rollback, and a small formula or DSL interpreter, blend algorithm, class design and memory reasoning. Implement them end to end and defend every representation choice out loud.
• Rehearse the AI-allowed prototyping sprint and demo. The onsite gives you roughly two hours with any AI tooling, then a panel demo and a decisions walkthrough. Run a few timed builds, ship something that works, and present what you chose, what you cut, and what you'd harden next.
• Bring composure and an honest why. AV and distributed-systems design prompts reward requirements coverage and justified trade-offs. The cultural-fit push-back is direct. The why-Applied-Intuition question wants a concrete tie to the autonomy-tooling mission.