Building and Learning with AI

This is an AI-first course. You are here to build real things and to learn by building them, with AI as your main tool. You are expected to use AI on every assignment, starting in the first week.

You will work with tools like GitHub Copilot, Claude, and ChatGPT throughout the semester. You will not spend it memorizing syntax. You will learn to direct AI, read what it produces, judge whether it is sound, and correct it when it is wrong. Developing that ability is the focus of this course. The work covers the whole job of building a product, from writing a PRD to deploying it.

🔑 The one rule: understand what you ship

You can use any AI tool on any assignment. The one thing you cannot do is hand in work you do not understand.

You should know your own project well enough to explain what the important parts do, change them, and fix them when they break. You will not be asked to defend every line, and nobody expects you to recite a CSS reset from memory. But if the instructor asks you to walk through your code and a whole section is a black box to you, that is treated the same as turning in someone else's work.

The project showcases, the walkthrough that ends each one, and the questions you get in class all exist for one reason: to check that you actually understand what you built.

🏷️ Every assignment tells you which mode it is in

How much AI to use is not a judgment call you have to make on your own. Every assignment is labeled with one of three levels, because the right answer differs by task:

By hand. Write it yourself. This is used for a small number of short exercises, and the reason is always stated. The point is to give you first-hand contact with something before you read an AI version of it.
AI writes, you check. This is the normal mode for this course. Generate freely, then read every line and be ready to explain any of it.
You direct, you verify. This is the mode for the projects. Decompose the problem, give the AI agent the context it needs, check the result against something real, and record what you did not accept as-is.

If an assignment does not say, assume "AI writes, you check". If a limit is on the page and you are unsure why, ask. The reason is never arbitrary, and the section below on why some assignments limit your tools explains the thinking.

🔒 Be careful what you feed it

Do not paste anything personal or private into an AI tool. Once it leaves your machine you cannot control where it goes or how long it is kept. The working rule: if you would not post it publicly, do not give it to an agent.

Things worth catching before you paste: a classmate's or client's personal details, anything from a job or internship, and API keys or tokens of any kind. A key in a prompt is the same mistake as a key in a repo.

When you do have something sensitive and still want AI help, Microsoft Copilot through your Babson login is the secured option. It runs under the college's own agreement instead of a consumer account.

🎭 Give AI a role

Decide what role you want AI to play before you start typing. The same tool does very different jobs depending on how you frame it.

Tutor. Ask it to explain a concept or point you to something to read, then solve the problem yourself. "Explain what a Python list comprehension does, in two sentences with one example."
Planning partner. Before you build, talk through your approach and let it poke holes. "Here is my plan for the login page. What am I missing before I start? Do not write code yet."
Debugging partner. When something breaks, have it help you find the cause instead of handing you a patch. "Do not write the code. Ask me questions until I find the bug myself."
Researcher. Ask it to gather options and narrow them down so you can choose. "List the ways to center an element in CSS, one line each, so I can pick one."

When you work alongside it like this, you stay the driver: you set the direction and decide what to keep. The more specific you are about the role, and about what AI should not do, the more useful the answer.

🤖 Working with AI agents

Newer tools do more than answer questions. GitHub Copilot's agent mode, Claude Code, and Codex are AI agents (sometimes called agentic AI): they work in a loop, reading your code, planning a change, editing files or running commands, then checking the result and repeating until the task is done or they hand control back to you. That is powerful, and it changes your job, since you are reviewing and directing more than you are typing.

The more an agent does for you, the more your understanding matters. You are still the one who has to explain the result, fix it when it breaks, and stand behind it at a checkpoint. Never let an agent get further ahead than you can follow. If it builds something you cannot read, slow down and have it walk you through the parts before you move on.

✅ What good AI use looks like

Generate, then adapt. Ask AI to produce something, then read it and change it to fit what you are building.
Explain. Have it break down code you did not write, including your own from last week.
Debug with context. Paste an error message together with your code and work through the fix.
Simplify. Ask it to review working code and suggest a cleaner version.
Learn as you go. Use it as a tutor for any concept you hit. "Why is my layout breaking on mobile?"
Override it. Strong students disagree with AI and change its output: "It suggested this, but I changed it because..." That instinct is exactly what this course is meant to build.

🔧 When AI gets it wrong

A wrong answer usually has a cause, and the cause decides the fix. Retyping the same request gets you a different wrong answer. These are the common causes:

It never saw what you know. It does not have your file structure or the decision you made last week, so it fills the gap with a plausible guess. Fix: show it the code, the exact error, and whatever constraint it is working under. Most bad answers are this one.

The conversation ran too long. After a long thread it starts contradicting something you settled 40 messages ago, because the early part of the conversation carries less and less weight. Fix: open a fresh chat and paste in only what matters now, the current file and the current goal.

Your request had more than one reading. "Make the header better" can mean five different things. It picks one of them. Fix: describe the result you want, and name what it must leave alone.

The task is past what the tool does well. This covers library versions released after its training data, and anything that needs to watch a running browser and react to what it sees. Fix: change the task. Break it into smaller pieces, or ask for the approach and write the tricky part yourself.

Before you retype a prompt, name which of the four you are in. The fix is different in each case.

🚩 Red flags

Some ways of using AI feel efficient but quietly work against you.

Treating AI as the source of truth. AI guesses from patterns, and without enough context it hands you code that is wrong or out of date. When you need a definite answer, check the official documentation first, then use AI to help you apply it.
Pasting code you cannot explain. If you ship code you do not understand, the problem does not disappear. It moves to the next bug you cannot fix. Break the snippet into parts and ask about each one until you can explain the whole thing in your own words.
Leaning on AI for every decision. AI is a good thinking partner, but do not let it set your whole approach. Its first answer is rarely the only way to do something, and often not the best one. Ask for a couple of alternatives, try your own ideas, and compare them before you commit.
Skipping the quality check. AI code does not always follow good habits: clear names, sensible structure, nothing you would be embarrassed to show someone. Read it with that eye before you keep it. The web-specific warning signs are listed in Using AI Tools for Web Development.
Looking only for agreement. If you ask AI whether your idea is right, you will usually get a yes. Ask it what is wrong with your approach instead, or what you might be missing.

🪜 Why some assignments limit your tools

Parts of this course ask you to write something by hand, ban a framework, or want a working version before AI touches the file. Those limits are scaffolding, and they come off as the semester goes on.

Reviewing AI output takes some first-hand contact with the material. Writing the logic yourself in a mini project is the training for reviewing 200 lines an agent produces two months later.

By the final project most of the constraints are gone and the tool choices are yours.

The habit is worth borrowing for your own work. When you hit something unfamiliar, a framework you have never used or a service you have never deployed to, put the scaffolding back on yourself: build the smallest version by hand, then let AI take it from there.

⭐ What we reward

Working software. Your project loads, the main feature works, and the page does not crash.
Evidence that you built it over time. A commit history that grows across days, with messages that say what changed, beats one commit that drops the whole project at once.
Honest reflection. "The code AI gave me for checking email addresses rejected valid ones, so I read it, found why, and fixed it" tells us more than "today I learned about forms."
Knowing when to overrule AI. Catching that a suggestion is wrong, or wrong for your situation, and changing course. "It ran fine, but it would have broken on mobile, so I did it another way." That is judgment.
Building your own taste. Over the semester you start to feel when AI's answer is clean and when it is off, even when both versions work. That sense, and being able to say why, is what this whole course is built around.

AI is one tool among many. When you are stuck, the official documentation, a search engine, your classmates, and the instructor are all worth turning to.

For the practical how-to of working with AI on web code, see Using AI Tools for Web Development.

Last updated: Wednesday, 9/23/2026