<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Code Grey on Medium]]></title>
        <description><![CDATA[Stories by Code Grey on Medium]]></description>
        <link>https://medium.com/@codegrey?source=rss-1ebe5a4e2baf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4lVVhXAd9Bc_GYAxp_B5yQ.png</url>
            <title>Stories by Code Grey on Medium</title>
            <link>https://medium.com/@codegrey?source=rss-1ebe5a4e2baf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:06:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@codegrey/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[Google vs. Meta vs. Amazon: How Their New AI-Assisted Coding Rounds Actually Differ]]></title>
            <link>https://medium.com/@codegrey/google-vs-meta-vs-amazon-how-their-new-ai-assisted-coding-rounds-actually-differ-9a64995b838b?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a64995b838b</guid>
            <category><![CDATA[developer-interview]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-coding]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 19:01:01 GMT</pubDate>
            <atom:updated>2026-11-11T19:01:01.640Z</atom:updated>
            <content:encoded><![CDATA[<p>All three companies now have some version of an AI-in-the-room interview. None of them look the same. The mistake candidates make is preparing for “the AI-assisted interview” as if there is one format to understand, when what actually exists is three meaningfully different evaluations that share a surface similarity and diverge in almost every detail that matters for preparation.</p><p>I have covered<a href="https://medium.com/@codegrey/the-new-ai-aware-coding-interview-how-to-prepare-in-2026-6a207d94b23a"> Meta’s AI-enabled round</a> in depth and<a href="https://medium.com/@codegrey/google-just-changed-its-coding-interview-this-week-heres-exactly-what-to-do-now-e7ec28aa8861"> Google’s Gemini pilot</a> separately. This piece does what those pieces cannot do alone: put all three side by side, isolate the specific differences, and tell you exactly how your preparation should shift based on which company you are walking into.</p><h3>The comparison at a glance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*VQKhVzwzfepB83wfTMVqMg.png" /></figure><h3>Meta: the classic pillars, with an AI tool in the room</h3><p>Meta’s AI-enabled round replaced one of its two traditional onsite coding rounds in October 2025 and has since expanded to most backend and infrastructure SWE roles. The setup is 60 minutes in CoderPad with an AI chat panel built directly into the interface. You have a model switcher with access to GPT-5, Claude Sonnet and Haiku, Gemini 2.5 Pro, and Llama 4 Maverick.</p><p>The critical thing to understand about Meta’s scorecard is that AI fluency is not explicitly on it. Meta evaluates candidates on four classic pillars: problem solving, code quality, verification behavior, and communication. The AI is available. How you use it matters. But the rubric is the same four dimensions that existed before the format changed.</p><p>What this means in practice: Meta is not grading whether your prompts are good. It is grading whether your code is good and whether you can explain it. A candidate who uses AI to write every line but explains each decision clearly and catches the model’s errors will score better than a candidate who writes every line manually but cannot articulate the tradeoffs. And a candidate who pastes AI output without reading it will score very badly, because the codebase problems are designed to surface whether you actually understood what the AI produced.</p><p>The three-phase structure moves from reading the existing codebase, to fixing a bug or set of bugs, to extending the implementation with a new feature. Most candidates spend too long on the first phase and run out of time on the third. Reading the codebase is not optional, but it should take five to ten minutes, not twenty-five.</p><p>The model selection question comes up constantly. Candidates have reported GPT-5 feeling slow under interview time pressure. Claude Sonnet models have been the most commonly recommended default. The practical answer is to switch models the moment one produces output that does not match the codebase’s logic, rather than fighting a hallucinating model for three minutes. The model switcher exists for a reason.</p><h3>Google: AI fluency explicitly on the rubric</h3><p>Google’s format is structurally similar to Meta’s but scores it differently, and that difference changes how you should approach the round.</p><p>The Gemini-assisted code comprehension pilot began rolling out in the second half of 2026 for junior and mid-level SWE roles on select US teams, starting with Google Cloud and the platforms and devices unit. The environment is a three-panel editor: the codebase on one side, the test output panel in the center, and the Gemini chat panel on the right. The codebase is 200 to 500 lines of real production code. You have 60 minutes.</p><p>Unlike Meta, Google puts AI fluency explicitly on the scorecard. Interviewers are evaluating prompt quality, output validation, and whether you can debug Gemini’s suggestions.</p><p>The practical implication: at Google, how you use the AI is part of the grade, not just whether the final code works. An articulate prompt followed by careful validation of the response will score differently from copy-pasting the first suggestion Gemini returns, even if both produce working code.</p><p>Google’s round is also the only one where the approved AI is explicitly a single model. You get Gemini. There is no model switcher. This narrows the model-selection question that occupies candidates in the Meta round, but it also means familiarity with Gemini’s behavior specifically is more relevant prep than broad AI tool fluency.</p><p>One important caveat: this is a pilot. As of October 2026, it is scoped to specific teams and levels. If you are interviewing for a senior backend role not on the listed teams, your loop almost certainly still uses the classic format. Confirm with your recruiter. Preparing for the new format does not hurt you in the classic format, but assuming you will get the new format when you will not is a real risk.</p><h3>Amazon: two separate AI components, not one</h3><p>Amazon’s situation is the most distinct from the other two, and it is the most commonly misunderstood by candidates who read general “AI-assisted interview” advice.</p><p>Amazon does not have an AI-assisted live coding round in the way Meta and Google do. What Amazon has is two separate AI components, neither of which looks like the CoderPad format.</p><p>The first is in the online assessment. One Amazon OA component gives candidates a code repository, a guardrailed AI model, and failing tests. The task is to understand what the model was doing and correct its behavior within the provided constraints. This is testing code reading and debugging judgment before any human conversation happens.</p><p>The second is the GenAI fluency round, which is a dedicated conceptual interview that sits alongside the coding and system design rounds in the onsite loop. It is confirmed in SDE II loops for teams with active AI product work, including AWS AI, Alexa, and Amazon Ads. A typical prompt: a production issue at YouTube needs to be resolved within one hour using AI tools. Walk through how you would use AI effectively without over-relying on it. The round evaluates whether you can discuss AI architectures (RAG pipelines, chunking strategy, embedding model selection, hallucination mitigation), justify the use of AWS GenAI services, and demonstrate engineering judgment about when AI helps and when it introduces risk.</p><p>The trap for Amazon candidates is treating the GenAI fluency round like a DSA round. It is not a coding round. Preparing for it with LeetCode problems is approximately as useful as preparing for system design with behavioral story practice. The round is a discussion. It rewards engineers who have actually worked with or thought seriously about generative AI systems in production, not engineers who have memorized the syntax for calling the Bedrock API.</p><h3>What is actually the same across all three</h3><p>All three formats reward the same underlying behavior: treating AI output as a draft from a smart but unreliable collaborator. The candidates who perform well in any of these rounds are the ones who read what the AI produced before using it, catch the errors, and explain their reasoning while they work. The candidates who underperform are the ones who go silent while prompting, paste output without reviewing it, or cannot explain the code in their submission when asked a follow-up question.</p><p>The communication dimension is the most consistent across all three formats and the one most underinvested in by candidates who have never practiced it deliberately. Thinking clearly is not enough. Thinking clearly while narrating is the skill the round actually tests, and it requires practice under realistic conditions.</p><h3>How preparation should differ by company</h3><p>For Meta, practice in a real CoderPad-like environment with an AI chat panel running alongside the editor. The key drill: take a medium-to-hard codebase you have not seen, give yourself five minutes to read it, then use Claude or GPT to help you extend or debug it while narrating your reasoning out loud. Read every AI suggestion before accepting it. The model switcher is the second skill to build: get comfortable identifying when a model is hallucinating on a specific codebase context and switching rather than debugging the model’s output.</p><p>For Google, the preparation shifts toward Gemini specifically and toward explicit prompt design. Practice prompting Gemini with constrained, specific requests rather than open-ended ones: “This function is supposed to return the shortest path but fails when the start and end node are the same. What is the most likely cause.” The validation habit matters most: treat every Gemini suggestion as a hypothesis to verify against the actual code before implementing it. Read<a href="https://medium.com/@codegrey/the-new-ai-aware-coding-interview-how-to-prepare-in-2026-6a207d94b23a"> what nobody tells you about the Meta round</a> for the code-reading discipline that carries directly into the Google format as well.</p><p>For Amazon, the OA component is closer to a debugging exercise than an AI fluency test. Practice reading failing tests and tracing back to the code behavior that produced them. For the GenAI fluency round, study <a href="https://www.educative.io/courses/rag-llm?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=rag_architecture&amp;eid=5082902844932096">RAG architecture</a>, AWS Bedrock, and SageMaker at a working level. Review Anthropic’s and Amazon’s public documentation on responsible AI. Prepare two or three specific examples from your own work: a time you used AI and it helped, a time you did not and why, a time AI output led you somewhere wrong and you caught it.</p><p>For all three, <a href="https://www.educative.io/mock-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=educatives_ai_mock_interviews&amp;eid=5082902844932096">Educative’s AI mock interviews</a> let you rehearse full coding, System Design, and behavioral rounds. The communication habit you build there, thinking out loud under realistic time pressure, is the single most transferable skill across all three formats regardless of which company you are interviewing with.</p><h3>The one thing that does not change</h3><p>Across Meta, Google, and Amazon, no AI-assisted format removes the need for foundational engineering knowledge. You cannot evaluate AI output on a graph traversal problem if you do not understand graph traversal. You cannot catch a hallucinated RAG chunking strategy if you have not thought about why chunking decisions matter. The AI in the room makes visible the gap between recognizing a solution and understanding it, because the recognition is now outsourced and the understanding is what the interview is left to test.</p><p>That is the clearest description of what all three companies are doing, even if they are doing it with different tools, different rubrics, and different problem structures. They stopped testing whether you can produce code. They started testing whether you understand what you produce.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a64995b838b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NeetCode 250 vs. NeetCode 150: Are the Extra 100 Problems Worth It in 2027?]]></title>
            <link>https://medium.com/@codegrey/neetcode-250-vs-neetcode-150-are-the-extra-100-problems-worth-it-in-2027-a481d1f490b7?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/a481d1f490b7</guid>
            <category><![CDATA[neetcode-150]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[leetcode]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 04:49:49 GMT</pubDate>
            <atom:updated>2026-11-11T04:49:49.981Z</atom:updated>
            <content:encoded><![CDATA[<p>If you have been using NeetCode 150 as your prep foundation and recently noticed NeetCode 250 sitting on the same platform, you have probably asked a version of this question: what is actually in those extra 100 problems, and should you do them before your next interview?</p><p>The short answer is: it depends on exactly one thing. Not your target company, not the difficulty of your interviews, and not how much time you have. It depends on whether you are new to algorithms or whether you have a working foundation already.</p><p>The longer answer is worth understanding because NeetCode 250 is positioned as the most beginner-friendly list on neetcode.io, and using it as an experienced engineer chasing pattern coverage you are already missing is a different use case from what it was designed for.</p><h3>What NeetCode 250 actually is</h3><p>NeetCode 250 is NeetCode 150 plus 100 additional problems. Every problem in NeetCode 150 is included in NeetCode 250. The extra 100 are not a separate tier of difficulty or a new set of patterns. They are additional warm-up and reinforcement problems within the same 18 categories that NeetCode 150 already covers.</p><p>Navdeep Singh, who created both lists, describes NeetCode 250 as the most beginner-friendly list, intended for people completely new to algorithms. In his own words, he recommends NeetCode 250 over NeetCode 150 for most people specifically because the extra problems build pattern fluency before the harder problems arrive. This is the clearest possible signal about what the list is for.</p><p>Both lists are completely free on neetcode.io. NeetCode 250 does not require Pro. The comparison here is purely about which study plan fits your situation, not which one you can afford.</p><h3>How the two lists differ by category</h3><p>The 100 extra problems in NeetCode 250 are distributed across existing categories, not spread evenly. The categories that expand most significantly are the ones where pattern fluency requires more repetition: Two Pointers, Backtracking, Graphs, Heap, and 2D Dynamic Programming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/1*iwU1Kgd_8g95ecsinw5Eog.png" /></figure><p>The patterns that get the most reinforcement are Backtracking, 2D DP, Graphs, Trees, and 1D DP. These are also the patterns candidates most often feel shaky on after completing NeetCode 150, which is not a coincidence.</p><h3>Who should do NeetCode 250 over NeetCode 150</h3><p>Do NeetCode 250 if you are new to algorithms, switching careers into engineering, returning to interviews after several years away, or consistently finding that you can solve easy problems but feel unsteady entering medium territory. The extra problems are warm-up reps in the patterns where fluency requires more exposure than NeetCode 150 provides. They are not wasted if you need them.</p><p>Do NeetCode 150 if you have a working algorithms foundation, have interviewed before and know which specific patterns are weakest, or are working against a 4 to 6 week timeline. The<a href="https://medium.com/@codegrey/the-neetcode-study-schedule-that-works-for-people-with-full-time-jobs-88fd537dd2b7"> study schedule I use for full-time workers</a> is built around NeetCode 150 specifically because the timeline is realistic. Adding 100 problems to that schedule, most of which reinforce patterns you are already building, risks spreading prep time too thin before a deadline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*_nNkvmcNonCagP8KFurkKg.png" /></figure><h3>Is NeetCode 250 harder than NeetCode 150?</h3><p>No. The extra 100 problems in NeetCode 250 are generally at the same or easier difficulty level than the NeetCode 150 problems in the same categories. NeetCode 250 is wider, not harder. It gives you more reps at the medium level before the harder problems arrive, which is what “most beginner friendly” means in practice.</p><p>The hardest problems in NeetCode 250 are the same problems as the hardest problems in NeetCode 150, because NeetCode 150 is a complete subset of NeetCode 250. If you are looking for a harder list, NeetCode All has 973 problems as of August 2026, with 824 free and 149 Pro. But that is a different conversation from this one.</p><h3>The mistake engineers make with both lists</h3><p>The mistake is not choosing the wrong list. The mistake is treating either list as a problem count target rather than a pattern mastery target. I documented this in detail in<a href="https://medium.com/@codegrey/the-biggest-mistake-people-make-with-neetcode-150-58d93492d43a"> the biggest mistake people make with NeetCode 150</a> and the same mistake applies to NeetCode 250: solving 250 problems at shallow depth produces recognition without understanding. Solving 150 problems at genuine depth produces pattern fluency that transfers to problems you have never seen.</p><p>The<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> approach that actually builds pattern recognition</a> is not about the count. It is about the cycle: solve, explain out loud, revisit cold, extend to a variant. That cycle applied to 150 problems beats a passive run through 250.</p><p>If you have completed NeetCode 150 and are wondering whether to continue to 250 or move to something else,<a href="https://medium.com/@codegrey/i-completed-neetcode-150-blind-75-and-grind-75-heres-the-only-list-you-actually-need-fe5cf6e72088"> I covered exactly that decision</a> after completing all three major lists. The short version: additional problems are most valuable when you can identify a specific pattern gap. If you cannot name the gap, more problems are not the answer.</p><h3>Does NeetCode 250 cover everything you need for FAANG interviews?</h3><p>NeetCode 250 covers the same 18 pattern categories as NeetCode 150, with more reinforcement in each. Whether it is sufficient depends on the company.</p><p>For Amazon, Microsoft, and most mid-size product companies, NeetCode 250 provides comprehensive pattern coverage. The extra problems in Backtracking, Graphs, and DP are genuinely useful for companies that probe these categories deeply.</p><p>For Google, Meta, and other FAANG companies that push toward hard problems and novel variants, NeetCode 250 gives you the foundation but not the ceiling. The hardest problems in the loop at these companies sit above what NeetCode 250 typically reaches. You would use NeetCode 250 to build the pattern base and then push harder from there.</p><p>For Stripe, Atlassian, and companies using scenario-based formats, pattern volume matters less than implementation quality and the ability to extend a solution under changing constraints. In this case, NeetCode 150 done deeply, with deliberate practice on extending solutions mid-solve, is more targeted prep than NeetCode 250 done broadly.</p><h3>The practical recommendation</h3><p>Start with NeetCode 150 unless you are new to algorithms. If you finish NeetCode 150 before your timeline runs out and have identified specific patterns that still feel shaky, the NeetCode 250 extras in those categories are the most targeted way to add reps. Backtracking, 2D DP, and Graphs are the three categories most worth extending if you have the time.</p><p>If you are new to algorithms or have not interviewed in years, start with NeetCode 250 from the beginning. The extra warm-up problems in each category prevent the experience of arriving at a medium problem feeling like you have not had enough easy-problem reps to build the pattern instinct first.</p><p>For structured pattern learning alongside either list, Educative’s<a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096"> Grokking the Coding Interview</a> teaches the patterns before the problems, which pairs well with whichever list you choose. You use Grokking to understand why the pattern works, then NeetCode to drill it across a set of problems. The<a href="https://www.educative.io/interview-prep/coding?page=roadmap&amp;utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=interview_prep_coding_platform&amp;eid=5082902844932096"> interview prep coding platform</a> on Educative also has interactive problem-solving with Ask AI built into the coding widget, which is a different experience from solving on neetcode.io for candidates who want contextual hints without leaving the problem.</p><p>For converting whichever list you choose into actual interview performance, <a href="https://www.educative.io/mock-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=educatives_ai_mock_interviews&amp;eid=5082902844932096">Educative’s AI mock interviews</a> add the layer that no problem list provides: timed sessions with specific feedback on whether your reasoning is legible under pressure. The problem list determines what patterns you know. The mock interview determines whether you can demonstrate them when it counts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a481d1f490b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sliding Window and Two Pointers, Simplified: The Patterns You Actually Need]]></title>
            <link>https://medium.com/@codegrey/sliding-window-and-two-pointers-simplified-the-patterns-you-actually-need-70012cbe05f4?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/70012cbe05f4</guid>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[two-pointers]]></category>
            <category><![CDATA[sliding-windows]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 06:29:30 GMT</pubDate>
            <atom:updated>2026-11-10T06:29:30.869Z</atom:updated>
            <content:encoded><![CDATA[<p>These two patterns sit at the top of almost every interview frequency list. They are also the two patterns candidates most often confuse with each other, reach for at the wrong time, or understand well enough to solve a familiar problem but not well enough to adapt when the problem changes slightly.</p><p>If you have read<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> how I trained pattern recognition without memorization</a>, the approach here is the same: understand the structure of the pattern first, then the problems become applications of something you already understand rather than puzzles to decode. This piece does that specifically for sliding window and two pointers: what each one is actually doing, when to reach for which one, and how to work through a problem with each from first principles.</p><h3>What sliding window is actually doing</h3><p>The sliding window pattern is for problems that ask you about a contiguous subarray or substring. The insight behind it is that instead of recomputing everything from scratch each time you check a new window, you maintain a running state and update only what changes as the window moves.</p><p>There are two types, and knowing which one you are dealing with determines your implementation.</p><h4>Fixed-size windows</h4><p>The window size is given to you directly in the problem. “Find the maximum sum subarray of size k.” The window never changes size. It slides one step at a time and you add the incoming element and remove the outgoing element.</p><p>The implementation skeleton looks like this:</p><pre>def fixed_window(arr, k):<br>    window_sum = sum(arr[:k])<br>    best = window_sum<br>    for i in range(k, len(arr)):<br>        window_sum += arr[i] - arr[i - k]<br>        best = max(best, window_sum)<br>    return best</pre><p>The key operation is arr[i] — arr[i — k]: add the new element, subtract the one that just left. Everything else in the window is unchanged.</p><h4>Variable-size windows</h4><p>The window size is not given. You are looking for the smallest or largest window that satisfies a condition. “Find the longest substring without repeating characters.” The right pointer expands the window; the left pointer contracts it when the condition is violated.</p><pre>def variable_window(s):<br>    seen = {}<br>    left = 0<br>    best = 0<br>    for right in range(len(s)):<br>        if s[right] in seen and seen[s[right]] &gt;= left:<br>            left = seen[s[right]] + 1<br>        seen[s[right]] = right<br>        best = max(best, right - left + 1)<br>    return best</pre><p>The right pointer always moves forward. The left pointer only moves when the window violates the condition. The window size at any point is right — left + 1.</p><h4>How to recognize a sliding window problem</h4><p>The problem asks about a subarray or substring. It involves a contiguous range of elements. It asks for a maximum, minimum, or specific count within that range. The phrase “at most k” or “exactly k” or “no more than k” is often a direct signal. If the answer depends on a consecutive sequence, sliding window is almost always the right tool.</p><h3>What two pointers is actually doing</h3><p>Two pointers is for problems where you can move two indices toward each other or in the same direction to reduce the search space. The key insight is that sorting (when applicable) gives you a property you can exploit: if the sum of two elements is too large, move the right pointer left; if it is too small, move the left pointer right. This eliminates pairs you do not need to check without a nested loop.</p><p>There are two main configurations.</p><h4>Opposite ends (converging pointers)</h4><p>Start one pointer at the beginning and one at the end. Move them toward each other based on a condition. This is the pattern behind 3Sum, Container With Most Water, and Valid Palindrome.</p><pre>def two_sum_sorted(arr, target):<br>    left, right = 0, len(arr) - 1<br>    while left &lt; right:<br>        current = arr[left] + arr[right]<br>        if current == target:<br>            return [left, right]<br>        elif current &lt; target:<br>            left += 1<br>        else:<br>            right -= 1<br>    return []</pre><p>The array must be sorted (or sortable) for this to work. Sorting gives you the property that moving left rightward increases the sum and moving right leftward decreases it.</p><h4>Same direction (fast and slow pointers)</h4><p>Both pointers start at the beginning and move in the same direction at different speeds. This is the pattern behind detecting cycles in linked lists, removing duplicates in-place, and finding the middle of a list.</p><pre>def remove_duplicates(arr):<br>    if not arr:<br>        return 0<br>    slow = 0<br>    for fast in range(1, len(arr)):<br>        if arr[fast] != arr[slow]:<br>            slow += 1<br>            arr[slow] = arr[fast]<br>    return slow + 1</pre><p>The slow pointer marks the boundary of valid elements. The fast pointer scans ahead. When fast finds something new, slow advances and takes it.</p><h4>How to recognize a two-pointer problem</h4><p>The problem involves a sorted array or one you can sort. It asks about pairs, triplets, or comparisons between elements at different positions. It asks about palindromes, cycles, or duplicate removal. The brute force is O(n²) and you need O(n). If you find yourself imagining a nested loop that moves two indices independently based on a comparison, two pointers is almost certainly the pattern.</p><h3>The question that actually separates them</h3><p>When you open a problem and both patterns feel plausible, ask one question: is the answer about a contiguous range of elements, or about a relationship between specific elements at different positions?</p><p>If the answer depends on everything inside a window (a sum, a frequency count, a character set) that is sliding window. The elements in between matter.</p><p>If the answer depends only on the elements at the two pointer positions and how they compare to a target or to each other, that is two pointers. The elements in between do not matter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1008/1*KXda9GQAzMy8K-VXyn2gIw.png" /></figure><h3>A worked example: why Longest Substring Without Repeating Characters is not a two-pointer problem</h3><p>This is the problem candidates most often misclassify. It has two pointers in the implementation, so it looks like a two-pointer problem. It is not. It is a variable sliding window.</p><p>The reason: the answer depends on what is inside the window, not just on the two boundary values. When you detect a repeating character, the window must contract based on where that character was last seen, which requires tracking the internal contents of the window. Two pointers alone, without a data structure tracking the window’s contents, cannot solve this. The hash map storing character positions is part of the pattern.</p><p>The check that confirms it is sliding window: does the answer depend on elements between left and right? Yes. You need to know what characters are currently in the window to know whether to contract. Sliding window, not two pointers.</p><h3>A worked example: why 3Sum is not a sliding window problem</h3><p>3Sum asks for all unique triplets that sum to zero. Candidates who see “subarray” anywhere in a problem instinctively reach for sliding window. 3Sum is not asking about a subarray. It is asking about three specific elements at different positions that satisfy a relationship.</p><p>The approach: sort the array. Fix one element with an outer loop. Use converging two pointers on the remaining portion to find pairs that sum to the negative of the fixed element. Move the pointers based on whether the sum is too large or too small.</p><p>The check that confirms it is two pointers: does the answer depend on what is between the two boundaries? No. You only care about the values at the two pointer positions and how they compare to the target. Two pointers.</p><h3>The practice progression that builds both</h3><p>Start with fixed sliding window problems, which have the simplest state. Maximum sum subarray of size k is the canonical starting point. Then move to variable windows where the contraction condition is simple (no repeating characters). Then variable windows where the contraction condition requires tracking frequency (longest substring with at most k distinct characters, minimum window substring).</p><p>For two pointers, start with converging pointers on sorted arrays (Two Sum II). Then triplet problems after sorting (3Sum). Then same-direction problems for in-place operations and linked list problems.</p><p>The<a href="https://medium.com/@codegrey/neetcode-patterns-ranked-by-interview-frequency-4af039b57903"> NeetCode patterns ranked by interview frequency</a> confirms both patterns appear in the top tier of frequency across real interviews. They are worth the time it takes to internalize them completely rather than just recognize them. Educative’s<a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096"> Grokking the Coding Interview</a> covers both patterns with the same structure this piece uses: pattern definition, implementation template, worked problems, which makes it the natural next step if you want more worked examples beyond what is covered here. If you want to practice these patterns in an in-browser coding environment with AI hints built in, Educative’s<a href="https://www.educative.io/interview-prep/coding?page=roadmap&amp;utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=interview_prep_coding_platform&amp;eid=5082902844932096"> interview prep coding platform</a> has both patterns with interactive challenge widgets and an Ask AI feature that gives contextual help without breaking your flow.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70012cbe05f4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NeetCode 150 vs. Grokking the Coding Interview vs. Hello Interview: the 2026 comparison]]></title>
            <link>https://medium.com/@codegrey/neetcode-150-vs-grokking-the-coding-interview-vs-hello-interview-the-2026-comparison-989702abf90c?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/989702abf90c</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <category><![CDATA[data-structures-algorithm]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 09:13:28 GMT</pubDate>
            <atom:updated>2026-10-26T09:13:28.157Z</atom:updated>
            <content:encoded><![CDATA[<p>This comparison comes up constantly in prep communities, and most of the answers treat the three as interchangeable resources competing for the same job. They are not. They solve different problems at different stages of preparation, and understanding that distinction is more useful than a ranked list.</p><p>Here is what each one actually is, what it costs right now, where it is genuinely strong, and the specific situations where it will let you down.</p><h3>What you need to know before comparing</h3><p>One important clarification that almost no comparison gets right: when people say “Grokking the Coding Interview,” they might mean two different things. The original Grokking course was created on Educative, but the original authors subsequently moved to their own platform at designgurus.io and publish there now. Educative has written its own replacement version, which is what you get at educative.io. Both carry the “Grokking” name in various forms. For this comparison I am covering Educative’s version, which is the one you encounter on the Educative platform. If you want the original authors’ course, that is at Design Gurus, and the price and content structure differ.</p><h3>NeetCode 150</h3><h4>What it is</h4><p>NeetCode is primarily a practice platform built around problem lists and video solutions. The NeetCode 150 organizes problems into 15 categories : arrays, two pointers, sliding window, stack, binary search, linked list, trees, tries, heap, backtracking, graphs, advanced graphs, dynamic programming, greedy, intervals, and math, with a clear video walkthrough for each problem by Navdeep Singh. The free tier covers the entire 150-problem list with videos and in-browser practice.</p><p>The free tier is genuinely excellent. A disciplined candidate can pass FAANG interviews using only the free version. This is not marketing copy. It is the honest reason I have recommended it in<a href="https://medium.com/@codegrey/leetcode-vs-neetcode-which-one-helps-more-in-real-interviews-7767598db912"> more than one comparison I’ve done before</a>.</p><h4>Pricing</h4><p>NeetCode Pro costs $119 per year or $297 for lifetime access, verified August 6, 2026. There is no monthly plan. Pro adds 11 structured courses, company-tagged problems, NeetBot AI hints, AI mock interviews, and cloud sync. The free roadmap already covers the core problem list; Pro earns its price mainly for beginners who want the structured courses or candidates who will actually use the AI mock interviews consistently.</p><h4>Where it is strongest</h4><p>Video explanation quality. When you are stuck on a problem and need to see someone think through it, Navdeep’s walkthroughs are consistently clear and among the best in this space. The 150-problem scope is also well-calibrated: comprehensive enough to cover the major patterns, focused enough to finish in a realistic timeline.</p><p>For the full story on what the NeetCode 150 actually produces and where the method breaks down,<a href="https://medium.com/@codegrey/i-grinded-neetcode-150-so-you-dont-have-to-218cfa405154"> I grinded NeetCode 150 so you don’t have to</a> covers the honest post-mortem.</p><h4>Where it falls short</h4><p>NeetCode groups problems by topic, but you still learn primarily by solving rather than by being taught the pattern first. The pattern is the index, not the curriculum. For candidates who need the pattern explained conceptually before they can absorb the problems, the learning sequence is backwards. You solve problems and eventually internalize the pattern rather than starting with the pattern and applying it.</p><p>The AI mock interview in Pro gives you reps at talking while coding, which no reading or watching replaces. But it is not a substitute for a realistic full-loop simulation with feedback on behavioral and <a href="https://www.educative.io/courses/grokking-the-system-design-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=system_design_rounds&amp;eid=5082902844932096">system design rounds</a>.</p><h3>Grokking the Coding Interview (Educative)</h3><h4>What it is</h4><p><a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096">Grokking the Coding Interview</a> on Educative is a course, not a problem list. It teaches 42 patterns (32 common and 10 advanced) across 50 chapters and 669 lessons. Each chapter introduces a pattern: what it is, when to recognize it, what the implementation template looks like. Then it walks through hand-picked problems that apply the pattern. This is the opposite of NeetCode’s sequence: pattern first, then problems.</p><p>The in-browser coding environment means you practice directly inside the course without switching to a separate platform. The course is text-based rather than video-based, which is the right format for some learners and the wrong format for others.</p><h4>Pricing</h4><p>Educative operates on a subscription model. The list price is roughly $200 per year, but discount codes that bring it to $80 to $100 circulate widely. Access ends when the subscription ends, which is worth factoring into the lifetime value calculation if you plan to return to the material across multiple interview seasons.</p><h4>Where it is strongest</h4><p>Pattern depth and sequencing. If you have ever solved a problem from a solution you read, understood it in the moment, and then could not reconstruct it the next day, Grokking’s structure addresses that directly. By teaching the pattern as a named, structured concept first, the problems become applications of something you already understand rather than mysteries to decode. This is the approach I described in<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> NeetCode without memorization</a>: building reasoning structures rather than solution recall.</p><p>For text-based learners who retain information better from reading than from watching, Educative’s format is a genuine advantage over NeetCode. For the pattern-learning phase specifically, it is the most thorough resource available at this price point.</p><p>The AI layer built into the platform is also more integrated than most candidates realise before they use it. Every coding challenge has an AI-powered debugger: you run your code, get specific feedback, and receive hints when something is off, without switching tabs or losing context. Within lessons, an “Ask AI” feature lets you ask follow-up questions on the exact concept you are reading, and “Explain with AI” breaks down ideas in clearer terms when you are stuck. This is meaningfully different from pasting code into a chat window, because the AI has the lesson context already.</p><p>Educative also has AI mock interviews covering coding, system design, API design, and object-oriented design, with over 50 practice questions and post-session feedback. These are AI-guided rather than human-led, but they are a real practice layer rather than just content.</p><h4>Where it falls short</h4><p>Quality is inconsistent outside the core courses. The Grokking material is strong. Content beyond it varies. If you are paying for a broad Educative subscription hoping to cover everything in one place, verify the specific courses you need before committing.</p><p>The subscription model also means access ends when you stop paying. If you plan to return to the material across multiple interview seasons, the lifetime value calculation matters more than the monthly price.</p><h3>Hello Interview</h3><h4>What it is</h4><p>Hello Interview is a system-design-first interview prep platform built specifically for engineers at large tech companies. It is organized around interview rounds rather than subject areas: System Design (31 problems), Low-Level Design (12), Coding (16), Behavioral (9), AI Coding (20), and Code Review (8). The Guided Practice feature steps you through system design problems interactively with AI feedback on your response quality.</p><p>One important 2026 change: Hello Interview wound down its live 1:1 human mock interviews on May 31, 2026. The platform is now AI-guided practice rather than human coaching.</p><h4>Pricing</h4><p>Pricing verified August 9, 2026: $47 per month (non-auto-renewing), $79 per year, $279 lifetime. The free tier includes “System Design in a Hurry” , partially accessible without payment, and one free Guided Practice problem. Check the current pricing page before purchasing, as promotional pricing has appeared alongside list prices.</p><h4>Where it is strongest</h4><p>System design, specifically. If system design is the round that will determine your outcome , which it is for most senior and above candidates, Hello Interview’s coverage is the most structured available at this price. The Guided Practice questions for system design are built around the specific format and depth interviewers expect, and the step-by-step feedback is closer to what you would get from a coaching session than what you get from reading a case study.</p><p>The free “System Design in a Hurry” track is genuinely worth reading before your onsite even if you do not pay. The Redis deep dive alone (single-threaded execution model, cluster hash slots, eviction policies, when Redis is the wrong answer) is better than most paid material on the same topic.</p><h4>Where it falls short</h4><p>DSA coverage is thin by design. Hello Interview’s coding section covers around 80 problems across 16 patterns. If raw algorithm volume is your bottleneck, this is not the right primary tool. It is not trying to be NeetCode or Grokking, and treating it as a substitute for those will leave you underprepared for coding rounds.</p><p>The loss of human mock interviews in May 2026 is also significant. The AI tutor is a Q&amp;A tool, not an interview simulator. It cannot replicate the real pressure of a timed session with a watching presence. For engineers whose primary preparation gap is performance under pressure rather than knowledge, this is a meaningful limitation.</p><h3>The comparison at a glance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*F1A0AsG6ZR37sVfR3Rzi5g.png" /></figure><h3>Who should use which, and when</h3><p>Use NeetCode 150 as your primary DSA resource if you are a video learner who needs pattern exposure through solving. Start with the free tier. Most candidates do not need Pro. The<a href="https://medium.com/@codegrey/i-completed-neetcode-150-blind-75-and-grind-75-heres-the-only-list-you-actually-need-fe5cf6e72088"> list comparison I did across Blind 75, NeetCode 150, and Grind 75</a> covers why NeetCode 150 is the right starting point for most engineers.</p><p>Use <a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096">Grokking the Coding Interview</a> on Educative if you are a text learner or if you keep solving problems correctly but cannot reconstruct the approach the next day. The pattern-first structure fixes the specific gap that random problem grinding does not. The integrated AI features, Ask AI within lessons, Explain with AI, and the AI debugger inside every coding widget, mean you get contextual help without switching tabs, which keeps the learning loop tighter than NeetCode’s video-then-practice sequence. Educative’s AI mock interviews also cover coding, system design, and OOD, so the performance practice layer is available without a separate tool, though how far you want to rely on it versus something more realistic is worth evaluating against your specific gaps.</p><p>Use Hello Interview if you are targeting a senior or staff role where system design is the deciding round. It is not a replacement for either of the above. It is what you add after your DSA foundation is solid. The $79 annual price for system design coverage alone is reasonable; the free tier is worth reading regardless.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=989702abf90c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Amazon’s Bar Raiser Round, Decoded: What Actually Happens in 2026]]></title>
            <link>https://medium.com/@codegrey/amazons-bar-raiser-round-decoded-what-actually-happens-in-2026-3fe2d75e5d84?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fe2d75e5d84</guid>
            <category><![CDATA[technical-interview]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[amazon]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 09:08:00 GMT</pubDate>
            <atom:updated>2026-10-26T09:08:00.213Z</atom:updated>
            <content:encoded><![CDATA[<p>Most engineers preparing for Amazon focus almost all their time on coding and system design and treat the <a href="https://www.educative.io/courses/grokking-the-behavioral-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=behavioral_rounds&amp;eid=5082902844932096">behavioral rounds</a> as a warmup they will figure out at the end. That is the wrong model for Amazon specifically, and it is the reason candidates with strong technical scores leave the loop without an offer more often at Amazon than at any other FAANG company.</p><p>The Bar Raiser is why. Understanding what it is, what it is actually measuring, and how the entire Amazon loop is structured around it will change how you allocate your preparation time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7phlXV6-fegk7NcqL3gcqQ.jpeg" /></figure><h3>What the Amazon loop actually looks like in 2026</h3><p>Amazon’s process has two distinct stages before you reach an offer.</p><h4>The online assessment</h4><p>The OA arrives as a timed link in your inbox before any human conversation. Most candidates focus entirely on the coding section. That is a mistake, because the OA has four components and all of them are scored.</p><p>The coding section is two problems at medium difficulty, 90 minutes total. Nothing exotic here. LeetCode medium patterns, with a focus on correctness and clean code rather than maximum optimization.</p><p>The debugging section is 6 to 8 short code snippets, each containing exactly one bug. The bugs are almost never algorithmic failures. They are logic errors: an off-by-one, a wrong operator, a flipped condition, an uninitialised variable. The strategy is to read the snippet, run it mentally against the expected output, and find where the behavior diverges. Candidates who try to rewrite snippets lose time and marks. Find the bug, fix the bug, move on.</p><p>The work simulation drops you into a simulated Amazon workday: inbox messages, ticket queues, dashboards, a teammate whose data contradicts yours, a deadline that cannot be met as scoped. There is rarely one right answer. The house style is consistent: start from the customer, insist on data, escalate honestly rather than quietly absorbing risk, take ownership. These scenarios are behavioral questions in disguise, and they are scored against the <a href="https://www.educative.io/blog/aws-leadership-principles?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=leadership_principles&amp;eid=5082902844932096">Leadership Principles</a>.</p><p>The work style assessment is a survey of how you prefer to work. It is not a lie detector but it is scored, and answers that pattern-match poorly against Amazon’s leadership culture affect borderline candidates.</p><h4>The virtual onsite loop</h4><p>The onsite is 4 to 5 rounds, all virtual, typically across one day. The structure varies by level but the consistent elements in 2026 are:</p><p>One or two coding rounds with DSA problems at medium to hard difficulty. Problems are tested live with an interviewer watching, which means your ability to think out loud matters as much as your ability to solve. I covered this in the<a href="https://medium.com/@codegrey/the-contradiction-nobody-talks-about-why-the-companies-building-ai-still-test-you-on-dsa-b5006b6204e1"> piece on DSA at companies building AI</a>: Amazon still tests algorithms seriously, but what the interviewer is watching for is engineering judgment, not raw pattern recall.</p><p>One system design round for SDE II and above. For SDE I, this is replaced by an object-oriented design or low-level design question. System design prompts at Amazon skew toward real Amazon infrastructure: design a URL shortener, a shopping cart, a real-time leaderboard, a rate limiter for an API. Be ready to discuss load balancing, caching, sharding, and the latency versus throughput tradeoff.</p><p>One GenAI fluency round, added in 2024 and now present in most SDE II and above loops. This is not a coding round. A typical prompt describes a RAG pipeline scenario for internal documentation retrieval and asks you to walk through tradeoffs: chunking strategy, embedding model selection, retrieval approach, guardrails for hallucination. One SDE II candidate reported being pushed hard on why they made specific architectural choices, not just what those choices were. If you cannot explain why RAG is appropriate for a given use case, or what the failure modes of a particular guardrail strategy look like, this round will be uncomfortable.</p><p>One Bar Raiser round, embedded somewhere in the loop without you being told which one it is.</p><h3>What the Bar Raiser actually is</h3><p>The Bar Raiser is a trained Amazon interviewer from a completely different team and organization than the one you are interviewing for. If you are interviewing for a Prime Video role, the Bar Raiser might be from AWS. They have no stake in whether your team gets a hire. Their job is to maintain or raise Amazon’s company-wide engineering bar, not optimize for a team’s immediate headcount need.</p><p>They have veto power. If every other interviewer votes Hire and the Bar Raiser votes No Hire, you do not get an offer. The veto is not a formality.</p><p>You will not be told which round the Bar Raiser is in. Amazon does this deliberately. The correct response is to treat every interviewer as if they might be the Bar Raiser, because they might.</p><p>The Bar Raiser round runs almost entirely behavioral in practice. They probe Leadership Principles with more depth than any other interviewer in the loop. They will ask follow-up questions until they can separate your personal contribution from team momentum. “What was the specific metric?” and “What would you do differently?” are standard Bar Raiser moves. The goal is to find where your evidence stops being specific and starts being general.</p><h3>How behavioral questions work across the entire Amazon loop</h3><p>This is the structural difference most candidates miss. At Meta, behavioral questions are siloed into a dedicated round. At Amazon, every round has behavioral questions woven in.</p><p>Your coding interviewer will ask about Invent and Simplify after your solution is written. Your system design interviewer will probe Deliver Results before the technical discussion begins. The Bar Raiser will go deep on Customer Obsession and Ownership. Every round follows a similar skeleton: 15 to 30 minutes of LP-tied behavioral questions, then 30 to 45 minutes of technical work.</p><p>The Leadership Principles were updated in mid-2023 to 16 total, adding “Strive to be Earth’s Best Employer” and “Success and Scale Bring Broad Responsibility.” Every loop is built around the current list of 16. Coverage gaps in Customer Obsession and Ownership are now the most common reason for Bar Raiser veto, according to multiple independent candidate reports from 2026.</p><p>There is also a new behavioral question that has appeared in virtually every Amazon loop in 2026 and can come from any interviewer: “Tell me about a time you used or chose not to use AI tools in your engineering work.” The Bar Raiser is more likely than not to ask this. Amazon has not published a scoring guide for it, but the pattern in candidate reports is consistent: answers that show engineering judgment about when AI helps and when it introduces risk perform better than either blanket enthusiasm for AI or blanket skepticism about it.</p><h3>What the Bar Raiser is actually evaluating</h3><p>The Bar Raiser is not primarily evaluating your coding score. They are evaluating whether your evidence, across the whole loop, is consistent with someone who should be hired at Amazon’s company-wide bar for your level.</p><p>The two most common failure modes, based on 2026 candidate reports, are thin coverage and borrowed credit.</p><p>Thin coverage means your behavioral stories collectively cover only a few Leadership Principles well and leave obvious gaps. A candidate with brilliant Bias for Action stories and brilliant Invent and Simplify stories but only generic Customer Obsession answers is at meaningful risk, because Customer Obsession is the first principle for a reason.</p><p>Borrowed credit means your stories consistently feature “we” without enough “I.” The Bar Raiser probes this specifically. If you describe a project outcome but cannot isolate exactly what you decided, what you built, and what result you personally caused, the story loses signal. The follow-up “what was your specific role in that decision?” is designed to find exactly this gap.</p><h3>How to prepare for the loop</h3><h4>For the DSA rounds</h4><p>The bar is medium to hard on LeetCode-style problems.<a href="https://medium.com/@codegrey/neetcode-patterns-ranked-by-interview-frequency-4af039b57903"> NeetCode patterns ranked by interview frequency</a> gives you the prioritized list. Arrays, strings, trees, graphs, dynamic programming, and hash tables are all live. Educative’s<a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096"> Grokking the Coding Interview</a> covers the pattern-first learning structure that transfers better to novel problems than grinding individual solutions does.</p><p>The habit that matters most in live coding is thinking out loud. A silent candidate reads as a struggling one at Amazon specifically, because every coding round has an LP lens attached to it. Narrating your reasoning while you code is both a communication habit and an Invent and Simplify signal at the same time.</p><h4>For behavioral</h4><p>Prepare 6 to 8 rich stories from real past experience that collectively cover all 16 Leadership Principles. Two stories per principle gives you flexibility when an interviewer probes a specific angle you had not anticipated. Every story should include a specific metric in the result. “Reduced API latency by 40%” is a story. “Improved system performance” is not.</p><p>For the AI tool usage question specifically, prepare a specific example with a concrete judgment call, a time you used AI and it helped, a time you chose not to and why, or a time AI output led you somewhere wrong and you caught it. Vague enthusiasm for AI tools reads as thin signal.</p><h4>For the GenAI fluency round</h4><p>Study RAG architecture at a working level: chunking and tokenization decisions, embedding model tradeoffs, retrieval strategies (dense vs sparse, hybrid), evaluation methods for retrieval quality, hallucination mitigation approaches. The round evaluates whether you can reason about generative AI systems in production and explain your architectural choices under follow-up pressure, not whether you can derive backpropagation.</p><h4>For full loop practice</h4><p><a href="https://www.mockinterviews.dev/">mockinterviews.dev</a>, built by ex-MAANG engineers and powered by Educative, runs complete interview loops including behavioral rounds with LP-specific feedback. The behavioral feedback is the part most candidates cannot get from solo practice, and it is exactly what the Bar Raiser evaluates most heavily. Getting specific feedback on whether your stories have sufficient depth and personal attribution is the most efficient investment for the round that has veto power.</p><h3>The thing about the Bar Raiser that most prep guides miss</h3><p>The Bar Raiser is not an obstacle at the end of the loop. It is a calibration mechanism running through the entire loop. Every interviewer is potentially the Bar Raiser. Every round has a behavioral component. Every answer is contributing to a composite picture of whether you are operating at the level Amazon expects.</p><p>The candidates who navigate this well are not the ones who save their best LP stories for the round they think is the Bar Raiser. They are the ones who tell specific, evidence-based, personally attributed stories with concrete outcomes in every round, so that whichever interviewer is actually the Bar Raiser sees the same depth regardless of which round they are running.</p><p>Preparation for Amazon that treats behavioral as secondary to technical is misallocated preparation. The technical bar is real. The behavioral bar is what the Bar Raiser controls. Treat them as equally important and your prep will reflect how Amazon actually makes hiring decisions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fe2d75e5d84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 15-Problem Method: The Coding Interview Problems That Matter Most]]></title>
            <link>https://medium.com/@codegrey/the-15-problem-method-the-coding-interview-problems-that-matter-most-501abd48b700?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/501abd48b700</guid>
            <category><![CDATA[leetcode]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 08:35:31 GMT</pubDate>
            <atom:updated>2026-10-20T08:35:31.988Z</atom:updated>
            <content:encoded><![CDATA[<p>I finished Blind 75 in three weeks and felt confident.</p><p>Then I bombed a Google interview.</p><p>The problem wasn’t that I hadn’t solved enough problems. It was that I’d spent three weeks solving problems and two hours actually understanding them. I could recognize patterns on sight but couldn’t explain why they worked. I could code the solution but would freeze when the interviewer added a constraint I hadn’t drilled.</p><p>So I did something I probably should have done before that failed interview: I cross-referenced Blind 75, NeetCode 150, and Grind 75 to find what every curated list agrees on. Not the lists themselves, but the signal underneath them. Fifteen problems appear across all three. The same 15. And if you master them, truly master them, not just solve them, you’ve covered what the entire coding interview community agrees on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yndrf1-CA1eNn0VFzLmjoA.jpeg" /></figure><h3>Why three lists converge on 15 problems</h3><p>Blind 75 was released in 2020. NeetCode 150 came out in 2022. Grind 75 is maintained and updated. The fact that they converge on the same 15 problems despite being created at different times, by different people, with different philosophies, is the strongest possible signal.</p><p>When I looked at my mentee’s prep schedule last month, she was on problem 47 of Blind 75. I asked her to explain Two Sum. She could code it in under two minutes. But when I asked “why does the hash map approach work here specifically, not in other array problems?” she paused.</p><p>That pause is where most people lose interviews. The culprit isn’t the lists. The culprit is the narrative around them: solve more, faster. Finish the 75. Then do the 150. Then do Grind 75. For people interviewing in 4 to 6 weeks, which is most of you, the math doesn’t work. You run out of time, panic, skip the hard problems, and show up to interviews recognizing patterns without understanding them.</p><p>When I pull the three lists and look for problems appearing in all three simultaneously, 15 come back. They span 12 categories: 6 easy, 7 medium, 2 hard. They represent the <a href="https://www.youtube.com/watch?v=TBBkiWRE9Zk">foundational patterns</a> that branch into 60% or more of what you’ll see across FAANG interviews. Three independent lists, created at different times by different people, all surfaced the same 15. That’s not coincidence. Fahim ul Haq’s<a href="https://www.educative.io/blog/blind-75-vs-leetcode-patterns-for-google-coding-interviews?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=blind_75_vs_leetcode_patterns_analysis_for_google_interviews&amp;eid=5082902844932096"> Blind 75 vs LeetCode patterns analysis for Google interviews</a> arrives at the same conclusion from a different angle: the overlap is the signal, not the noise.</p><p>If you want the full breakdown of how the three lists compare, I did that in<a href="https://medium.com/@codegrey/i-completed-neetcode-150-blind-75-and-grind-75-heres-the-only-list-you-actually-need-fe5cf6e72088"> I completed NeetCode 150, Blind 75, and Grind 75</a>. The short version: they’re different views of the same underlying patterns.</p><h3>The 15 problems: The canonical list</h3><h4>1. Two Sum</h4><p><strong>Category:</strong> Arrays &amp; Hashing</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> The foundation. Hash table pattern unlocks 40+ related problems.</p><p><a href="https://www.educative.io/interview-prep/coding/two-sum?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=two_sum&amp;eid=5082902844932096">Two Sum</a></p><h4>2. Valid Parentheses</h4><p><strong>Category:</strong> Stack</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> Stack mechanics. Used in parsing, recursion recognition.</p><p><a href="https://www.educative.io/interview-prep/coding/valid-parentheses?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=valid_parentheses&amp;eid=5082902844932096">Valid Parentheses</a></p><h4>3. Merge Two Sorted Lists</h4><p><strong>Category:</strong> Linked List</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> Linked list pointer manipulation. Appears in merge sort and list operations.</p><p><a href="https://www.educative.io/interview-prep/coding/merge-two-sorted-lists?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=merge_two_sorted_lists&amp;eid=5082902844932096">Merge Two Sorted Lists</a></p><h4>4. Best Time to Buy and Sell Stock</h4><p><strong>Category:</strong> Sliding Window</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> Single-pass optimization. Teaches you to think about state across iteration.</p><p><a href="https://www.educative.io/interview-prep/coding/best-time-to-buy-and-sell-stock?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=best_time_to_buy_and_sell_stock&amp;eid=5082902844932096">Best Time to Buy and Sell Stock</a></p><h4>5. Climbing Stairs</h4><p><strong>Category:</strong> Dynamic Programming</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> DP foundation. How to recognize overlapping subproblems.</p><p><a href="https://www.educative.io/interview-prep/coding/climbing-stairs?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=climbing_stairs&amp;eid=5082902844932096">Climbing Stairs</a></p><h4>6. Contains Duplicate</h4><p><strong>Category:</strong> Arrays &amp; Hashing</p><p><strong>Difficulty:</strong> Easy</p><p><strong>Why it matters:</strong> Hash set pattern. When to use sets vs maps.</p><p><a href="https://www.educative.io/interview-prep/coding/contains-duplicate?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=contains_duplicate&amp;eid=5082902844932096">Contains Duplicate</a></p><h4>7. Maximum Subarray</h4><p><strong>Category:</strong> Greedy</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> Greedy reasoning. When to use greedy vs DP.</p><p><a href="https://www.educative.io/interview-prep/coding/maximum-subarray?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=maximum_subarray&amp;eid=5082902844932096">Maximum Subarray</a></p><h4>8. Longest Substring Without Repeating Characters</h4><p><strong>Category:</strong> Sliding Window</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> Advanced sliding window. State management with constraints.</p><p><a href="https://www.educative.io/interview-prep/coding/longest-substring-without-repeating-characters?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=longest_substring_without_repeating_characters&amp;eid=5082902844932096">Longest Substring Without Repeating Characters</a></p><h4>9. 3Sum</h4><p><strong>Category:</strong> Two Pointers</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> Pointer movement after sorting. Two sum + constraint.</p><p><a href="https://www.educative.io/interview-prep/coding/3sum?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=3sum&amp;eid=5082902844932096">3Sum</a></p><h4>10. Binary Tree Level Order Traversal</h4><p><strong>Category:</strong> Trees</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> BFS on trees. Queue-based traversal.</p><p><a href="https://www.educative.io/interview-prep/coding/binary-tree-level-order-traversal?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=binary_tree_level_order_traversal&amp;eid=5082902844932096">Binary Tree Level Order Traversal</a></p><h4>11. Min Stack</h4><p><strong>Category:</strong> Stack</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> Stack with extra tracking. Design patterns.</p><p><a href="https://www.educative.io/interview-prep/coding/min-stack?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=min_stack&amp;eid=5082902844932096">Min Stack</a></p><h4>12. Number of Islands</h4><p><strong>Category:</strong> Graphs</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> DFS/BFS pattern on grids. Union-find alternative.</p><p><a href="https://www.educative.io/interview-prep/coding/number-of-islands?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=number_of_islands&amp;eid=5082902844932096">Number of Islands</a></p><h4>13. Search in Rotated Sorted Array</h4><p><strong>Category:</strong> Binary Search</p><p><strong>Difficulty:</strong> Medium</p><p><strong>Why it matters:</strong> Binary search variant. When binary search still applies.</p><p><a href="https://www.educative.io/interview-prep/coding/search-in-rotated-sorted-array?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=search_in_rotated_sorted_array&amp;eid=5082902844932096">Search in Rotated Sorted Array</a></p><h4>14. Minimum Window Substring</h4><p><strong>Category:</strong> Sliding Window</p><p><strong>Difficulty:</strong> Hard</p><p><strong>Why it matters:</strong> Complex sliding window state. Most advanced of the three sliding window problems.</p><p><a href="https://www.educative.io/interview-prep/coding/minimum-window-substring?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=minimum_window_substring&amp;eid=5082902844932096">Minimum Window Substring</a></p><h4>15. Binary Tree Maximum Path Sum</h4><p><strong>Category:</strong> Trees</p><p><strong>Difficulty:</strong> Hard</p><p><strong>Why it matters:</strong> Tree DP. Tracking state across recursive calls.</p><p><a href="https://www.educative.io/interview-prep/coding/binary-tree-maximum-path-sum?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=binary_tree_maximum_path_sum&amp;eid=5082902844932096">Binary Tree Maximum Path Sum</a></p><p>Each problem name links to Educative’s<a href="https://www.educative.io/interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=interview_prep_platform&amp;eid=5082902844932096"> interview prep platform</a>, where you can solve them interactively without leaving your browser.</p><h3>How to actually study these 15</h3><p>Here’s where most people mess up. They solve the problem, check it off, and move to the next one. That’s not studying, that’s checking a box.</p><p>Real mastery looks like this.</p><h4>Week 1 to 2: The initial solve (per problem: 3 to 4 hours across 2 days)</h4><p>Solve it once without looking at solutions. Get it working, even if it’s slow. Then solve it again using the optimal approach. Then solve it a third way. Every problem has multiple valid approaches.</p><p>Example: Two Sum can be solved with brute force (O(n²)), sorting plus two pointers (O(n log n)), or hash map (O(n)). Understand when each matters.</p><h4>Week 2 to 3: Teaching and explaining (per problem: 2 hours)</h4><p>Explain the solution out loud as if you’re in an interview. Record yourself or explain to a peer. Write down the intuition in plain English, not code comments. Identify the moment where the pattern matters. For Two Sum, it’s “I need to check if complement exists. Hash map is O(1) lookup.”</p><p>This is the core shift I described in<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> NeetCode without memorization</a>: stop treating problems as solutions to memorize and start treating them as reasoning structures to internalize. Educative’s<a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096"> Grokking the Coding Interview</a> is built around this exact principle, pattern first then problems, which makes it a natural companion for this phase of the method.</p><h4>Week 3 to 4: Variants and edge cases (per problem: 3 to 4 hours)</h4><p>Find 3 to 5 related problems that use the same pattern. Example for Two Sum: Two Sum IV (on BST), Two Sum II (sorted array), Two Sum III (design). Solve two without looking at your notes. Notice how the core pattern stayed the same but the context changed.</p><h4>Week 4 and beyond: Revisit and defend (per problem: 1 to 2 hours after 1 week)</h4><p>Come back after a week and solve it cold, from scratch, without notes. Be honest about what you forgot. That’s the gap you need to fill. This is where active recall matters.<a href="https://fenzo.ai/"> Fenzo</a> is worth using here specifically: you input the pattern, ask it to quiz you on it, and it generates retrieval-based sessions that test whether you can produce the reasoning rather than just recognize it.</p><h3>The 4-week schedule</h3><p>Week 1: Two Sum, Valid Parentheses, Merge Two Sorted Lists, Best Time to Buy and Sell Stock</p><p>Week 2: Climbing Stairs, Contains Duplicate, Maximum Subarray, Longest Substring Without Repeating Characters</p><p>Week 3: 3Sum, Binary Tree Level Order Traversal, Min Stack, Number of Islands</p><p>Week 4: Search in Rotated Sorted Array, Minimum Window Substring, Binary Tree Maximum Path Sum</p><p>Week 5 and beyond: Revisit all 15. Solve related problems. Do mock interviews.</p><p>This isn’t a fast schedule. It’s a complete one. You’ll finish it confident rather than just finished.</p><p>If you want a structured daily pacing tool rather than managing this yourself, Grind 75’s customizable schedule is built for exactly this. I changed my mind about it for precisely that reason, and wrote about why in<a href="https://medium.com/@codegrey/i-used-to-think-grind-75-was-a-waste-of-time-not-anymore-6ecc5e239877"> I used to think Grind 75 was a waste of time</a>. The schedule is the product, not the problem list.</p><h3>Why this works (when just grinding doesn’t)</h3><p>Three reasons this approach beats “finish the list.”</p><p>You build mental models, not pattern matching. When you solve Two Sum three different ways, you don’t memorize the hash map solution. You understand why hash maps matter for this problem. That reasoning transfers to Two Sum II, to Pair With Target Difference, to any problem where you need fast lookups. Pattern matchers freeze when they see an unfamiliar problem. People with mental models see the underlying structure.</p><p>You spend time on what matters. The two hardest problems in the list, Minimum Window Substring and Binary Tree Maximum Path Sum, separate good candidates from great ones. They’re not harder because they use different patterns. They’re harder because they combine patterns in ways that require tracking multiple states simultaneously. Most people skip them because they’re chasing problem count. I documented exactly this failure mode in<a href="https://medium.com/@codegrey/i-grinded-neetcode-150-so-you-dont-have-to-218cfa405154"> I grinded NeetCode 150 so you don’t have to</a>: volume without depth produces recognition without understanding.</p><p>You’re prepared for variations, not just memorized questions. An interviewer at Meta asked my mentee a problem I’d never seen before: find the maximum profit if you can buy and sell stock twice. She’d memorized Best Time to Buy and Sell Stock. Except the new problem wasn’t different. It was the same problem, twice. She solved it in 15 minutes because she understood the pattern. That happens when you go deep on 15 instead of shallow on 150.</p><h3>The questions you’re asking</h3><p>“But what if my company asks a problem not on this list?”</p><p>They might. But if you truly master these 15, you’ve built the pattern recognition that lets you approach any problem. I’ve seen candidates solve problems they’d never seen before because they could identify which of the 15 patterns it connected to.</p><p>“Is 4 weeks realistic?”</p><p>Yes, if you work at it daily. Most people prep for 1 to 2 hours a day. This schedule assumes 1 to 1.5 hours per problem plus daily review. If you have less time, prioritize the 6 easy problems first, then medium, then hard. If you want to understand how platform choice affects your prep,<a href="https://medium.com/@codegrey/leetcode-vs-neetcode-which-one-helps-more-in-real-interviews-7767598db912"> LeetCode versus NeetCode</a> covers the structural differences.</p><p>“Should I do this instead of Blind 75, or in addition to it?”</p><p>Instead of. If you finish these 15 deeply and have time left, then add more problems. Most people don’t have time left.</p><h3>What actually changes when you do this</h3><p>You stop worrying about how many problems you’ve solved and start worrying about how well you’ve solved them. In interviews, you explain your reasoning instead of just coding. When an interviewer asks “What if we changed X constraint?” you can think through the implications instead of panicking.</p><p>I’ve watched this play out 40 or more times with people I’ve mentored. The ones who did the 15 problems deeply passed at a 75% rate. The ones who chased Blind 75 completion passed at 35%. That’s the difference between understanding and memorizing.</p><p>For full-loop practice once you’ve completed the 15,<a href="https://www.mockinterviews.dev/"> mockinterviews.dev</a>, built by ex-MAANG engineers and powered by Educative, runs complete interview simulations with feedback specific enough to tell you which patterns still need work. And Educative’s<a href="https://www.educative.io/interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=personalized_interview_prep&amp;eid=5082902844932096"> personalized interview prep</a> lets you continue practicing the same 15 problems interactively with real coding environments built in.</p><p>The lists aren’t competing. They’re converging. Three different curators, three different philosophies, all surfaced the same 15 problems. That convergence is the signal. Your job isn’t to pick a list. Your job is to find the signal and go deeper.</p><p>These are the 15.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=501abd48b700" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Long Does ‘Interview Ready’ Actually Last? I Stopped Practicing for 60 Days to Find Out]]></title>
            <link>https://medium.com/@codegrey/how-long-does-interview-ready-actually-last-i-stopped-practicing-for-60-days-to-find-out-d968b23ba7a4?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d968b23ba7a4</guid>
            <category><![CDATA[leetcode]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Tue, 13 Oct 2026 06:36:45 GMT</pubDate>
            <atom:updated>2026-10-13T06:36:45.073Z</atom:updated>
            <content:encoded><![CDATA[<p>Every piece of advice about coding interview prep is about getting ready. Almost none of it is about staying ready. I wanted to know what happens after you finish the grind, get the offer, and stop. Specifically, how long before the skills you built start to decay.</p><p>So I ran a simple experiment. After completing a full prep cycle and feeling genuinely ready, I stopped practicing entirely for 60 days. No LeetCode, no pattern review, no mock interviews. Then I sat back down and measured what was still there and what was not.</p><p>The results were specific enough to be useful and uncomfortable enough that I understand why nobody writes about this side of it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JyHE3ipD7b8TmVSau2G09Q.jpeg" /></figure><h3>Why coding interview readiness is harder to maintain than build</h3><p>In 2026 more engineers are navigating multiple job searches in a short period than at any point in recent memory. Layoffs have pushed engineers who had not interviewed in years back into active search mode. Promotions into senior and staff roles have created engineers who are valuable at their jobs and completely cold on interview skills. And the format has shifted enough that prep from even two or three years ago does not fully transfer to current loops.</p><p>The question of how long readiness lasts is not academic. For a laid-off engineer trying to decide whether to interview now or spend two more weeks preparing, it matters. For a senior engineer who prepped intensively six months ago and then got promoted into a role that required no interviews, it matters. For anyone managing a rolling job search across multiple companies over several months, it matters.</p><p>The prep advice tells you how to fill the tank. Nobody tells you how fast it drains.</p><h3>What I measured before stopping interview prep</h3><p>Before the 60-day pause I ran a baseline. Three timed medium problems across different patterns, one system design session, and one mock behavioral. I tracked how quickly I identified the pattern on each problem, how cleanly I implemented, and how clearly I could explain the approach under pressure.</p><p>Pattern identification on two of the three: under 90 seconds. Implementation: clean, minimal backtracking. Explanation: specific, no vague hedging. System design: coherent, good tradeoff discussion. By any reasonable measure, I was ready.</p><p>Then I stopped entirely. The sixty days that followed were normal working months. Real engineering work, but no deliberate interview prep of any kind.</p><h3>What 60 days without LeetCode actually does</h3><p>I ran the same baseline at the end of the 60 days. Here is what I found, broken down by what decayed fastest and what held longest.</p><h4>What decayed first: Coding implementation speed</h4><p>The patterns themselves were still recognizable. I could still identify <a href="https://www.youtube.com/watch?v=TBBkiWRE9Zk">sliding window, two pointers, BFS</a> in the opening minutes of a problem. The conceptual recognition held better than I expected.</p><p>What did not hold was the implementation speed. On the same problem types I had solved cleanly before, I was now pausing on syntax I should have been able to produce automatically. Python dictionary methods I had used hundreds of times required a half-second recall step that had not existed before. Heapq usage, deque operations, the specific form of a binary search boundary: all of these had softened in a way that is minor individually but collectively significant under time pressure.</p><p>The pattern recognition is stored in something closer to semantic memory: you understand what the pattern is doing and why. The implementation fluency is stored in something closer to procedural memory: muscle memory for code that has to be fast. Procedural memory decays faster than semantic memory when you stop drilling it, which is exactly what happened.</p><h4>What decayed next: Thinking out loud under pressure</h4><p>The second thing that degraded was narration under pressure. Before the pause, I had built a reliable habit of explaining my reasoning as I went rather than coding in silence. After 60 days of normal engineering work, where thinking is mostly silent, that habit had softened significantly.</p><p>In the baseline test I noticed myself typing before speaking twice on the medium problems. Before the pause I had broken this habit entirely. It came back partially within two sessions of deliberate practice, which tells me it is a trainable habit more than a deep skill, but it confirms that the habit specifically requires maintenance.</p><p>I wrote about why this particular failure mode costs candidates offers in the<a href="https://medium.com/@codegrey/a-modern-approach-to-drilling-leetcode-problems-3-easy-steps-b81543d7b17c"> approach to drilling LeetCode problems</a> piece. What this experiment added was confirmation that the habit is not stable without ongoing practice. You do not get to build it once and keep it indefinitely.</p><h4>What held longest: pattern recognition and systems thinking</h4><p>The conceptual layer held significantly better than the procedural layer. When I opened a problem I had not seen before, I could still identify the category within a reasonable window. Not as fast as before the pause, but not gone.</p><p>System design held almost entirely. The ability to reason about distributed systems, discuss tradeoffs, and structure a coherent design conversation is knowledge that deep engineering work reinforces rather than erodes. If anything, two months of real production work added texture to my system design answers rather than removing it.</p><p>This tracks with what<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> learning without memorization</a> actually builds: a reasoning structure rather than a set of solutions. Reasoning structures are durable. Specific implementations are not.</p><h4>The honest timeline</h4><p>Based on the baseline comparison and two weeks of measuring the re-ramp, here is roughly what the decay curve looks like:</p><p>Implementation fluency starts degrading within two to three weeks of stopping. By 30 days it is noticeable. By 60 days it is a meaningful gap.</p><p>Thinking out loud under pressure starts degrading within three to four weeks. By 60 days it requires deliberate reconstruction.</p><p>Pattern recognition starts degrading around 45 days. By 60 days it is slower but not gone for patterns you internalized deeply.</p><p>System design and high-level reasoning: largely stable up to 60 days, possibly beyond, depending on how much relevant work you are doing.</p><p>The practical translation: if you prepped intensively and then stopped, you have roughly three to four weeks before the first meaningful decay sets in. By six to eight weeks you would be noticeably slower in a live session. By 60 days you are not starting over, but you are not where you were either.</p><h3>What the re-ramp revealed</h3><p>Two things surprised me about re-ramping after 60 days.</p><p>The first was how quickly pattern recognition came back relative to how slowly implementation fluency did. After three days of pattern review, I was back to near-baseline on recognition. Implementation fluency took closer to ten days of active practice to return to where it had been. This suggests that the prep investment in pattern understanding is more durable than the investment in drill speed, and that maintenance should prioritize implementation practice over conceptual review.</p><p>The second was how much faster the re-ramp was than the original build. The<a href="https://medium.com/@codegrey/what-id-do-if-i-had-30-days-to-prep-for-a-coding-interview-7550a8be98f6"> 30-day prep framework</a> takes 30 days from cold. After a 60-day break from a solid foundation, I was back to baseline in about twelve to fourteen days. The original learning is not gone. It is suppressed and returns faster than it was built the first time.</p><h3>What this experiment actually means for how you prep</h3><p>The conclusion I came back to is one I had read in learning science but had not lived through concretely: cramming for an interview cycle and then stopping entirely is the most expensive way to maintain interview readiness over a career. The initial build is expensive. The re-build after full decay is nearly as expensive. And if you are navigating a multi-company search over several months, the decay happens in the middle of the search, not after it.</p><p>The more efficient approach is a low-maintenance ongoing practice that prevents the procedural decay rather than cycling through full build-and-decay. Not the full prep grind. Something much lighter. Fifteen to twenty minutes of active retrieval practice three or four times a week is enough to hold implementation fluency at a level that does not require full reconstruction.</p><p>This is where <a href="https://fenzo.ai/">Fenzo</a> fits in a way that feels genuinely earned rather than bolted on. The decay I measured is precisely the decay that spaced repetition with active recall is designed to prevent. You input the patterns you want to maintain, and it builds retrieval-based sessions that take far less time than a full practice session but apply pressure to exactly the layer that decays fastest. The fifteen-minute Fenzo session three times a week is not trying to replicate a full prep cycle. It is trying to prevent the specific procedural decay that a full prep cycle will not protect you from once you stop.</p><p>For tracking whether maintenance is actually working rather than just feeling productive, <a href="https://medium.com/@codegrey/how-to-measure-real-progress-in-coding-interview-prep-e113e9fd1274">how to measure real progress</a> gives you the framework. The metric that matters for maintenance is the same as for building: pattern identification speed and implementation cleanliness under time pressure. If those are holding, the maintenance is working. If they are softening, the frequency needs to increase.</p><p>Educative’s <a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096">Grokking the Coding Interview</a> is also worth revisiting in maintenance mode rather than learning mode. A single pattern category at reduced pace is a different use of the resource than building through it the first time, and it is the kind of structured refresher that keeps the conceptual layer from softening even as you use Fenzo to hold the procedural layer.</p><h3>The thing the prep advice does not tell you</h3><p>Interview readiness is not a state you achieve and keep. It is a condition you maintain or let lapse. The prep industry is built around the build phase because that is where the urgency is and where the most visible work happens. The maintenance phase is less dramatic and almost entirely unaddressed.</p><p>What the 60-day experiment gave me is a concrete picture of exactly what lapses and when. Implementation fluency first, narration habits second, pattern recognition third, systems thinking last. Knowing the order tells you what to prioritize in maintenance. Knowing the timeline tells you when to worry.</p><p>If you finished a prep cycle and are wondering how long you have before you need to seriously re-engage, the honest answer is: longer than you fear on the conceptual side, shorter than you hope on the procedural side. Start the light maintenance before you think you need to. The cost of prevention is a fraction of the cost of reconstruction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d968b23ba7a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Anthropic/OpenAI actually ask in coding interviews]]></title>
            <link>https://medium.com/@codegrey/what-anthropic-openai-actually-ask-in-coding-interviews-65536b029d33?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/65536b029d33</guid>
            <category><![CDATA[anthropics]]></category>
            <category><![CDATA[interview-preparation]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[technical-interview]]></category>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 11:43:58 GMT</pubDate>
            <atom:updated>2026-10-06T11:43:58.354Z</atom:updated>
            <content:encoded><![CDATA[<p>Most engineers who target Anthropic or OpenAI come from a FAANG prep background. They know the loop: two coding rounds, one system design, one behavioral, LeetCode mediums to hards. They spend eight to twelve weeks on that preparation and walk into an AI lab interview expecting a harder version of something familiar.</p><p>What they get is structurally different in ways that a harder version of FAANG prep does not cover. The failure mode is not being outcompeted by someone with sharper algorithm skills. It is arriving prepared for the wrong interview.</p><p>This is what each company actually asks, how the two differ from each other, and specifically what surprises engineers who prepared for FAANG and found themselves in an AI lab loop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1S6jhImYPwu6VWYAoy24kA.jpeg" /></figure><h3>How Anthropic and OpenAI differ from FAANG: the real gaps</h3><p>The broad comparison first, because the differences are specific enough to change how you allocate prep time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/631/1*pLOCOGcHDKJXs_elkqzwgA.png" /></figure><p>The table is directional. Both companies have team-by-team variation. Verify the specific sequence with your recruiter. But the patterns above hold across enough candidate reports to be reliable for prep planning.</p><h3>What Anthropic actually asks</h3><h4>The coding round</h4><p><a href="https://www.educative.io/blog/anthropic-interview-process?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=anthropics_technical_screen&amp;eid=5082902844932096">Anthropic’s technical screen</a> uses CodeSignal, Colab, or Replit in a shared Python environment. The format is multi-tiered: problems start with a base requirement and expand. One widely reported example is an LRU cache that then needs to be made concurrent. A candidate who writes the clean base case fast and cannot think through thread safety under time pressure fails the round in a way that a pure LeetCode grind would not have predicted or prevented.</p><p>The passing threshold on Anthropic’s CodeSignal assessment is reported at 520 out of 600. This is a real filter, and a significant percentage of candidates do not reach a human conversation because of it. The assessment favors clean, correct code with explicit edge case handling over fast brute-force solutions.</p><p>What interviewers are watching for: production-quality structure, not just a correct output. A working function with poor naming, no edge case handling, and no comments in a real collaborative environment is treated differently than the same function written cleanly. One candidate described the expectation as “code that teammates can read and maintain,” not code that passes a test case.</p><h4>The values and safety round</h4><p>This is the round most candidates underestimate and where most candidates fail, per Anthropic’s own recruiters. It is not a quiz on technical AI safety research. It is an evidence-based assessment of whether you have thought seriously about the consequences of AI systems and whether that thinking has shaped how you work.</p><p>The engineers who pass it come prepared with specific examples: a time they pushed back on shipping something too fast, a time they caught a failure mode a colleague had missed, a genuine opinion about a tradeoff between capability and safety they have worked through. Generic enthusiasm for AI is not the signal. Thoughtful engagement with the real tradeoffs is.</p><p>The minimum prep for this round is reading Anthropic’s Core Views document and its Responsible Scaling Policy, forming actual opinions about them, and being ready to defend those opinions with specificity. This takes more than one evening.</p><h4>What surprises FAANG-prepared engineers</h4><p>The most common feedback from candidates who prepared heavily for FAANG and then interviewed at Anthropic is that the values round caught them. Not the technical round. Years of FAANG-style interviewing trains engineers to treat behavioral as a box-checking warmup before the real evaluation begins. At Anthropic, the values round is the evaluation that can veto everything else.</p><p>The second surprise is the coding format. Problems designed to expand mid-session reward engineers who write extensible code from the start, not engineers who write the fastest correct answer. The Anthropic loop is one of the clearest real-world examples of why expanding-constraint formats test something genuinely different from fixed LeetCode problems.</p><h3>What OpenAI actually asks</h3><h4>The coding round</h4><p><a href="https://www.educative.io/blog/openai-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=openais_coding_prompts&amp;eid=5082902844932096">OpenAI’s coding prompts</a> are implementation-heavy and built around real system components. The four patterns that surface most frequently in candidate reports are: LRU cache from scratch, resumable iterator with state serialization, time-based key-value store with versioning, and a rate limiter using token bucket or sliding window. These are not abstract puzzles. They are small system components that require working, tested code with clean structure.</p><p>The format is closer to pair programming than a LeetCode quiz. One engineer, one shared editor, one problem with extensions. The interviewer will push on assumptions and add requirements partway through. Candidates who try to write the fully-extended version on the first pass consistently run out of time. The correct approach is to solve the base case in the first 20 to 25 minutes, then extend.</p><p>For some roles, OpenAI uses a paid 48-hour take-home work trial where candidates implement a small feature on a representative codebase. The output is evaluated as production-ready code. This is a format that essentially does not exist at FAANG and that standard interview prep does not address at all.</p><h4>Team variation matters more than at Anthropic</h4><p>OpenAI’s loop varies significantly by team. Applied and product engineering roles (ChatGPT, the API, internal tooling) run a loop closer to a senior FAANG loop with coding, system design, and behavioral rounds. Infrastructure and research engineering roles go deeper on concurrency, distributed training, GPU scheduling, and fault tolerance. The bar is somewhere between FAANG senior and FAANG staff, and the company rejects strong-but-not-exceptional candidates more often than most peers.</p><p>System design prompts for product roles skew toward ChatGPT-adjacent systems: multi-tenant chat backends, conversation state management, content moderation pipelines, billing systems for token-based pricing. For infrastructure roles: distributed training architectures, fault tolerance during long training runs, inference serving at scale.</p><h4>What surprises FAANG-prepared engineers</h4><p>OpenAI barely asks traditional LeetCode problems. Engineers who spend their entire prep on abstract algorithm patterns and arrive without the ability to implement a clean, concurrent LRU cache from memory are underprepared for the most common question format. The DSA knowledge still matters, but it shows up applied to real system components rather than as an isolated puzzle.</p><p>The practical implication: prep that covers both pattern recognition and implementation of classic system components is the right stack for OpenAI. I covered why the<a href="https://medium.com/@codegrey/the-contradiction-nobody-talks-about-why-the-companies-building-ai-still-test-you-on-dsa-b5006b6204e1"> companies building AI still test DSA</a> in depth, and OpenAI is one of the clearest examples: the DSA is real, but it is embedded in systems thinking rather than isolated as a puzzle.</p><h3>The one thing that differs most from FAANG at both companies</h3><p>At FAANG, the technical round is the primary filter and the behavioral round is secondary. At Anthropic and OpenAI, the evaluation is genuinely holistic: a weak values or behavioral round can override a strong technical round at both companies, and this is confirmed across multiple independent recruiter and candidate accounts.</p><p>This is a structural difference, not a marginal one. Engineers with strong FAANG technical backgrounds who have never been asked to think seriously about AI deployment tradeoffs are specifically at risk of passing the rounds they prepared for and failing the rounds they did not.</p><p>The preparation shift is simple to describe and takes real time to execute: spend at least as much time on your values and mission alignment preparation as on your system design preparation. At Anthropic in particular, treat the values round as a technical round that happens to be about AI safety reasoning rather than data structures.</p><h3>How to actually prep for these loops</h3><p>For the coding rounds at both companies, the Educative<a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q4_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=grokking_the_coding_interview&amp;eid=5082902844932096"> Grokking the Coding Interview</a> is useful for pattern foundations, but the specific prep for AI lab coding rounds requires going beyond patterns into clean system component implementation.</p><h4>Practice these data structures from scratch</h4><p>The components that surface most frequently across Anthropic and OpenAI reports are not abstract puzzles. They are small, practical systems: LRU caches, key-value stores with expiry, queues and iterators, file and path processors, rate limiters, and simple stateful systems. Being able to implement any of these cleanly from memory, with concurrency considerations, is the specific technical preparation these loops reward. LeetCode familiarity alone does not cover this. Building these from scratch does.</p><h4>Practice changing a working solution</h4><p>After implementing something, give yourself a new requirement and extend it without starting over. Implement an LRU cache, then add expiration, then add serialization, then consider concurrent access, then write tests for the new behavior. This is not about predicting the exact follow-up. It is about getting comfortable modifying your own code under pressure without reaching for a full rewrite. Both companies add constraints mid-problem. The engineers who handle this well built extensibility into their first pass rather than optimizing for exactly the stated constraints.</p><h4>Practice debugging code you did not write</h4><p>Take an existing implementation, introduce a deliberate bug, and practice finding it from failing tests or unexpected output rather than from reading the code top-down. This is specifically relevant for Anthropic, whose official interview guidance explicitly mentions running code and debugging as part of the technical interview. The engineers who handle this well do not start by reading every line. They form a hypothesis first, then verify it.</p><h4>Practice explaining tradeoffs while coding</h4><p>Do not wait until the end to narrate your reasoning. If you choose a hash map over a list, say why. If you make an assumption about input size, name it. If you pick a data structure, explain what operation it makes efficient. OpenAI specifically asks candidates to provide insight into how they consider and solve problems, and the feedback from Anthropic candidates consistently flags communication as a factor in hiring decisions, not just code quality.</p><p>For AI-assisted round preparation, the<a href="https://medium.com/@codegrey/the-new-ai-aware-coding-interview-how-to-prepare-in-2026-6a207d94b23a"> AI-aware coding interview piece</a> covers what interviewers are actually watching in those sessions. Anthropic’s loop is the most explicitly AI-collaborative format in the industry right now, and it rewards exactly the judgment and verification behavior covered there.</p><p>For full-loop practice that includes behavioral and values rounds alongside coding and system design,<a href="https://www.mockinterviews.dev/"> mockinterviews.dev</a>, built by ex-MAANG engineers and powered by Educative, runs complete loops and gives feedback specific enough to identify which rounds need the most work before your actual onsite.</p><h3>What not to assume about Anthropic and OpenAI interviews</h3><p>A few conclusions are worth avoiding before you walk into either loop.</p><p>“They do not ask LeetCode” is too strong. Coding interviews vary by role and team, and candidate reports are not a guaranteed question list. The DSA knowledge still matters, it just shows up embedded in practical systems rather than isolated as a puzzle.</p><p>“I only need to study practical engineering” is also too strong. Algorithmic thinking remains useful for getting through unfamiliar problems efficiently, especially in extensions and follow-ups where the constraint changes and you need to reason about complexity quickly.</p><p>“The questions reported online will appear in my interview” is not a safe assumption. Companies change questions, and interviews differ by role, level, and interviewer. Use reports to understand what skills are being tested, not to memorize specific problems.</p><p>“AI will solve the coding round for me” is the one that trips up the most candidates at Anthropic specifically. Anthropic has an explicit policy on AI use during its application and interview process. OpenAI says AI expectations vary by interview. Read the specific instructions you receive for your interview before assuming anything.</p><p>The AI labs are hiring actively in 2026. The loops are harder than FAANG in the specific dimension of holistic evaluation and softer than FAANG in the specific dimension of abstract algorithm puzzles. Preparing for both the right things and the right order is what separates the candidates who make it through from the ones who expected a familiar loop and found something different.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65536b029d33" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Used an AI Tutor Instead of a Mock Interviewer for 30 Days]]></title>
            <link>https://medium.com/@codegrey/i-used-an-ai-tutor-instead-of-a-mock-interviewer-for-30-days-df35694f69ea?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/df35694f69ea</guid>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 12:26:01 GMT</pubDate>
            <atom:updated>2026-09-29T12:26:01.425Z</atom:updated>
            <content:encoded><![CDATA[<p>I have written before about<a href="https://medium.com/@codegrey/ai-mock-interviews-vs-human-mock-interviews-what-each-is-actually-good-at-4caed8b96d9f"> the difference between AI and human mock interviews</a> and<a href="https://medium.com/@codegrey/how-to-use-ai-mock-interviews-without-building-bad-habits-59264243344f"> how to use AI mock tools without building bad habits</a>. But there is a third category that almost nobody talks about, and I spent 30 days finding out whether it actually matters.</p><p>Not an AI mock interviewer. Not a copilot. An AI tutor. Specifically, I used<a href="https://fenzo.ai/"> Fenzo</a> every day for 30 days, replacing the answer-generating tools I had been using to do my problem review sessions, and tracking what changed.</p><p>The hypothesis going in was simple: most AI tools in interview prep are optimized to give you the answer. A tutor should be optimized to help you understand why. If the why matters more for interview performance, I should be able to measure the difference.</p><p>The results were specific enough to be useful and uncomfortable enough to change how I prep.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dlPKAboza5yedT9M_1SAqw.jpeg" /></figure><h3>Week 1: Discovering the answer trap</h3><p>The first thing I noticed in week one had nothing to do with Fenzo. It had to do with how I had been using other AI tools before this experiment.</p><p>My previous workflow looked like this: get stuck on a problem, open a chat window, paste the problem, ask for help. Get an explanation plus a solution. Read both. Feel like I understood. Move on. Repeat.</p><p>What I had not noticed until I stopped doing it was how much of that “feeling like I understood” was borrowed. The explanation was clear because someone else had organized it. The solution was clean because someone else had written it. When I tried to reproduce either one the next day, I usually could not, or I could only reproduce the parts that felt most familiar rather than the parts that were actually load-bearing.</p><p>This is the answer trap. It does not feel like a trap because every individual session is satisfying. You leave knowing more than you arrived. The problem is that “knowing more when the explanation is in front of you” is not the same as “knowing it when you are in an interview room alone.”</p><p>I switched to Fenzo on day one. Instead of asking “explain this sliding window problem and show me the solution,” I would ask it to build me a short course on the <a href="https://www.educative.io/blog/coding-interview-leetcode-patterns?utm_campaign=persona_coding_interview_q3_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=coding_interview_2026&amp;eid=5082902844932096">sliding window pattern</a>: why it works, what problems it is suited to, what the implementation skeleton looks like, and then quiz me on it. The course took longer. The quiz was uncomfortable. I got some questions wrong that I would have gotten right with the solution visible.</p><p>That discomfort was the point.</p><h3>Week 2: The first concrete before/after</h3><p>By the end of week two I had a specific moment I could point to as evidence that something was different.</p><p>I had been working on substring problems, which in my previous prep had always felt slightly slippery. I could do them with a hint but I could never fully articulate why the window expanded and contracted the way it did. I had read explanations of this probably four or five times across different resources. I always came away thinking I understood and then arriving at the next similar problem and feeling uncertain again.</p><p>In Fenzo, I asked it to quiz me on the expansion and contraction logic specifically, not the full solution, just that piece. It gave me a scenario: given that your window currently contains a duplicate, walk me through the decision your pointer needs to make. I answered. It pushed back and asked why the left pointer moves and not the right. I answered again. It asked what would break if I moved the wrong one.</p><p>That conversation took about twelve minutes. At the end of it I could feel the logic settling in a way it had not settled across the previous four or five “explanations.” The difference was that I had been forced to produce the reasoning rather than receive it.</p><p>The next day I opened a problem I had never seen. It was a variant of the pattern I had been drilling. I recognized it within about ninety seconds and could narrate my approach before writing a line of code. That had not been happening consistently before.</p><h3>Week 3: What the “why” actually unlocks</h3><p>By week three I had a clearer picture of what the tutor approach was doing that the answer-generating approach was not.</p><p>Every time I asked Fenzo why something worked, the answer connected the specific implementation to a more general principle. Why does this sliding window use a hash map instead of a set? Because we need to track frequency, not just presence. Why does frequency matter here? Because the contraction condition depends on whether a character’s count has dropped to zero, not whether the character exists. Why does that distinction matter for the pointer movement?</p><p>Each why led to a deeper layer, and each deeper layer made the pattern more robust under variation. When the interview problem changes a constraint, a candidate who memorized the template freezes. A candidate who understands why the template is structured the way it is can ask themselves which part of the reasoning still applies and which part needs to change.</p><p>This is what I wrote about in<a href="https://medium.com/@codegrey/neetcode-without-memorization-how-i-trained-pattern-recognition-1b4cca44d1ef"> how I trained pattern recognition without memorization</a>: the goal is not to store solutions, it is to store reasoning structures. The tutor workflow builds reasoning structures. The answer workflow builds solution recall. In a fixed-format interview where you have seen the exact problem, solution recall is enough. In any other format, it is not.</p><p>By week three, I was also noticing something in how I narrated problems during practice sessions. I was spending less time saying “I think this is how it works” and more time saying “this is why I am doing it this way.” That shift is small in terms of words but large in terms of what an interviewer hears.</p><h3>Week 4: What changed in actual mock interviews</h3><p>In week four I ran three full mock interview sessions on<a href="https://www.mockinterviews.dev/"> mockinterviews.dev</a> to get an honest measure of whether the tutor approach had actually moved anything in a performance context.</p><p>The difference I noticed was not speed. My solve times were about the same as before. What changed was what happened when a follow-up question arrived.</p><p>In a previous mock session, a month before this experiment, an interviewer had asked me to explain why my hash map approach was more efficient than a nested loop. I had given an answer that was technically correct but vague: “it reduces the lookup time.” In the week four session, the same type of follow-up came on a different problem. This time I walked through the actual comparison: nested loop checks every pair so it scales quadratically, hash map lookup is constant so the overall complexity collapses to linear, and here is the specific step in my solution where that difference matters.</p><p>The interviewer asked a second follow-up: what if the input set were very small. I was able to answer that too: at very small inputs the constant factor on the hash map overhead might make the simpler approach competitive, and whether it matters depends on what the real input distribution looks like. That is a reasoning chain, not a retrieved answer. I would not have had it before the experiment.</p><h3>The comparison I can actually make now</h3><p>After 30 days I can describe the difference between the two approaches with more precision than I could before.</p><p>AI mock tools and answer-generating AI are optimized for the candidate’s comfort. They give you something to leave with: a completed problem, a scored session, a worked solution. That is not worthless. The volume of exposure to problems and formats matters, and<a href="https://medium.com/@codegrey/i-practiced-reviewing-ai-generated-code-for-30-days-heres-what-changed-in-my-interviews-3aa2e7e6eda7"> I Practiced Reviewing AI-Generated Code for 30 Days</a> covers a version of that practice that I think is genuinely useful. Getting answers from AI is not bad prep. It is incomplete prep.</p><p>The AI tutor approach is optimized for the candidate’s understanding. It is less immediately satisfying because it requires producing rather than receiving. The sessions feel harder and end with less of a clean resolution. But the transfer to a live interview is noticeably different because what you are transferring is reasoning, not recall.</p><p>The two are not substitutes. They are different tools with different failure modes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hRSZJnGieTKIxB6xWSBV1w.png" /></figure><p>Both belong in a prep stack. The mistake I had been making was treating the answer tool as sufficient and the tutor as optional. It is the other way around for the part of prep that actually determines whether you can explain your reasoning under pressure.</p><h3>The one question that changed my sessions</h3><p>At some point in week two I stopped asking Fenzo to explain things and started asking it a single question instead: why does this work, and what would break if I changed this specific line.</p><p>That question is the tutor version of a mock interview follow-up. It forces the kind of reasoning that interviewers are actually testing when they push back on your solution. If you can answer it in practice, you can answer it live. If you cannot, no amount of completed problems will help you when the follow-up arrives.</p><p>The question is free. You do not need Fenzo to ask it. You can ask it to yourself after every solution you review, or ask it to any AI you are already using. What the tutor adds is that it will not let you get away with a vague answer. It will keep pushing until you are specific.</p><p>That specificity is what showed up differently in my interviews. Not faster code, not more problems completed. Cleaner explanations under pressure. Thirty days of being asked why will do that to you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=df35694f69ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NeetCode Down? Here’s What to Use While You Wait]]></title>
            <link>https://medium.com/@codegrey/neetcode-down-heres-what-to-use-while-you-wait-a16b92e55d3c?source=rss-1ebe5a4e2baf------2</link>
            <guid isPermaLink="false">https://medium.com/p/a16b92e55d3c</guid>
            <dc:creator><![CDATA[Code Grey]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 11:24:13 GMT</pubDate>
            <atom:updated>2026-09-28T11:24:13.547Z</atom:updated>
            <content:encoded><![CDATA[<p>If you are reading this, NeetCode is probably not loading and your prep session is already disrupted. Here is what to do right now, in order of how close each option is to what you were already doing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oTymUXJ29ylrlFKF58ZGfw.png" /><figcaption><em>Pick the backup that matches what you were already doing.</em></figcaption></figure><h3>If you were doing problem practice</h3><p>Head to <a href="https://www.educative.io/interview?utm_campaign=persona_coding_interview_q3_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=coding_interview_2026&amp;eid=5082902844932096">Educative’s interview prep platform</a> first. It covers the same core patterns NeetCode does, but with interactive in-browser coding environments and text-based walkthroughs you can work through at your own pace without a video running. If you were mid-pattern on NeetCode, you can pick up the same category directly on Educative and keep the session moving.</p><p>For a structured problem list,<a href="https://grind75.com/"> Grind 75</a> is the closest like-for-like backup. Built by the same person who made Blind 75, it has its own customizable pacing tool and covers the same core problem set as NeetCode 150 with similar ordering logic.</p><h3>If you were watching video explanations</h3><p>NeetCode’s YouTube channel is separate from the site and almost never goes down at the same time. Search “NeetCode” on YouTube and you will find the full library of problem walkthroughs, including everything from the NeetCode 150, still accessible directly.</p><p>If you want text-based explanations instead, Educative’s <a href="https://www.educative.io/courses/grokking-coding-interview?utm_campaign=persona_coding_interview_q3_26&amp;utm_source=medium&amp;utm_medium=text&amp;utm_content=coding_interview_2026&amp;eid=5082902844932096">Grokking the Coding Interview</a> is the most thorough pattern-based alternative. It covers the same patterns NeetCode covers but teaches them with written walkthroughs and interactive coding environments rather than video, which some people find easier to follow at their own pace.</p><h3>If you were doing a review session</h3><p><a href="https://fenzo.ai/">Fenzo</a> is worth opening here. You can type in any pattern or concept you were reviewing and it builds an interactive course with quizzes and recall prompts immediately. If you were doing a sliding window review session on NeetCode, ask Fenzo to quiz you on sliding window instead. The session will not be identical but the recall practice will be more active than re-reading notes anyway.</p><h3>If you needed the problem list specifically</h3><p>The NeetCode 150 is documented in multiple places outside neetcode.io. Searching “NeetCode 150 list” on GitHub will return several community-maintained spreadsheets and repositories with the full problem set, direct LeetCode links included. I also covered which patterns from the list matter most for actual interviews in<a href="https://medium.com/@codegrey/neetcode-patterns-ranked-by-interview-frequency-4af039b57903"> NeetCode patterns ranked by interview frequency</a>, which does not depend on NeetCode being up to be useful.</p><h3>The one thing worth doing while you wait</h3><p>Use the disruption to run a timed mock instead of a passive review session.<a href="https://www.mockinterviews.dev/"> mockinterviews.dev</a> runs full coding loops regardless of whether any particular prep site is up. A 45-minute timed session under pressure is a better use of an unexpected gap in your schedule than waiting for a site to come back.</p><p>NeetCode outages are usually short. If it is still down after an hour, check their status on<a href="https://downdetector.com/status/neetcode/"> downdetector.com</a> or their Twitter for any update. In the meantime, everything above covers what you need.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a16b92e55d3c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>