Exploring AI in the Classroom

A large language model is, at its core, a prediction engine. It’s software that was trained on a massive corpus of text — books, websites, articles, code, forums, encyclopedias — and learned statistical patterns in how language works. It does not understand content. It does not retrieve facts from a database. It assembles statistically likely sequences of text, one piece at a time.

The basic unit isn’t even a word. LLMs process tokens — subword pieces. The word “understanding” becomes three tokens: “under,” “stand,” “ing.” This is why models can handle misspellings and new words, but it also means the model never “reads” your text the way you do. It processes numerical sequences. Everything an LLM does is one operation repeated: read all tokens so far, calculate the probability of every possible next token, select one, add it to the sequence, and repeat.

The output looks intelligent because the patterns were learned from trillions of words of human-written text. The sophistication is inherited, not generated. There is no reasoning engine, no comprehension module. The breakthrough that makes it feel coherent is the attention mechanism — when predicting the next word, the model weighs which previous words in the passage matter most, tracking relationships across the entire input rather than just the word immediately before.

Three technical concepts come up often. Temperature controls randomness — low temperature produces predictable, conservative responses; high temperature produces creative, varied, riskier ones. Context window is how much text the model can “see” at once, measured in tokens, ranging from thousands to millions. Fine-tuning is specializing a general model for a particular task — ChatGPT is a fine-tuned version of GPT, optimized for conversation. The base model is a general text predictor; the product you use has been shaped on top of that.

The practical takeaway: AI, without tools, is the most confident liar you’ll ever meet. It doesn’t browse the internet. It produces text from patterns learned during training. When it generates a citation, the output reads like a real citation because the model has seen thousands of them — not because it looked one up. This is hallucination, and it’s a feature of the architecture, not a bug to be patched. AI detection tools work the same way — statistical patterns, not reading for meaning.

We don’t yet have shared language for when AI use is acceptable and when it isn’t. The Stoplight Framework is a simple, assignment-level tool that gives faculty and students a common vocabulary.

GREEN AI use is encouraged or expected. Students brainstorm essay topics with AI, generate practice quiz questions from their notes, or use AI to survey a topic landscape before diving deeper. The learning happens in what the student does with the output, not in the output itself.

YELLOW AI is permitted with conditions. A student might use AI to help structure a paper but must write all content independently, or use AI to identify bugs in code but must explain the fix in their own words. Yellow assignments require guardrails: attribution of AI use, written reflection on what was changed and why, revision logs showing the process, or prior instructor permission.

RED AI use is not permitted. Timed in-class essays that assess unassisted writing ability. Oral examination responses that require verbal demonstration of knowledge. Portfolio reflection pieces where authentic voice is the point.

The framework is simple, but the boundaries aren’t always clean. Consider: you allow AI for brainstorming. A student brainstorms with AI, then organizes their ideas with AI, then drafts a paragraph with AI. At what point did brainstorming become writing? The student followed the logic of each step. There is no clean line, and that’s why policies need to be specific about process — not just classification.

The deeper lesson is that most academic integrity conflicts come from ambiguity, not dishonesty. Clear expectations before the assignment prevent detective work after it. A student who knows “this is a yellow assignment — you may use AI to outline, but all prose must be yours, and submit your chat log” has a completely different relationship to the tool than a student guessing where the line is.

The quality of AI output depends entirely on the quality of the instruction. Vague in, vague out. The CORE framework gives faculty (and students) a repeatable structure for writing prompts that produce useful results:

Context — Who is the audience? What do they already know?
Objective — What should the output accomplish?
Requirements — Format, length, constraints, tone.
Expectations — What does a good result look like? What should it avoid?

The difference is dramatic. “Explain photosynthesis” produces generic, textbook-level output. “Explain photosynthesis to a community college biology student who struggles with abstract processes. Use a kitchen analogy. Under 200 words.” produces something targeted, tailored, and immediately useful. Same model, same knowledge base — different instruction.

Each element does measurable work. Remove context and the output doesn’t match your audience. Remove requirements and you get the wrong format or length. Remove expectations and the model doesn’t know what quality looks like. Faculty who tested this during the seminar — building a discipline-specific prompt live — saw the output improve with each element they added.

The most important mindset shift: iteration is the process. Your first prompt will rarely produce exactly what you want. That’s normal. Revise the prompt based on what you see — this is skill, not magic. The same principle applies when teaching students to use AI: the ability to write a good prompt and critically evaluate the output is the competency, not the ability to get an answer on the first try.

A student submits an excellent paper but can’t explain any of its arguments in a follow-up conversation. They become defensive when asked. It could be legitimate work by a student who struggles verbally, anxiety about being accused rather than guilt, or genuinely different skills in writing versus speaking. Or it could be AI-generated work the student can’t defend, defensiveness masking dishonesty, or a pattern worth investigating further. You don’t know. The question isn’t “what’s the answer” — it’s “what’s your process?”

Equity adds another layer. You teach two sections of the same course. One has students with reliable laptops and internet access. The other does not. How do you set AI policy across both? A blanket ban penalizes students in the first section who could benefit from the tool. Blanket permission advantages those with access over those without. Same policy, same intent — but equal treatment and equitable treatment point in different directions. There’s no clean answer, and the seminar didn’t pretend there was one.

The session worked through these scenarios not to arrive at a “correct” response but to model how to think through hard situations. The answer to the opening scenario — your best student submits a suspiciously polished paper — depends on decisions you haven’t made yet: what your AI policy says, how you communicated it, and what process you have for conversations like that one. Those decisions are yours. The seminar was about giving you the framework and the language to make them well.