LeetCode Tutor
A Socratic AI tutor that tracks your competency profile and adapts. It reads your code, knows what you've struggled with before, and guides you through problems without giving answers. Five levels of hints before it ever shows a solution.
I recently read the new biography about Alex Karp, The Philosopher in the Valley, and love the quote about Alex having never learned to drive: “I was too poor, and then I was too rich.” It reminds me of my relationship with LeetCode — I was too stubborn, and then there was Claude.
I never was big on grinding LeetCode. I landed an offer out of university without it and it was intimidating. There's also the looming feeling that LeetCode is a thing of the past, a relic of a bygone, pre-agentic coding world. I tend to agree (whether out of convenience or conviction would require some scrutiny alone in a quiet room). Nevertheless, as one thinks about their next chapter in this uncertain world — and I now see it can be fun to learn to apply your problem-solving skills in a new way — it seemed like a natural thing to build.
My gripe with DSA problems was that I could sit there for hours on an Easy when I was 19 and feel like I made no progress. In the same time period I could write a multi-hundred line MIPS assembly routine that confused the hell out of my friends. If only someone could sit there with me and just offer a little hint. Well, with intelligence on demand, now everyone can have a personal tutor 24/7 that's smarter, more patient, and has a way better memory than any grad student in the tutoring center.
I am very bullish on the future of education with AI. I think students having access to 1:1 tutoring that lets them go as fast as they want will let us see many more kids under 18 earning undergrad degrees. And what a magnificent thing that will be.
The tutor doesn't jump to the answer. It follows a strict escalation path: conceptual nudge → pattern identification → algorithmic direction → pseudocode outline → full solution walkthrough. Each level only activates when you're stuck at the previous one. Most sessions resolve by level 2 or 3. The model is prompted to ask Socratic questions at each level, not deliver lectures.
The system maintains a per-user competency profile that tracks your strengths and weaknesses across problem categories — dynamic programming, graph traversal, sliding window, etc. The profile is computed from your session history: which problems you solved, how many hints you needed, which concepts tripped you up. When the tutor formulates a response, it has access to this profile and adjusts its approach accordingly.
The AI doesn't just receive a prompt and respond. It operates in a tool use loop with structured access to your context. The model can call read_problem to see the current problem statement, read_code to inspect your latest code in the editor, and query_history to check your past sessions and competency data. This means the tutor can reference your actual code when asking questions — “I see you're using a hash map here, but what happens when the input has duplicates?”
The editor is CodeMirror 6 with syntax highlighting, a terminal-inspired dark theme, and multi-language support. The tutor reads from the editor state in real time — when you ask for help, it sees your current code, not a stale snapshot. The split-pane layout puts the editor and the tutor conversation side by side.
┌──────────────────────────────────────────────┐
│ React + CodeMirror 6 │
│ │
│ ┌─────────────┐ ┌───────────────────────┐ │
│ │ Code │ │ Tutor Conversation │ │
│ │ Editor │ │ (SSE streaming) │ │
│ └──────┬──────┘ └───────────┬───────────┘ │
│ │ │ │
└─────────┼─────────────────────┼──────────────┘
│ │
└──────────┬──────────┘
│
┌────────────▼────────────┐
│ Express Server │
│ │
│ ┌───────────────────┐ │
│ │ Tool Use Loop │ │
│ │ ┌─────────────┐ │ │
│ │ │ read_problem│ │ │
│ │ │ read_code │ │ │
│ │ │ query_hist │ │ │
│ │ └─────────────┘ │ │
│ └─────────┬─────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │ Claude API │ │
│ │ (Socratic mode) │ │
│ └───────────────────┘ │
│ │
│ ┌───────────────────┐ │
│ │ SQLite │ │
│ │ (sessions, │ │
│ │ competency) │ │
│ └───────────────────┘ │
└─────────────────────────┘The backend is Express with a tool use loop that mediates between the client and Claude. When you ask for help, the server packages your current code, the problem statement, and your competency profile into a structured context. Claude processes this with Socratic prompting and responds via SSE streaming, so you see the response as it's generated.
Session data — problem attempts, hint levels reached, completion status — is stored in SQLite and used to compute the competency profile. The profile is recalculated after each session, weighting recent performance more heavily. This means the tutor adapts as you improve — it stops over-explaining concepts you've demonstrated mastery of.
The entire system is designed around not giving answers. This is a hard constraint in the prompt, reinforced by the hint ladder. The tutor asks questions that lead you to the insight. It's slower than just showing the solution, but the point isn't speed — it's building the neural pathways that let you solve the next problem independently.
The tool use loop runs server-side. The client sends a message, the server handles all the Claude API calls — including intermediate tool calls for reading code and querying history — and streams back the final response. This keeps the Claude API key on the server and means the client doesn't need to know about the tool use protocol.
A generic AI chat has no memory of what you know. It explains binary search the same way every time. By maintaining a competency profile, the tutor can skip concepts you've proven you understand and spend more time on areas where you repeatedly get stuck. The learning path becomes personalized without the user having to configure anything.
I'd integrate a problem recommendation engine. The competency profile already knows your weak areas. Automatically suggesting the next problem to practice — based on what you need to work on, at the right difficulty level — would close the loop between assessment and practice.
I thought about productizing this, but there's no good open-source DSA problem set I could find. You could probably launch it as “helping with non-descript DSA problems,” but I have no interest in a legal battle with LeetCode.