Why Learn Algorithms in the AI Era

Added: 2026-05-18

[00:00:00]Hey.

[00:00:01]Welcome to Bits and Proofs.

[00:00:03]This is video one in a new series algorithms across languages where we break down classic algorithms in Rust, Go, and Python side by side.

[00:00:14]But before we get into the code, I want to answer a question almost every software engineer is quietly asking himself or others.

[00:00:23]Before we get into why, here is a quick map of where we are going.

[00:00:28]First, I'll show you the actual bugs AI-generated code keeps shipping to production, then concrete examples, then the mental model that's helped me think about working with AI, treating it like a junior developer, and you as the senior.

[00:00:43]Then the four habits of mind the algorithms train, and where they pay off in a ways that have nothing to do with the interviews.

[00:00:52]We will talk about why AI is an amplifier, not a replacement, and what it means for the engineers who get good at it versus the ones who don't.

[00:01:04]And finally, why the interview bar is going up in the AI era, not down.

[00:01:10]Takes about 9 minutes total, no prerequisites.

[00:01:14]Let's go.

[00:01:17]AI tools like Claude and Copilot can write working code in seconds.

[00:01:22]So, why should we still spend time learning algorithms?

[00:01:26]Next few minutes, I'll give you five reasons, and they are not the ones you usually hear.

[00:01:34]The short answer is this.

[00:01:36]AI does not know when it is wrong, and neither do you unless you understand what good code actually looks like.

[00:01:47]What AI is good or bad at.

[00:01:50]There's a huge amount of work AI does genuinely well for us.

[00:01:55]Ask AI to write the repetitive setup code that every project starts with.

[00:02:02]It does a perfect job.

[00:02:04]Writing clean natural code in any programming language, AI often does this better than senior engineers.

[00:02:12]Routine tasks, talking to your database, parsing data files, calling an API, AI handles these instantly.

[00:02:21]A quick how do I do X kind of a thing you used with the Google search or Stack Overflow so far, now can be done with AI a lot faster.

[00:02:32]Converting from one programming language to another, good AI models do a great job. That's the easy 80% of the programming and AI just dissolves it.

[00:02:44]But here is where it falls apart.

[00:02:47]Problems it hasn't seen before, anything unlike what it saw during the training, code that's fast enough for your real-world data.

[00:02:57]AI tends to write the textbook version that works on small inputs and falls over on the large ones.

[00:03:06]Tricky bugs that pass all your tests but break in production.

[00:03:12]Knowing when its own answer is wrong.

[00:03:17]And the big one, picking the right approach in the first place.

[00:03:23]The last 20% is where engineering actually happens.

[00:03:27]And that's the part we have to bring in as human engineers.

[00:03:33]Looks right is the trap.

[00:03:35]When AI generates the code for you and you look at it at a high level, it feels right.

[00:03:41]That's a trap.

[00:03:42]Let me show you how with a concrete example.

[00:03:46]You ask AI, "Write a function to find duplicates in a list." And this is what you get.

[00:03:52]It works. It's clean.

[00:03:58]You would merge this code in some master or main branch after testing with a test array.

[00:04:04]It passes code review. It ships to production.

[00:04:09]Then a customer passes a 100,000 item list, and you have got a 10 million comparisons.

[00:04:16]Your endpoint is suddenly 10 seconds slow.

[00:04:20]The fix is one line, but you only see the fix if you know the words O of N squared.

[00:04:27]The original code did not have any of those words written in it.

[00:04:31]The bug was not in the syntax. It was in the algorithm.

[00:04:37]Same trap, different failure.

[00:04:39]And it's not about loops or time complexity or space complexity using big O.

[00:04:46]Same pattern, different failure mode.

[00:04:48]You ask AI to flatten a nested list, and this is what you get.

[00:04:55]It looks like a textbook problem. Uh it passes your tests.

[00:04:59]Then real input arrives, a config tree with 5,000 levels deep, and uh Python throws a recursion error.

[00:05:08]Maximum recursion depth exceeded.

[00:05:12]The fix is not more code.

[00:05:14]It's recognizing that recursion has a ceiling and uh reaching for an explicit stack instead.

[00:05:21]That's an algorithmic instinct.

[00:05:23]And AI does not have it unless you ask for it.

[00:05:26]I, as a software engineer working for over 30 years, have started using AI tools like all others, have witnessed issues in production even with the best code models like Opus 4.6 from Anthropic.

[00:05:42]The reviewer problem.

[00:05:45]Reviewing others' code is hard.

[00:05:47]And reviewing AI-generated code is even harder. Why?

[00:05:53]O of n squared, off-by-one, race condition, unbounded recursion.

[00:05:59]These are not just interview trivia, but they are the names of failure modes that take down real systems.

[00:06:08]If those words don't fire anything in your head, and when you look at the AI output, the bug ships to production.

[00:06:16]AI generates the code. You are still the reviewer.

[00:06:22]Think of AI as a junior developer.

[00:06:25]Here is the mental model that helped me the most when working with AI.

[00:06:31]Treat the tools like a junior developer.

[00:06:34]Eager, fast, can write a lot of code, can churn out solutions you would take an afternoon to write, but still junior.

[00:06:44]And you are the senior.

[00:06:49]All the AI tools do what you tell them.

[00:06:52]But if you don't know how to guide them, and you can't tell them what correct looks like, then they don't know what to do either.

[00:07:01]So, the senior responsibility does not go away.

[00:07:04]With AI in the loop, it actually matters a lot.

[00:07:12]AI is an amplifier, not a replacement.

[00:07:15]Engineers who understand the fundamentals ship faster with AI. They ask sharp questions. They make AI work the right way. They catch its mistakes before production does.

[00:07:28]Engineers who don't understand end up shipping plausible-looking code, code that they cannot defend in a review, code they cannot debug when it breaks.

[00:07:41]Same tool, same junior in the loop, 10 times different outcomes. The difference is what you as a senior brought to the keyboard.

[00:07:52]So, what do algorithms actually teach you?

[00:07:55]It's a four habits of mind that show you in everything you do as an engineer.

[00:08:03]Decomposition, taking a fuzzy problem and breaking it into pieces that you can actually solve.

[00:08:11]Complexity reasoning, predicting the cost of your code before you ever run it.

[00:08:18]Trade-off thinking, time versus space, simple versus fast.

[00:08:24]And correctness arguments, being able to say why your code works, not just that it has passed the tests you happen to write.

[00:08:34]Once you internalize these habits, you start spotting them everywhere.

[00:08:39]You can see the list on the screen.

[00:08:41]The one I want to call out is reading AI-generated code, because if AI really is a junior developer, then the responsibility falls on the senior to do the code review.

[00:08:54]And honestly, beyond software entirely, once you start thinking algorithmically, you can catch yourself decomposing problems at the grocery store.

[00:09:04]As an engineer, you're still responsible for what AI produces.

[00:09:11]None of these skills expire when the new model ships.

[00:09:16]Interviews still test algorithms.

[00:09:19]Oh, one more thing. And uh stay with me even if you're not job hunting right now.

[00:09:24]Something surprising is happening with the how top companies are interviewing.

[00:09:31]Top companies are more selective on fundamentals now, not less.

[00:09:37]Their reasoning is simple.

[00:09:39]If AI is handling the easy 80%, they only need the engineers who can do the other 20.

[00:09:47]The bar did not go down, it went up.

[00:09:52]Let's bring all five threads together before we close.

[00:09:56]First, looks right is the trap. AI ships plausible code that hides real bugs underneath, and those bugs are algorithmic, not syntactic.

[00:10:07]Second, you can't see a bug you don't have the vocabulary to spot, and algorithms give you that vocabulary.

[00:10:14]Third, algorithms train four habits of mind: decomposition, complexity reasoning, trade-off thinking, and correctness arguments.

[00:10:24]And those habits transfer everywhere, including reading AI code.

[00:10:30]Fourth, AI is an amplifier.

[00:10:33]Engineers who have built those habits ship 10 times faster and better with it.

[00:10:38]Engineers who have not ship code, they cannot defend.

[00:10:43]And fifth, the interview bar went up, not down.

[00:10:47]Companies want 20% AI can do.

[00:10:51]Five reasons, different angles, same conclusion.

[00:10:56]The takeaway.

[00:10:59]Algorithms are not competing with AI.

[00:11:02]They are the lens that make AI useful.

[00:11:06]Learn the fundamentals, use the tools, ship better code than either you or AI alone.

[00:11:16]Thanks for watching.

[00:11:17]The next videos on this channel break down classic algorithms in Rust, Go, and Python in entry style, side by side.

[00:11:26]Like, share, subscribe, and comment if you have any.

[00:11:30]Thanks.