How to keep learning in the age of LLMs | Oğuzhan Olguncu
Short summary
LLMs have made it too easy to skip the struggle that actually builds learning, so the author rebuilt his approach: use LLMs as Socratic mentors that ask questions instead of giving answers, delegate boring grunt work, plan projects in phases to stay motivated, and make progress visible to maintain curiosity.
- The core problem: LLMs can one-shot solutions, removing the productive struggle your brain needs to actually learn and retain information—you have to force yourself to work through problems first, then use LLMs to explain concepts you're stuck on.
- Use LLMs as a Socratic mentor, not a code generator: ask it to ask you questions that lead you to the answer yourself, which makes the lesson stick far better than being handed the solution.
- Plan your learning projects in detailed phases with clear goals and checkboxes before you start; this kills procrastination and lets you resume work with zero willpower, plus spaced practice across short sessions actually cements learning better than marathon grinding.
- Build visible progress into your project—a REPL, UI, benchmark chart—to maintain motivation and curiosity; the author's LSM-tree compaction code making reads 100× faster was what kept him engaged.
Full summary
The author argues that LLMs have made learning harder by eliminating productive struggle. When you can ask an AI to solve a problem instantly, you skip the mistakes that actually cement knowledge in your brain. He hit a wall with this approach—grinding through frameworks and languages felt pointless when an LLM could generate working code in seconds. His breakthrough came while implementing Bitcask, a database paper. Instead of asking the LLM to write stuck code, he asked it to explain concepts so he could solve it himself. This led him to adopt what he calls "socratic-code-mentor" mode: the LLM asks questions rather than providing answers, forcing you to think through problems. He gives a concrete example of debugging a loop that runs one index too far—the LLM doesn't say "your loop goes too far," it asks how many items are in the array and what the last index is, then draws a diagram. You find the bug yourself, and it sticks.
The second problem is motivation over long projects. Without structure, you'll spend your next session staring at a blank screen. The author uses detailed PLAN.md files split into phases, each with a goal, small steps, a "done when" checkpoint, and known traps. For his tinylsm project (an LSM-tree database), Phase 2 focused on write-ahead logging with specific tasks: encode/decode records, append to a file, replay on startup. Each phase ends with working code and passing tests. This removes decision fatigue and lets you tick boxes for quick wins. Spaced practice—working on the same project in short bursts over weeks—forces your brain to retrieve information between sessions, which is what makes learning stick. Psychologists call this effect retrieval strength.
Visual feedback matters more than you'd think. The author had the LLM build a REPL for tinylsm where he could watch tables accumulate and benchmark reads, seeing his compaction code make queries 100× faster. That dopamine hit kept him curious and engaged. He also points out that LLMs excel at research now—instead of digging through GitHub repos and specific book chapters to learn how something works, you just ask the AI to research and summarize it. The key is using LLMs as teaching tools and grunt-work handlers, not answer machines. Let them build boring test scaffolding and boilerplate while you focus on the concepts that matter to you.