AI Tutor for Computer Science: The Step You Cannot See in a Lecture Hall

Computer science is the subject in this list where an AI tutor is both the most useful and the most
dangerous. It is the most useful because the gap in CS is often in a specific step of the
algorithm, and the tool that meets you at that step is exactly the tool you want at 2 a.m. the
night before a problem set. It is the most dangerous because the tool will do the problem set
for you, and a student who lets it build the linked list or prove the loop invariant is not
building the skill, and the skill in CS is in the building, not in the reading.

The honest version of what an AI tutor is for in computer science is a loop that runs on the
student's own code and their own problems, and it is not a loop that hands the student the code
without the derivation of why it works. You can start running problems through that loop, free
and with no card, by building a study system from your own code and problems, free, no card, in a
tool like Fennie, and that is the right first move to see
whether it helps your specific course.

Why computer science is a different case for an AI tutor

The reason "AI tutor for computer science" is a different question than "AI tutor for
statistics" is that the hard part in CS is a skill stack, and the tool is useful at some layers
of the stack and misleading at others, and the student who does not know which layer they are in
is going to end up with a high GPA and a low skill floor.

The syntax layer is where the tool is most useful and the skill gap is smallest. The gap in
the syntax layer is a specific error, the off-by-one, the null reference, the recursive case
that never terminates, the variable that is scoped to the wrong block, and the tool that names
the specific error is the tool that is most useful, and the student who knows the specific error
is in a different position than the student who does not. This is the layer where the tool is
best at its job, and the layer where it is also the most likely to do the student a disservice
if the student does not understand the specific error they are being told about.

The algorithm design layer is where the tool is most dangerous if it does the work. The
gap in the algorithm design layer is a design question, "should I use a heap here," "should I
use a hash map here," "should I sort and then binary search," and the tool that hands the student
the algorithm is not teaching the algorithm choice, and the student who accepts the algorithm
choice without being able to reproduce the design reasoning is in a weaker position on the exam
than a student who makes the design choice themselves and gets it wrong, because the design
choice is the skill and the skill is in the choosing, not in the accepting.

The proof and complexity analysis layer is where the tool is at its most misleading. The
gap in the proof layer is a reasoning gap, "why does this loop terminate," "why is this
invariant maintained," "why is the complexity O(n log n) and not O(n^2)," and the tool that
hand-covers the proof without the student being able to reproduce it is a tool that is doing the
student a disservice, because the proof layer is the layer where the reasoning is the skill,
and the reasoning is the thing the student has to build, and the tool that does not push for
reproduction is not the right tool for that student.

What a good AI tutor does for computer science

This is the shape of the tool that earns its place in a CS stack, and it is worth knowing
what "good" looks like before you pick one.

A step-by-step walk of the algorithm, with the design choice and the loop invariant named.
A tool that can be asked to walk a sorting algorithm, step by step, "what is the invariant at
this step," "why does this swap maintain the invariant," "why does the loop terminate," and
that can name the design choice at each step, is the instrument for the algorithm layer, and
that is where the tool is most useful, because the algorithm layer is the layer where the
skill is in the design and the reasoning, and the tool that names the design and the reasoning
is the tool that is useful. A tool that gives the student the code without the design and the
reasoning is a code generator, not a tutor.

A "which data structure does this problem call for" check on the setup. A tool that can be
asked to check the data structure choice before the algorithm, "should I use a heap or a sorted
list for this priority-queue problem, can you check my reasoning," is the instrument for the
design layer, and that is where the tool is most useful, because the data structure choice is
where the reasoning starts, and the reasoning is the layer the course tests. A student who
asks the tool which data structure to use, and then does not ask the tool to walk their
reasoning, is asking for the wrong thing and the tool will give them the right thing, and the
gap stays.

A loop that runs on your own code and your own problems. A tool like Fennie can run the
student's own code against their own test cases, and can be asked to walk the code that the
student wrote, and that is the instrument for the skill-building, because the CS skill is in
the code the student writes, not in the code the tool writes, and the loop that builds the
student's code skill is the one that is useful. A tool that only writes code from a fixed
problem bank is a code generator, not a tutor.

A spaced-repetition component for the named algorithms and the named data structures. The
final part of a CS course is the memory part, which algorithm for which problem, which data
structure for which problem, the named algorithms, the named data structures, the named
complexity bounds. That is a recall loop, and a spaced-repetition component in the tool is
what handles that part, because the memory part is not a conceptual gap and a conceptual tool
will not close it, and the memory part is where the tool is cleanest for the student.

What the AI tutor will not do for computer science

This is the honesty part, and it is the piece most AI-tutor pages skip.

It will not write the code for the student and call it done. The tool is not the code,
and the student who lets the tool write the code for them is not building the skill that the
course is teaching, because the skill in CS is in the code, and the code is the thing the
student has to be the one writing, and the tool checking the code is a different role than the
tool doing the code.

It will not prove the loop invariant or the algorithm's correctness for the student. The
tool can walk the proof, and the tool can check the student's proof, and the student who reads
the tool's proof without being able to reproduce it is in a weaker position than a student who
can reproduce their own proof, because the proof is the layer the exam tests, and the student
who reproduces their own proof is in a different position than one who cannot.

It will not close a gap that lives in the design layer. The design layer, "should I use a
heap here," "should I use a hash map here," "should I sort and then binary search," is the
layer the tool often does not close, because the tool is either writing the code or checking
the code, not designing the code, and the design layer is the layer the exam tests. A student
who has a gap in the design layer is not going to fix it by asking the tool to write the code
or by asking the tool to check the code. They are going to fix it by a focused two-week pass on
the design layer, and the tool is the instrument inside that pass, not the pass itself.

FAQ

Is an AI tutor better than an IDE for debugging?

No, not for debugging. The IDE is the debugger, the tool that finds the syntax error and the
type error, and the AI tutor is a different tool. The AI tutor is for the design layer, the
proof layer, and the algorithm choice, and it is useful because those are the layers where
students actually get stuck, not the syntax. Use the IDE to debug the syntax, and the AI
tutor to check the design and the reasoning, and the two together are more valuable than
either one alone.

Can I use an AI tutor to write my CS homework?

No, with one boundary, and the boundary is the one that makes the tool do its job. The tool
is for checking the design and checking the reasoning, not for writing the code. A student
whose code is the tool's, and not theirs, is in a weaker position on the exam, because the
exam tests the code, and the student who writes their own code is the one who passes. The
tool is the check, not the writer, and the student who uses it that way is the one who
benefits.

Which AI tutor is best for computer science?

The best one for computer science is the one that checks the design, checks the proof, and does
not write the code or cover the proof for the student. Fennie does the design check, the proof
check, and the code loop on your own code and problems, and it does not write the code or cover
the proof for the student, and that is why it is useful, because the code is the layer where
the tool is best at its job, and the design is the layer where the student has to do the work.

Do I need an AI tutor if I already have a CS professor I can see in office hours?

No, but the two do different jobs. The professor is the diagnostician, the one who looks at
your code and tells you which of the layers is the gap. The AI tutor is the loop, the design
check and the proof check, available at 2 a.m. and not in the office hour that is four days
away. Use the professor for the diagnostic, the AI tutor for the loop, and the two together
are more valuable than either one alone.

The honest bottom line

An AI tutor for computer science is a real and useful tool, and the honest version is that it is
the loop on the student's own code, not the code writer, not the proof writer, and not a rescue
for the student whose gap is in the design layer. It is the instrument for the syntax layer,
and the check for the design layer and the proof layer, and it is the memory loop for the named
algorithms and the named data structures, and it is not the instrument for the student's
reasoning, because the reasoning in CS is in the design and the proof, and those have to be
yours.

If you want to see what the loop and the design check do for your course, start with a study
system built around your own code and your own problems, free, no card,
and run your own code through it this week, and do the design and the proof yourself, because
that is where the exam tests, and it is the work only you can do for yourself.