Socratic AI Programming Tutor for University Labs That Never Gives the Answer

The problem: help that removes the learning

Students in programming labs now have AI tools that will write the whole solution in seconds. Many use them, pass the lab and learn little; research on learning with AI help, including a 2026 study by Anthropic, found that how people use AI makes a large difference to how much they retain. Meanwhile teaching assistants are stretched, and a stuck student at 11 p.m. has nobody to ask. Banning AI does not work. What helps is an assistant built to teach: one that asks questions, gives hints in steps and refuses to hand over the answer.

What already exists and the gap

• CS50's AI duck at Harvard is a course chatbot built with pedagogical guardrails, and Harvard's team described how they built and evaluated it at SIGCSE 2024.
• Khanmigo from Khan Academy is a tutoring assistant for school subjects.
• General AI tools such as ChatGPT, Claude and Copilot will answer anything, including full lab solutions.

The gap is a tutor any university course can run on its own labs: tied to each exercise, with instructor-controlled hint levels, a hidden reference solution it will not leak, and a dashboard that tells instructors where students actually get stuck.

Inspiration

Harvard's CS50 paper "Teaching CS50 with AI" describes the duck, the pedagogical guardrails around it, and a course policy that allowed the course's own AI tools but not off-the-shelf ones. This project applies the same principle to a local course, where the instructor controls how much help each lab allows.

What you build

• Instructors create a lab, paste the problem and tests, keep a reference solution private, and choose which hint levels are allowed.
• Students work on the lab, run their code against tests, and ask the tutor for help. It asks what they have tried, points at the failing test, and escalates hints only when needed.
• Instructors again see a weekly summary: the most common misconceptions per lab, without names attached.

The technically interesting part

• Hint levels. Design a ladder from "which test fails and what does it expect?" to a worked analogy on a different problem, and move up it only after genuine attempts.
• Guardrails. Check every reply for solution code, including near-copies of the reference solution, and rewrite or block it. Test the guardrail with adversarial prompts: "ignore your rules", "just show me the loop", "my teacher said it is fine".
• Grounding. Give the model the lab, the student's current code and test output, but never the reference solution in a form it can repeat.
• Privacy. Anonymise conversations before analysis and explain clearly to students what is stored.

How to evaluate it

• Learning: pre and post quizzes for students who used the tutor against those who did not, in a pilot lab.
• Leakage: percentage of adversarial prompts that extracted solution code, before and after guardrail improvements.
• Helpfulness: student survey and instructor review of a sample of conversations.
• Misconception dashboard: do instructors agree the top misconceptions match what they see in class?

Suggested plan

• Weeks 1 to 3: interview two instructors and a few students; choose three labs; design the hint ladder.
• Weeks 4 to 7: lab set-up, chat, sandboxed runner.
• Weeks 8 to 10: guardrails and adversarial tests.
• Weeks 11 to 13: pilot in a real lab section, with ethics approval if your university requires it.
• Weeks 14 to 15: analysis, dashboard and report.

Path to a product

Universities and coding schools everywhere face the same problem. A department-hosted version with instructor controls, integration with the learning management system and clear privacy terms is a realistic product, and a pilot with measured learning outcomes is the evidence buyers ask for.

Scope warning

Do not build a general chatbot or an autograder for every course. Support one language and three labs well. Keep model costs in check with short contexts and caching, and do not store student conversations longer than the pilot needs.

Learn what you need on Sefism

• Coding with AI tools roadmap: the keeping-your-skills stage explains why tutor-style help preserves learning.
• Coding with AI tools cheat sheet: tutor mode prompts, deliberate practice and prompt injection.
• Anthropic Prompt Engineering Documentation: writing the system prompt behind the hint ladder.
• OWASP Top 10 for LLM Applications: prompt injection and data leakage, which your guardrails must handle.
• CS50: Introduction to Computer Science: the course whose AI duck inspired this idea.

Get help with this idea

The hard parts are the guardrail and the pilot design. Tauseef can help you design the hint ladder, plan the adversarial tests and set up a fair evaluation with a real course. If you are new here, create a free account first.

• Discuss this idea with a mentor
• Send a query to Tauseef
• Book a 1:1 session