This is Part 4 of a four-part series on building classroom tools and teaching computer science with AI.

• Part 1: Beyond the Chatbot: What is Agentic Programming?
• Part 2: Local Classroom Automation: Rebuilding Precalculus Notes
• Part 3: Automating the Tedious: Scraping Regents Exams & The Hosting Bottleneck
• Part 4: What Do We Teach When the Code is Free?

I spent the last few months building three different projects with AI: a native Apple TV app, a local curriculum compiler, and a web tool for my math department. I didn't write code in any of them.

At no point did I think about a conditional. I never considered how a loop should be structured. I didn't design a function, I didn't think about scope, I didn't worry about types. A compiler error would show up, I'd paste it into the agent, the agent would fix it, and I'd move on.

I'm a CS major. I've taught computer science for years. And the thing that I ostensibly teach (writing code) I didn't do once.

So. What do we actually teach going forward?

You Still Need to Know Things

There's a version of this conversation that goes: "AI means anyone can build anything." I don't think that's right.

Looking back at the three projects, I can see my CS background was doing a lot of work the whole time. I just didn't notice it because it wasn't the hard part.

When I started Barn Burner, I knew it was a simple app. No user accounts. No database. No cloud syncing. No real-time anything. It's a timer. The complexity ceiling was low and I knew that going in, which is why I thought it would work. A person who didn't know what databases and APIs are, who didn't have any intuition for what makes an app hard versus easy: would they have made the same call? Or would they have described what they wanted and gotten halfway through before running into problems they couldn't diagnose?

I also knew (from years of following Apple development, listening to ATP (Accidental Tech Podcast), reading about iOS development) that it was possible to play audio cues over background audio without ducking the system volume. That's not an obvious thing. It's the kind of knowledge you accumulate by paying attention to a platform. Without that knowledge, you might not even think to try.

Taste is part of it too. The first build of Barn Burner looked generic. Getting it to look good required me to have opinions (I don't think I'm a good designer, but merely that I'm not a generic AI tool and not a terrible one either). A decade of making generative math art meant I had old code I could bring in. Having strong views about how tvOS apps should look and feel meant I could give specific feedback about what to change. The agent can execute. But someone has to have opinions about what looks right.

What This Means for a CS Classroom

If I'm being honest, I'm more uncertain than I am confident here. I don't have clean answers. But here's where my thinking is landing.

The focus on syntax can probably loosen up a bit. I've spent years in intro CS classes helping students debug missing semicolons and mismatched brackets. If a student is going to build something real using an AI agent, their bottleneck isn't going to be semicolons. It's going to be whether they can describe what they want, understand the system they're building, and evaluate whether what they got is actually correct.

That last part, evaluation, seems really important to me right now. When the AI writes the code, someone still has to check whether it's right. Whether it does what it's supposed to do. Whether it handles the cases you haven't thought of yet. That's a skill we can teach, and it might be more valuable now than it was before.

The "idea people" in my classes (the students who had great concepts for apps but got frustrated the moment they had to think about syntax) might actually be able to build things now. That's exciting. But "I have an idea" without "I understand what I'm asking for" still runs into walls.

The Crossroads

I've been thinking about this tweet I almost sent:

More and more I think we're at a crossroads with teaching CS and AI. From all the projects that I've done over the past couple of months with AI I've noticed that I've touched code nearly never, but knowing the basis of how the program is working in the background has been irreplaceable. Is the question now how do we teach these students the background of CS, how data structures work, what kind of things are possible with databases and how can they also be dangerous? What kind of information are apps taking in and how do we as the humans behind the programming (even if we don't touch the code) responsible for the data?

That last sentence is the one that keeps sticking with me. The human behind the programming is responsible for the data.

If a student builds an app using AI and that app collects user information, stores it in a database, or shares it somewhere, who is responsible for that? The AI didn't make a choice. The student who prompted the AI did. Even if they never thought about how the database was structured. Even if they never read the code that handles the storage. If someone gets sued or fired for misuse of data, it'll be the human, not the AI agent.

This is a new kind of literacy that CS education needs to address. Not just how do data structures work, but what can go wrong with them, what can they be used for, who has access, what are the legal and ethical responsibilities that come with building software that touches other people's data.

That's not something you can just outsource to the agent.

The E-Bike

An e-bike still requires you to know how to ride a bike. You still have to steer, balance, read traffic, make judgment calls. The motor handles the effort layer. It doesn't handle any of the decisions.

Someone who doesn't know how to ride, on an e-bike, is going to crash faster and harder than they would on a regular bike. The assist doesn't save them. It just gets them into trouble quicker. And they're still feeling the pain from mistakes made.

But a capable rider on an e-bike can cover ground they never could before. They can go further, take on hills that would have stopped them, arrive somewhere actually useful instead of exhausted.

I think that's where CS education is right now. AI is the motor. The question is whether we're teaching students to ride, or just handing them the e-bike and hoping for the best.

From Velocipedia by Gianluca Gimini. In 2009, Gimini started asking people to draw a bicycle from memory, then built 3D renderings of exactly what they drew. Most people can ride a bike. Almost nobody can actually draw one that works.

Next Post Previous Post