are CS students cooking or getting cooked?

Aug 13, 2024

There’s a new split happening in computer science classrooms and Discord servers.

On one side: students who use AI like a jetpack—faster feedback loops, better explanations, more experiments, more output.

On the other side: students who use AI like a crutch—copy answers, pass assignments, and quietly lose the ability to reason about the code they ship.

So… are CS students cooking or getting cooked?

Both.

What AI is really changing

The cost of “trying something” is approaching zero

Before AI, learning was bottlenecked by friction:

  • you got stuck
  • you searched
  • you opened five tabs
  • you tried to understand one StackOverflow post
  • you hoped it applied to your case

Now, you can ask a model to propose a solution, explain it, and generate variations. That means more iterations per hour, which is basically the closest thing we have to a cheat code for skill acquisition.

But here’s the catch: iterations only teach you if your brain stays in the loop.

The new failure mode: “I can produce code, but I can’t predict code”

In CS, the difference between beginner and competent isn’t typing speed.

It’s this ability:

Before running it, I can predict what the program will do.

If AI writes your code, you can end up in a weird place where you can assemble projects, but you can’t debug them. You can pass a class, but you can’t reason under pressure.

That’s what “getting cooked” looks like in 2026.

The good side effects (aka: cooking)

If you use AI like a tutor, you get huge wins:

  • Faster explanations: “Explain recursion like I’m five, then like I’m a senior engineer.”
  • Better examples: “Show me three implementations and compare them.”
  • Immediate practice: “Generate 10 exercises that slowly increase in difficulty.”
  • Rubber duck debugging: “Here’s the bug; ask me questions until we isolate it.”

This is especially powerful for topics that are conceptually heavy:

  • pointers and memory
  • concurrency
  • complexity analysis
  • graphs and dynamic programming
  • compilers, interpreters, and parsing

The bad side effects (aka: getting cooked)

1) Outsourcing the hard part

Most learning happens at the moment you’re uncomfortable:

  • you don’t know why it’s failing
  • you’re forced to form hypotheses
  • you test and revise

If AI removes that moment, you skip the workout and only watch fitness videos.

2) Phantom understanding

This is a dangerous loop:

  1. AI generates code
  2. the code runs
  3. you feel like you understand it

But if I change one constraint (input size, performance needs, security requirements), the whole thing breaks and you don’t know why.

3) Assessment mismatch

Some courses still grade like it’s 2016 (handwritten proofs) while the industry hires like it’s 2026 (shipping working systems).

AI makes the mismatch louder.

If your class wants raw problem solving, AI can sabotage you. If your internship wants product thinking and iteration, AI can accelerate you.

How to use AI without losing your fundamentals

Here are rules I wish every student followed.

Rule 1: Ask for questions, not just answers

Instead of “solve this,” try:

  • “What are 3 approaches and their tradeoffs?”
  • “What would you check first if this fails?”
  • “What assumptions does this solution rely on?”

Rule 2: Force yourself to rewrite

If AI gives you code, you’re not done until you:

  • rename variables to something meaningful
  • rewrite it in your own style
  • add a test
  • add a comment only where you were confused

That rewrite step is where understanding forms.

Rule 3: Always do a ‘no-AI’ rep

For every topic you learn with help, do one exercise entirely without AI:

  • implement a stack + queue
  • write a simple parser
  • build a small REST API
  • build a tiny game loop

This is like lifting without straps. It exposes weak points fast.

Rule 4: Use AI to generate adversarial tests

One of the best prompts is:

“Give me edge cases that would break this algorithm.”

Then run them. If you can’t explain why an edge case fails, you didn’t learn the topic yet.

Rule 5: Learn the shape of systems

The industry doesn’t pay for “knowing syntax.” It pays for:

  • modeling data
  • designing APIs
  • handling failures
  • logging and observability
  • performance and tradeoffs

Ask AI to describe the system architecture, not just to dump code.

The future implications

AI will raise the baseline output. That means:

  • more people will be able to ship small projects
  • interviews will shift toward reasoning and debugging
  • “explain your decisions” becomes more important than “write it from scratch”

If you’re a student, the winning strategy is simple:

Use AI to multiply practice, but never let it replace thinking.

Do that and you’re cooking.

Skip that and… yeah.