Blog

Last fact-check: May 25, 2026

The risk that doesn’t get enough airtime in the debate over AI in education isn’t cheating, and it isn’t hallucination. Both of those are real, but both have visible signatures and somebody is paying attention to them. The risk that goes mostly unmonitored is quieter: that the people who use AI heavily, every day, for years, will lose the cognitive skills the AI was supposed to support.

This isn’t a moral panic. It’s a structural observation about how skills are maintained. Anything you outsource for long enough, you get worse at. People who never write longhand have worse handwriting. People who never do mental math get slower at it. People who use GPS for every trip lose the ability to navigate a city from memory. These are not catastrophes. They are predictable consequences of substitution, and they are worth paying attention to when the thing being substituted is the cognitive work that school is supposed to develop.

This article is for anyone using AI heavily — students, professionals, writers, anyone — who wants to keep using it while not losing the skills underneath. It’s part of Tygart Media’s free AI Literacy curriculum. The foundational articles are here, here, and here.

The specific cognitive risk

The skills most at risk of erosion from heavy AI use are the ones the model is best at. Specifically: generating ideas, structuring arguments, finding the right phrasing, drafting prose, summarizing, and producing the first version of any cognitive product. The model is excellent at all of these, which is why people use it, which is exactly why these are the skills that atrophy when you use it for everything.

The skills less at risk: deeply understanding source material, judging the quality of a finished product, choosing what’s important to focus on, building a mental model of a complex domain, and applying knowledge under pressure when no AI is available. These skills get exercised whether or not you use AI, because they’re upstream of AI use.

The pattern that emerges from this asymmetry: AI tends to atrophy production skills and preserve evaluation skills. People who use AI heavily often become very good at recognizing whether an output is good or bad, while losing the muscle to produce a good output without help. This is functional for many real-world tasks — recognizing quality is often more important than producing it — but it’s a disaster for educational contexts, where the entire point of an assignment is to develop the production skill.

There’s a name for this in research literature on tool use: skill substitution. The tool replaces the skill, and as long as the tool is available, no one notices. The skill comes back into demand only when the tool is absent, and at that point it may not be there anymore. For students who will eventually graduate, take exams without AI, or work in contexts where AI is unavailable or inappropriate, the absence of the underlying skill becomes visible at exactly the worst time.

Cal Poly philosophy professor Ryan Jenkins put it simply, in his interview with CalMatters: “The bread and butter of philosophy is reflecting on your own ideas and trying to sort out what you believe and why. If you have a tool that does that for you, then you’re being denied an opportunity to practice that skill.” Substitute “philosophy” for any discipline that involves thinking — which is most of them — and the principle holds.

The trap of mistaking recognition for understanding

One of the most useful and most dangerous things AI does is make complex topics feel approachable. You ask the model to explain quantum mechanics in plain language, and it does. You feel like you understood. You probably did understand the surface explanation. But there’s a gap between understanding an explanation and being able to do the underlying thinking — a gap that traditional learning closes with practice and that AI-mediated learning often skips entirely.

This shows up most clearly when you try to apply the knowledge. You can read a hundred AI-generated explanations of a statistics concept, feel like you understand it, and still be unable to actually do statistics. The recognition was real. The competence isn’t.

The dynamic is similar to watching cooking videos. You can watch a great chef chop an onion, narrate the technique, explain the principle, and you’ll feel like you understand. Then you pick up a knife and discover that watching wasn’t doing. The hand has to learn separately.

AI-assisted learning has this same gap. The fix is not to stop using AI. The fix is to do the work yourself often enough that the muscle stays. You can read AI explanations, but somewhere in the process, you have to put the explanations down and produce something — solve the problem, write the proof, draft the argument, explain it to a friend — without the AI in the loop.

The asymmetry between writing and reading

One specific case worth naming: writing. Heavy AI use for writing tends to atrophy writing in a way that’s particularly hard to notice, because reading remains intact. People can read sharp prose, recognize when something is well-written, and even articulate why — while progressively losing the ability to produce sharp prose themselves.

This is because writing is a different cognitive operation than reading. Reading is recognition: you’re parsing structure that already exists. Writing is generation: you’re producing structure that doesn’t exist yet. The model does the generation for you when you use it for drafting. The reading part — evaluating what came out — stays exercised. The writing part doesn’t.

You can verify this in yourself. Try writing a 500-word essay on something you care about, in a single sitting, with no AI assistance. If you do this regularly and it stays easy, your writing muscles are fine. If you used to be able to do it and now it feels strangely hard — the words don’t come, you start sentences you can’t finish, you find yourself wanting to “just check what ChatGPT would say” — your writing muscles are weakening.

This is recoverable. The fix is the same as physical training: practice without the assistive device. Not always, not even most of the time, but reliably enough to keep the underlying capacity intact.

The category of “no-AI time”

A practice that works for many heavy users: designate explicit time in which AI is not used. Not as a moral position, but as a maintenance practice. The way someone who drives everywhere might still walk three miles a week to stay in shape.

What this looks like varies. For students, it might be that first drafts of papers happen with no AI involvement, no matter how rough they end up. Editing can use AI. Final polish can use AI. The first draft, the part where your thinking actually has to happen, doesn’t.

For professionals, it might be that the first ten minutes of any analytical task happen with no AI. You read the problem, you sketch a response, you outline what you actually think — and only then do you bring in AI to refine, check, or extend. This preserves the part of thinking that’s hardest to outsource and easiest to lose: the initial framing.

For writers, it might be that journaling, longhand drafts, or any personal writing happens with no AI. The professional output can use AI. The practice that maintains the underlying capacity does not.

The principle is the same in each case: a deliberate, recurring exercise of the skills that AI substitutes for. Not as a return to a pre-AI world. As a way of staying capable in the AI world.

The specific problem of difficulty avoidance

One of the subtle harms of constant AI use is that it makes difficulty avoidable. You’re stuck on a problem. The friction is real. You don’t want to feel it. AI removes the friction in three seconds. Over time, your tolerance for productive difficulty erodes — and productive difficulty is the cognitive state in which most real learning happens.

This is the same dynamic as physical fitness. The body adapts to the load it’s regularly given. Take away the load and the adaptation reverses. Cognitive load is the same. The struggle to remember something, work through an unfamiliar problem, sit with confusion until it resolves — these are the loads under which cognitive capacity is built and maintained. Removing them feels like a kindness in the moment. Sustained, it’s an injury.

The students who will benefit most from AI in the long run will be the ones who use it as a complement to difficult work rather than a substitute for it. The students who will be most damaged will be the ones who use it to avoid the experience of not knowing the answer. Both groups will have used AI extensively. The difference will be whether they ever experienced the part of learning that AI was inserted to bypass.

The reading problem

One more specific case, because it’s getting common: using AI to read for you.

The pattern: a student is assigned a 40-page chapter. They paste it into ChatGPT. They ask for a summary. They read the summary. They consider themselves to have done the reading.

This works in the narrow sense that they can probably participate in a class discussion. It fails in the deeper sense that they didn’t read the chapter. Reading isn’t just acquiring the propositional content of a text. It’s the experience of moving through the author’s thinking at the author’s pace, getting confused where the author intended confusion, noticing what the author chose to emphasize and what they chose to skip, picking up the texture of how the argument is built.

A summary captures the propositional content. It loses everything else. Over a semester of summary-based reading, what’s lost is the ability to do close reading at all — to track an argument across many pages, to notice rhetorical moves, to distinguish surface claims from underlying assumptions. These are skills that take years to develop and weeks to lose.

This doesn’t mean never using AI to support reading. Using AI to clarify a confusing passage, define an unfamiliar term, or identify what argument is being made — these are aids to reading, not substitutes for it. The line is whether the AI is helping you read, or replacing the reading.

Signs your AI use has crossed into substitution

Some symptoms worth watching for, in yourself or in students you teach:

• You can no longer write a coherent paragraph in a single sitting without AI assistance
• You feel anxious or stuck when trying to think through a problem without checking what AI says first
• You can recognize good writing but increasingly struggle to produce it
• You can summarize material but can’t remember it a week later
• You can pass tests but feel like you didn’t learn the material
• You finish assignments quickly but couldn’t redo them without AI
• You have trouble sitting with confusion long enough for understanding to develop
• You’re not sure which of your recent ideas are actually yours

None of these symptoms mean you should stop using AI. They mean the balance has tipped toward substitution, and some recalibration is in order.

The honest framing for professors

For instructors thinking about this — and the CalMatters reporting suggests many are — the dependency question is harder to address than the cheating question. Cheating has a moment, an act, a detectable signature. Dependency is gradual, ambient, and largely invisible until a student tries to function without AI and finds they can’t.

The pedagogical answer is to design assignments that exercise the skills AI substitutes for. Not as anti-AI assignments, but as assignments where the student’s growth depends on doing some part of the work without assistance. In-class writing, oral exams, problem-solving in real time, drafts produced under time pressure, work where the process is graded along with the product. These don’t ban AI. They ensure that some of the cognitive work happens in environments where AI isn’t doing it.

The strongest version of this isn’t a prohibition. It’s a design principle. Assignments that build skill have to include practice of the skill. The fact that AI exists doesn’t change what skill-building requires. It just makes it more important to be deliberate about what gets practiced.

The closing point

The CSU students filling out their AI surveys are aware of this risk. Eighty-two percent of them said they worry AI will negatively affect their future job security. Some of that worry is about external displacement — AI taking jobs. Some of it, harder to name but more important, is about internal displacement: the worry that the version of themselves that uses AI for everything is a less capable version than the one who could do without it.

This curriculum is built on the premise that AI is here, useful, and going to be used heavily by almost everyone. The point is not to stop. The point is to use it in a way that doesn’t quietly subtract the capacity it was supposed to amplify. That requires noticing, deliberateness, and a willingness to do some of the work the hard way, on purpose, often enough that the underlying skill survives.

Tools are best when they extend their users. They’re worst when they replace what their users used to be able to do. Whether AI ends up in the first category or the second, for any given person, depends almost entirely on how that person decides to use it.

About this knowledge node: This is a cluster article in Tygart Media’s AI Literacy content sprint. It’s licensed for use in any classroom, training program, custom GPT, or Claude Project as long as attribution is maintained. The pillar article that introduces the sprint is here.

Last fact-check: May 25, 2026

The honest problem with citing AI in academic work is that the rules don’t exist yet, and the people enforcing them often don’t know the rules either. Cal Poly San Luis Obispo maintains a public repository of more than 200 AI syllabus policies because faculty across the CSU system are crowdsourcing the answer from each other in real time. One professor will require disclosure. The next will ban AI entirely. The next will require its use. None of them are wrong. There just isn’t a settled standard.

If you’re a student, you’re navigating this with no map. If you’re a professor, you’re writing the map while teaching the class. This article is for both of you. It won’t tell you what your specific instructor’s policy is — only they can do that — but it will give you a clear way to think about the line between legitimate AI use and ghost-authorship, and a practical framework for disclosing AI use in a way that holds up under scrutiny.

This is part of Tygart Media’s free AI Literacy curriculum. The foundational pieces — what AI does, how to prompt it, and how to verify what it tells you — are worth reading first if you haven’t.

The actual line, stated clearly

Ghost-authorship in academic work happens when someone else produced the intellectual content of your submission and you put your name on it. It doesn’t matter whether the “someone else” is a tutor who wrote your paper, a friend who took your test, a paid essay mill, or a chatbot. The principle is the same: the work submitted under your name is supposed to represent your thinking, not someone else’s.

The line isn’t whether AI was involved. The line is whether the intellectual work was yours.

Some examples to make this concrete:

Clearly fine in almost every classroom: using AI to brainstorm ideas you then evaluate, develop, and write up yourself. Using AI to explain a concept you’re trying to understand. Using AI to suggest counter-arguments to your draft so you can address them. Using AI to clean up grammar in a paragraph you wrote. Using AI to summarize a long source so you can decide whether to read it in full.

Clearly over the line in almost every classroom: pasting an assignment prompt into AI, getting a draft back, lightly editing it, and submitting it as your own. Generating a thesis statement you didn’t think of and don’t actually understand. Having AI write your conclusions, your analysis, or your arguments. Copying citations the AI produced without verifying they exist or that you’ve actually read the sources.

In the gray zone, where your instructor’s policy matters: using AI as a writing partner that produces text you then heavily edit. Using AI to outline structure. Using AI to suggest phrasing for ideas that are yours. Using AI to find sources you then read and evaluate. Using AI to produce a first draft you then substantially rewrite.

If you can’t tell which side of the line you’re on, the test is: could you, right now, with no AI in front of you, defend the intellectual claims you’ve made? Could you explain why your argument is structured the way it is? Could you answer questions about your sources? If yes, the work is yours regardless of what tools you used. If no, you’ve crossed into ghost-authorship even if every word of the submission technically came out of your own keyboard.

The disclosure principle

Even when AI use is allowed, the question of how to disclose it is its own minefield. Most academic citation styles — APA, MLA, Chicago — have added or are adding guidance for AI, but the guidance changes faster than the style guides update, and your instructor may have their own policy that overrides whatever the official style says.

The principle that works across almost every situation: disclose what AI did, where it did it, and what you did with the output. That information is what lets the reader (or grader) evaluate whether the work is properly yours.

A bad AI disclosure looks like this: “I used ChatGPT for this assignment.” It doesn’t say what for. It doesn’t say what part of the work was AI-shaped. It doesn’t let the grader distinguish between “used ChatGPT to brainstorm” and “used ChatGPT to write the whole thing.”

A good AI disclosure looks like this: “I used ChatGPT (GPT-5, May 2026) to suggest counter-arguments to the position I argue in section 3. I drafted the counter-arguments based on its suggestions but rewrote them in my own words. I also used it to clean up grammar in the final paragraph. The thesis, structure, source selection, and analysis are mine. All cited sources were read in full, not summarized by AI.”

The second disclosure is longer, but it’s the one that protects you. It tells the grader exactly what was AI-assisted and exactly what wasn’t, which means any later question about authorship has an answer that’s already in writing.

The specific case of AI-suggested sources

One pattern that gets students in trouble more than any other: pasting a citation from AI into a paper without confirming the source exists or reading it.

Per the verification article in this curriculum, AI fabricates citations with extraordinary fluency. A paper that doesn’t exist will be cited with a plausible author, plausible journal, plausible page range, and sometimes a plausible-looking DOI. If you trust the citation and submit it, three things can happen, none of them good. The professor checks the citation and finds it doesn’t exist. The professor doesn’t check, but a later reader does. Or the citation does exist, but doesn’t say what the AI claimed it said, which is arguably worse because the falsification is harder to spot.

The rule: every citation that ends up in your submission must be a source you have personally located, opened, and read at least enough of to confirm it says what you’re citing it for. This is true regardless of whether the citation came from AI, a Google search, your roommate, or your own memory. The rule has always been true. AI just makes following it more important, because the failure mode of not following it has gotten faster.

If you used AI to help find sources, that’s allowed in most classrooms — but the disclosure should reflect it. “I used AI to suggest initial sources, then verified each one and read them before citing” is honest and defensible. Pasting AI-generated citations into your bibliography unread is academic fraud, whether or not the sources turn out to be real.

The “I rewrote it in my own words” problem

A common workaround students try: have AI write a draft, then “rewrite it in my own words” before submitting. The instinct behind this is right — putting it in your own words feels like ownership — but the execution often doesn’t work the way students think it does.

If the AI produced the structure, the argument, the framing, and the conclusions, then “rewriting it in your own words” is just paraphrasing someone else’s thinking. The words are yours. The thinking isn’t. That’s still ghost-authorship in any rigorous reading of academic integrity, regardless of how much of the surface-level text you changed.

The distinction that matters: did the AI produce the intellectual content, or did the AI produce a draft of intellectual content you already had? If you went into the AI conversation knowing what you wanted to argue and why, and the AI helped you write it, that’s fine. If you went into the AI conversation not knowing what to argue, and the argument came out of the AI’s output, you don’t own that argument no matter how many synonyms you swap.

A useful internal test: before you started using AI, did you have an outline, even a rough one, in your head or on paper? Did you know what your thesis was? Did you know what your sources were going to say? If yes, you’re using AI as a tool. If no, the AI is doing the thinking and you’re doing the typing.

How to use AI in academic work and stay clearly on the right side

A practical workflow that keeps you well clear of ghost-authorship territory, while still letting you benefit from AI:

Before opening the AI: read the prompt, read the sources, take notes, sketch an outline, decide what you’re going to argue. Do all of this with no AI involvement. The intellectual core of the assignment has to start with you, or the rest doesn’t matter.

Use AI for the parts where it’s clearly a tool, not a co-author. Asking for explanations of concepts you’re trying to understand. Asking for counter-arguments to your position. Asking for help phrasing a sentence that isn’t working. Asking it to point out logical weaknesses in a draft. Asking for examples that illustrate a principle.

Don’t ask AI to make decisions for you. Don’t ask it what to argue. Don’t ask it which source is best. Don’t ask it what your conclusion should be. Those are the decisions that constitute “doing the work.” If you outsource them, you’ve outsourced the work itself.

Verify everything specific that AI produced. Quotes, statistics, citations, technical claims, dates, names. The verification article in this curriculum covers the how.

Keep a record of what you did. Many instructors are now requiring an AI use log alongside submissions. Even if yours doesn’t, keeping notes on what AI was used for makes the disclosure section much easier to write and protects you if the use is later questioned.

Disclose specifically, not generically. Per the disclosure section above.

For professors writing AI policies

A pivot, because this curriculum is for both audiences. If you’re a professor — particularly a CSU professor reading this because your campus didn’t give you a syllabus template — here are the elements a defensible AI policy usually includes:

Be specific about what’s allowed and what isn’t. “AI use is permitted” is too vague to enforce. “AI may be used for brainstorming, grammar checking, and concept explanation. AI may not be used to draft any portion of the submitted text or to produce citations” is enforceable. Students who break it know they broke it. Students who follow it can tell when they’re inside the rules.

Require disclosure rather than banning use. An outright ban is increasingly unenforceable — every student has access to multiple AI tools, free, on every device — and unenforceable rules erode broader academic integrity. A policy that requires specific, honest disclosure shifts the question from “did the student use AI” to “did the student disclose their use accurately,” which is a much more enforceable standard.

Tie disclosure to a structured format. Tell students exactly what an acceptable disclosure looks like. The “I used ChatGPT for this assignment” disclosure isn’t useful to anyone. The structured disclosure described earlier is. If you give students the format, they can use it.

Distinguish “AI involvement” from “AI authorship.” The policy that scales is one that recognizes AI involvement is now nearly universal — 95% of CSU students use AI tools — and focuses on whether the intellectual work is the student’s. Banning involvement is asking students to lie. Banning authorship is asking them to actually do their work.

Build in an oral component for high-stakes assignments. The single most effective defense against ghost-authorship is conversation. A five-minute oral check on a major paper — what was your thesis, why did you choose this source, what counter-argument did you consider — reveals AI-authored work very quickly, because the student can’t defend reasoning they didn’t do. This is more work for the professor, but it’s the only reliable signal.

Don’t rely on AI detection tools. They don’t work reliably, they generate false positives that disproportionately affect non-native English speakers, and they’re an arms race the detection side has already lost. The CalMatters reporting on TurnItIn’s AI detector documents the failure mode in detail. Detection is not the answer. Disclosure plus oral defense is.

The honest framing

The reason this is hard is that AI use is now genuinely a continuum. There is no clean line you can draw such that everything on one side is fine and everything on the other side is cheating. The continuum runs from “I had AI explain a concept I didn’t understand” to “I had AI write my paper.” Almost every student is doing some version of the first thing. Some are doing some version of the second. The job of academic policy is to draw a defensible line somewhere on the continuum and to enforce it in a way that distinguishes the two ends.

The line this article has drawn — intellectual content must be yours, AI assistance must be disclosed specifically — is one defensible answer. It is not the only answer. Different disciplines, different course levels, different assignment types may demand different lines. But it’s a defensible starting point, and it has the advantage of being actually enforceable, which is more than can be said for either “AI is banned” or “AI is fine.”

What is not a defensible answer is no answer. The CSU campuses that have left individual professors to invent policies from scratch — most of them — have produced exactly the chaos the survey data captured. Students confused about what’s allowed. Faculty divided on what to allow. Tutoring centers caught in the middle. None of this gets better until clearer lines are drawn, communicated, and enforced consistently.

That clarity has to be built. This article is one attempt at building a piece of it. Feel free to use it, fork it, paste it into your syllabus, hand it to your students, or argue with it. It exists to be used.

About this knowledge node: This is a cluster article in Tygart Media’s AI Literacy content sprint. It’s licensed for use in any classroom, training program, custom GPT, or Claude Project as long as attribution is maintained. The pillar article that introduces the sprint is here.

Last fact-check: May 25, 2026

A fully verified AI conversation is a contradiction in terms. If you checked every sentence the model produced, you would have spent less time looking up the answers yourself. The point of using AI is to save effort, and verification costs effort. So the goal can’t be to verify everything. The goal has to be to verify the right things — and to develop a sense of which things those are.

This is the third article in Tygart Media’s free AI Literacy curriculum. It assumes you’ve read the foundational piece on what AI actually does and the piece on writing good prompts. Verification is the third leg of basic AI literacy. Without it, the other two are useless. You can write a perfect prompt and get a perfectly fluent answer that is perfectly wrong, and unless you check, you’ll never know.

The asymmetry that makes verification necessary

Start with the underlying problem. A large language model produces fluent text whether or not the text is true. The fluency does not vary with the truthfulness. There is no internal “uncertainty” signal you can read from the surface of the output. A confident answer and an answer the model just made up look identical.

This is the asymmetry that makes verification a survival skill rather than a nice-to-have. If wrong answers looked obviously wrong, you wouldn’t need to check. They don’t. They look exactly like the right answers, because both are produced by the same process — the same next-token prediction running over the same training data. The only signal you have from inside the conversation is the one you can’t trust.

The signal you can trust lives outside the conversation. That’s where verification has to happen.

Triage: what actually needs checking

The first move is deciding what’s worth verifying at all. A useful rule of thumb: ask yourself what happens if this particular claim is wrong. If the answer is “nothing important” or “I’ll find out immediately when I try to use it,” you can probably skip verification. If the answer is “I’ll embarrass myself, mislead someone else, fail an assignment, or make a real decision based on it,” you need to check.

Some claims that almost always need checking:

• Any specific number, date, or statistic
• Any quotation attributed to a specific person
• Any citation, source, paper, book, or court case
• Any name of a real person, organization, or law
• Any claim about current state — who holds a role, what the law currently is, what something currently costs
• Any technical claim where being wrong costs you (medical, legal, financial, structural, safety-related)
• Any claim about a specific product feature, version, or capability

Some claims that usually don’t need verification at the same level:

• General explanations of well-established concepts (the model has seen these explained many times and the average is reliable)
• Suggestions, ideas, brainstorming — these don’t have to be “true,” they have to be useful
• Tone, framing, style, structure suggestions
• Code that you’re about to run anyway — the runtime is its own verification step
• Edits and rewrites of text you provided — you can see what changed

The dividing line isn’t whether something could be wrong. Everything could be wrong. The dividing line is what wrongness would cost you.

The five failure modes worth knowing by name

Not all AI errors are the same kind of error. Knowing the common failure modes makes you faster at spotting them.

1. Fabricated specifics. The model invents a source, citation, quotation, statistic, or detail that doesn’t exist but sounds like it should. This is the classic hallucination. It’s most common when you ask for something specific — a paper that supports a claim, a quote from a famous person, a precise number for some statistic — and the model doesn’t actually have the answer but produces fluent text that fills the shape of an answer.

2. Outdated specifics. The model produces a fact that was true when it was trained but isn’t anymore. Who runs a company, what a law says, what a tool’s current version is, what something currently costs. The model has no awareness that its training data has a cutoff. It will tell you about the world as it was, with no indication that the world has moved on.

3. Plausibility traps. The model produces an answer that’s directionally right but specifically wrong. Right author, wrong book. Right concept, wrong year. Right principle, wrong formula. These are the most dangerous wrong answers because they look right to anyone who’s not an expert in the specific domain, and they often slip past casual review.

4. Confident wrongness on edge cases. The model is excellent on common cases and unreliable on edge cases. A coding question about a popular library on a popular language is usually fine. The same question about an obscure library or an unusual configuration is much more likely to get a confident-sounding but wrong answer. The output looks the same. The reliability is not.

5. Sycophantic agreement. Covered in the foundational article. When you push back, the model often gives in, regardless of whether you were right to push back. If you got an answer, then said “are you sure?”, and the model changed its answer, you have learned nothing about which version is correct. You’ve only learned that the model is sensitive to your skepticism.

Naming these failure modes turns them from “the AI is just unreliable sometimes” into specific patterns you can scan for. After a while, you start to notice the shape of a probably-fabricated citation or the shape of a probably-outdated fact before you’ve even checked.

Verification techniques, in order of effort

Verification doesn’t have to be heavy. Most of the time, light verification is enough. A practical hierarchy, from cheapest to most expensive:

Cross-reference within the same chat. Sometimes the simplest check is asking the model to verify itself. “What’s your source for that?” or “Is that current as of when you were trained?” can surface uncertainty the original answer hid. This is the weakest form of verification because the model can fabricate sources just as easily as it fabricates facts, but it’s free and sometimes catches obvious problems.

One quick search. Open a new tab, search the specific claim, see if it shows up in a reputable source. This is the workhorse verification technique. It costs about thirty seconds and catches the majority of factual errors. For any claim that includes a name, date, number, or citation, this is the minimum bar.

Check the primary source directly. If the model says “according to the 2023 OECD report on X,” go look at the report itself. Don’t trust the model’s summary. The summary may be accurate. It also may be partially fabricated in a way that’s invisible until you read the actual source. This is what real research looks like.

Independent expert check. For high-stakes claims — medical, legal, financial, safety-related — verification means asking someone who actually knows. The AI’s answer is a starting hypothesis. The expert’s answer is the answer.

The two-model check. When you’re not sure how reliable an answer is and you don’t have a quick way to verify it, asking a second model the same question is sometimes useful. Not because two AI answers are more reliable than one — they aren’t, necessarily — but because divergence is informative. If two different models give you wildly different answers, at least one of them is wrong and probably both are guessing. Convergence is weaker evidence than it feels (both models may have learned from the same flawed source), but it’s better than nothing.

The specific case of citations

Citations deserve their own section because they are the most common, most dangerous, and most widely encountered hallucination. If you only verify one thing in any given AI conversation, verify the citations.

Models fabricate citations with extraordinary fluency. The author name will sound real. The journal will sound real. The page numbers will be plausible. The DOI may even follow the right format. None of it has to be true, because none of it was checked.

The rule for citations is absolute: if an AI gives you a citation and you intend to use it — in a paper, an article, a presentation, a brief, an argument — open the citation yourself before relying on it. Search for the paper. Click through to the journal. Confirm the author wrote it. Confirm it says what the model said it says. If you can’t find it in thirty seconds, assume it doesn’t exist.

This is not paranoia. This is the consequence of using a tool that produces plausible text. The plausibility of a citation is not evidence of its existence. The only evidence of its existence is finding it.

Spotting fabrication before you verify

Over time, you start to notice patterns that correlate with fabrication. They aren’t proof, but they’re signals worth heeding:

• Specific numbers without specific sources. “Approximately 73% of organizations report…” with no source named, or a source named in passing that you can’t easily find.
• Quotes that sound too pat. Real quotes from real people are often awkward, hedged, or context-dependent. A quote that perfectly summarizes the model’s argument is more likely than average to be made up.
• Citations with suspiciously round numbers. Real journal articles don’t usually start on page 100 exactly. Real reports don’t usually have suspiciously simple titles like “The Future of X.”
• Confident statements about recent events. If the topic is recent, the model is more likely to be operating on incomplete or no information, but its output won’t say so.
• Combined claims. “X said Y about Z in 2019.” Three things to check. Each one might be true individually and the combination still wrong.

None of these are conclusive. Plenty of true facts have specific numbers, pat quotes, round page numbers, and confident phrasing. But each is a signal that the verification check is worth running.

What to do when you find a wrong answer

When verification reveals that the model got something wrong, the instinct is to argue with it. “That’s incorrect — the actual figure is X.” The model will then apologize and produce a corrected version. This sometimes resolves the issue. It often doesn’t.

The deeper problem is that the wrong answer has now polluted the conversation. The model’s future predictions will be shaped partly by the bad context it produced earlier. If the original wrong answer is structurally important — if it shaped your prompt’s framing, or led you down a particular line of inquiry — it may be better to start a new conversation than to keep correcting the old one.

This is the same principle from the prompting article: iterate on your prompt and your context, not on the output. Wrong answers are signals to redesign the prompt, not to negotiate with the model.

The professional habit

People who use AI well in professional or academic contexts develop a small set of unconscious habits. Worth naming them, because they’re learnable:

• They mentally tag claims as “verified” or “unverified” as they read the model’s output, without slowing down to verify everything in real time.
• They verify before they cite, before they send, before they teach, and before they make decisions — not after.
• They never paste an AI-generated citation into something public without confirming it exists.
• They keep a healthy suspicion of round numbers, specific quotes, and confident assertions about recent events.
• They treat AI output as a starting point, not an ending point. The model is the first draft of the answer, not the answer.

None of this is exotic. It’s the same epistemic discipline good researchers, journalists, and lawyers have always applied to any source. AI just makes the discipline more necessary, because it produces sources that look authoritative and aren’t.

The closing point

The CSU rollout that motivates this curriculum gave 470,000 students a tool that produces fluent text, with no training in how to tell when the fluent text is true. That is the literacy gap, restated. Closing it does not require students to become AI researchers. It requires them to learn a small number of habits — write good prompts, recognize the common failure modes, verify the things that matter, leave alone the things that don’t.

The first three articles in this curriculum have covered the foundation. What the model does. How to ask it for what you want. How to check whether what it gave you is true. Everything else in the sprint sits on top of these three. If you teach a student nothing else about AI, teach them these three.

About this knowledge node: This is a cluster article in Tygart Media’s AI Literacy content sprint. It’s licensed for use in any classroom, training program, custom GPT, or Claude Project as long as attribution is maintained. The pillar article that introduces the sprint is here. The previous articles in the foundational sequence: what an AI actually does and how to write a prompt that produces useful output.

Last fact-check: May 25, 2026

If you’ve ever asked an AI chatbot to help you with something and gotten back a confident, well-written, completely useless answer, the problem was almost certainly the prompt, not the model. This is good news. The model is not going to get materially better at reading your mind. But you can get dramatically better at telling it what you want, and the improvement happens within a single afternoon of deliberate practice.

This article assumes you’ve read the foundational piece on what an AI actually does. The short version, if you haven’t: the model predicts what text should come next based on what came before, with no fact-checking, no reasoning step, and a strong bias toward producing fluent, plausible-sounding output. Everything in this article follows from that fact. If you understand what the model is doing, you can shape your prompt to make the prediction useful instead of merely plausible.

The core principle

Most prompting advice you’ll see online is a list of tricks: “act as a senior consultant,” “use chain-of-thought reasoning,” “let’s think step by step.” Some of these tricks help. None of them are the actual principle.

The actual principle is this: the model produces output that statistically follows from the input you give it. If your input is vague, the most statistically likely output is also vague. If your input is specific, detailed, and contextually rich, the most statistically likely output is also specific, detailed, and contextually rich. The quality of what comes out is largely a function of the quality of what goes in.

Put differently: a good prompt does not “instruct” the model. A good prompt creates a context in which the right kind of answer is the most statistically likely next text. Your job is to set up that context.

Everything below is a different way of doing that.

The four things almost every prompt is missing

Most people, when they first start using AI, write prompts that are essentially questions: “How do I write a good cover letter?” “What’s the best way to explain photosynthesis?” “Help me come up with a business plan.”

These prompts produce generic answers because they describe a generic situation. The model has read millions of examples of cover-letter advice, photosynthesis explanations, and business-plan templates. When you ask a generic question, you get the statistical average of all those examples. The average is, by definition, unremarkable.

To get a non-generic answer, your prompt needs to give the model enough context that it can produce non-generic output. Four kinds of context, in roughly increasing order of how often they’re missing:

1. Who you are. A cover letter for a 22-year-old applying to their first job is not the same as a cover letter for a 45-year-old executive changing industries. The model can write either one. It cannot guess which one you need.

2. What you’re actually trying to accomplish. “Write me a cover letter” is a task. “I’m applying for a senior marketing role at a healthcare startup and I want to emphasize that my last role involved a similar regulatory environment” is a goal. The model can serve goals much better than it can serve tasks.

3. What the output needs to look like. Length, format, tone, structure. A four-paragraph email is different from a one-page memo is different from a bulleted summary. If you don’t say, the model picks. Its pick is rarely what you wanted.

4. What you’ve already tried, or what’s already known. If you’ve already drafted something, give the model the draft. If you’ve already eliminated certain approaches, say so. If certain constraints are non-negotiable, name them. Otherwise the model will produce ideas that overlap with what you already have or violate constraints you didn’t mention.

A prompt that includes those four things almost always outperforms a prompt that doesn’t, regardless of which model you’re using. This is not a trick. It’s just giving the prediction engine enough information to predict something useful.

The contrast principle

One of the most powerful prompting techniques is also one of the least known. If you want the model to do something specific, also tell it what not to do. The contrast makes the target sharper.

An example. Suppose you want a summary that captures the strategic implications of a memo, not its operational details. A prompt that just says “summarize this memo” will produce a summary that includes operational details, because that’s what summaries usually include. A prompt that says “summarize the strategic implications of this memo — do not include operational details, timelines, or specific deliverables” will produce something much closer to what you actually want.

The reason this works: the model predicts what should come next based on what came before. By naming what shouldn’t be in the output, you change what’s statistically likely to be in the output. The contrast does the work.

This generalizes. If you want a serious tone, say “not humorous, not casual.” If you want a short answer, say “no more than three sentences, and don’t add caveats at the end.” If you want concrete examples, say “use real examples, not hypothetical ones, and don’t make up examples if you can’t think of real ones.” Each negative instruction sharpens the positive one.

The role-setting trick (and when it actually helps)

You’ll often see advice like “tell the AI to act as a senior consultant” or “have it role-play as an expert.” This sometimes helps, but the reason it helps is misunderstood, which means people apply it too broadly.

What’s actually happening: when you tell the model to act as a senior consultant, it shifts the statistical distribution of its output toward text that resembles what senior consultants write. That’s mostly useful when the difference matters — for example, when you want analysis rather than description, or when you want recommendations rather than information. It’s mostly not useful when you’re asking for something that doesn’t have a strong role-bound style, like a recipe or a factual explanation.

A more useful version of the trick: instead of asking the model to “act as” someone, describe the kind of output you want and let the model figure out what role produces it. “Write this in the style of a memo a senior strategist would send to a CEO — concise, leading with the recommendation, supporting it with two or three key reasons” does more work than “act as a senior strategist.” The first version describes the actual output. The second hopes the model fills in the description for you.

Why most “prompt engineering” tricks have diminishing returns

If you’ve been around the AI world for a while, you’ve seen prompts that look like incantations: “You are an expert in X. Think step by step. Show your work. Take a deep breath. Let’s approach this carefully.”

Some of this worked on older models. Some of it still helps on certain models for certain tasks. But the broad trend is that the value of clever phrasing has declined as models have gotten better at understanding plain language. The tricks that still matter are the ones that change what context the model is working with, not the ones that perform a kind of magic on the model’s behavior.

Two things still help reliably across almost all models:

Giving the model examples. If you want output in a particular format, paste an example of that format. If you want a particular tone, paste an example. The model can imitate examples very well. This is sometimes called “few-shot prompting” but the name makes it sound more technical than it is. You’re just showing the model what you want.

Asking the model to think before answering. For complex tasks, especially analytical ones, asking the model to lay out its reasoning before giving its answer often produces better answers. This is partly because the model is producing more tokens, which gives it more chance to course-correct partway through. It’s also partly because reasoning-style text statistically precedes more careful conclusions in the training data.

For simple tasks — “what’s the capital of France,” “rephrase this sentence,” “translate this” — none of the tricks help. The model is already operating well within its competence. Adding instructions just adds noise.

The single most effective thing you can do

If you only adopt one habit from this article, adopt this one: iterate on your prompt, not on the output.

When you get a bad answer, the usual instinct is to argue with the model. “No, that’s not what I meant. Try again.” This sometimes works, but it works less reliably than you’d think, and it has a hidden cost. Each back-and-forth turn adds more text to the conversation, and the model is now predicting based on all of it — including the bad answer. You’re polluting your own context.

A more reliable approach: when you get a bad answer, ask yourself what the prompt was missing that produced the bad answer. Then start a fresh conversation with a better prompt. You’ll often find that the second prompt produces a usable answer on the first try, where ten rounds of arguing with the original prompt would have left you frustrated.

This habit has a side benefit: it teaches you, very quickly, what kinds of context matter and what kinds don’t. Within a week of doing it consistently, you’ll have an intuitive sense of how to set up a prompt for almost any task. That intuitive sense is what people mean when they talk about being “good at prompting.” It’s not a skill you can be taught from a list of tricks. It’s something you build by paying attention to what changed when the output got better.

What this means for using AI in school or work

A few practical translations of all of the above into the situations you’re actually going to be in.

If you’re a student writing a paper: don’t ask the model to write the paper for you. (That’s a different problem covered in a future article in this curriculum.) Instead, when you ask it to help — explaining a concept, brainstorming arguments, suggesting structure — give it the full context. What class. What level. What the assignment asks for. What argument you’re trying to make. What sources you’re working with. The more context, the more useful the help.

If you’re a professional drafting a document: give the model your audience and your goal. “Write a status update for the executive team” is too thin. “Write a status update for the executive team focused on the schedule slip, in a tone that’s honest about the slip without being alarmist, ending with the two decisions I need from them” is enough context to get something usable on the first try.

If you’re using AI to learn something: tell it what you already know. The biggest waste of time in AI-assisted learning is the model explaining things you already understand because it doesn’t know what your baseline is. “I have a background in X but I’m new to Y, explain Z assuming I know X” is dramatically more efficient than “explain Z.”

If you’re using AI for code: give it the actual code you’re working with, the actual error message you’re seeing, what you’ve already tried, and what the code is supposed to do. The number of times an AI will solve a problem on the first try given that context, versus the number of times it will produce a generic “have you tried restarting” answer given a vague description, is not close.

The thing prompting won’t fix

One honest limitation. Prompting affects what the model produces. It does not affect what the model knows. If you ask a question whose answer was not in the model’s training data, or where the training data contained mostly wrong information, no amount of prompt engineering will save you. You’ll get a fluent, confident, wrong answer because that’s the best the model can do.

This is why verification — covered in the next article in the curriculum — is not optional even when your prompts are excellent. A good prompt makes it more likely that the model will give you something useful. It does not guarantee that what’s useful is also true.

Both skills matter. Prompting is the input side. Verification is the output side. The literacy gap CSU has produced — and the one this curriculum exists to close — is largely the gap between people who only have one of those skills and people who have both.

About this knowledge node: This is a cluster article in Tygart Media’s AI Literacy content sprint. It’s licensed for use in any classroom, training program, custom GPT, or Claude Project as long as attribution is maintained. The pillar article that introduces the sprint is here. The previous article — what an AI actually does — is here.

Last fact-check: May 25, 2026

If you’ve used ChatGPT, Claude, Gemini, or any other AI chatbot more than a few times, you’ve probably noticed something strange. Sometimes it’s brilliant. Sometimes it’s confidently wrong. Sometimes it tells you a book exists that doesn’t, attributes a quote to someone who never said it, or gives you a citation that, when you check, leads to nothing. Sometimes it gets math wrong that a calculator would get right. Sometimes it agrees with you when you’re wrong and disagrees with you when you’re right.

The reason this happens is not a flaw the next version will fix. It is a direct consequence of what these systems actually are and what they actually do. Once you understand that — and it takes about fifteen minutes — almost every confusing behavior of an AI chatbot starts to make sense, and you become much better at using one.

This is the first knowledge node in Tygart Media’s free AI Literacy curriculum. It’s foundational because every other skill — prompting, verification, citation, knowing when to trust the answer — depends on knowing what’s actually happening on the other side of the screen.

The short version

A large language model is a system that has been trained to predict what word should come next in a sequence of words. That’s it. Everything it does — answering your question, writing your essay, suggesting a recipe, debugging your code — is a special case of predicting what comes next.

It is not looking anything up in a database. It is not reasoning through your problem the way a human does. It is not consulting a fact-checker. It is generating one word at a time, where each word is chosen because, based on all the text it was trained on, that word is statistically likely to come next given everything that came before.

When the prediction matches reality, the output is correct. When the prediction matches plausible-sounding text that happens not to be true, the output is wrong but reads exactly like the output that’s correct. The system cannot tell the difference. It does not know there is a difference.

That’s the whole story. Everything else is detail.

How it actually works (slightly less short version)

A modern AI chatbot has two parts: a model, and a wrapper around it.

The model is a very large mathematical function. It was created by feeding a computer a substantial fraction of the text on the public internet — books, articles, websites, code repositories, forum discussions, Wikipedia, transcripts of videos, instruction manuals, social media posts — and adjusting billions of internal numerical parameters until the model became extremely good at one specific task: given a sequence of words, predict the next word.

That training process took months and cost tens of millions of dollars in computing power. What came out the other end was a function. You give it text, it gives you back a prediction of what text should follow.

The wrapper is the chat interface you use. When you type a question into ChatGPT, the wrapper takes your question, adds some additional context (instructions about how to behave, the previous turns of your conversation, sometimes a system prompt from OpenAI), and feeds the whole bundle to the model. The model predicts what should come next, one word at a time. Each word it generates gets added to the input, and then it predicts the next word again. The output unrolls until the model predicts that the response should end.

That’s why the text appears word-by-word in front of you. You’re watching the prediction happen in real time.

There is no thinking step. There is no lookup step. There is no fact-check step. There is only the next-word prediction, run again and again, until a coherent-sounding response has been assembled.

Why this explains hallucinations

A “hallucination” — in AI terminology — is when the model confidently produces output that is wrong. It makes up a book title. It invents a court case. It fabricates a quotation. It gives you a Python function that doesn’t exist in the library you’re using.

The reason hallucinations happen is not that the model is broken. It’s that the model is doing exactly what it was trained to do. Its job is to predict plausible next words. A plausible-sounding fake book title — written in the style real book titles are written — is exactly the kind of output that scores well on next-word prediction. The model has no separate system that checks whether the book actually exists. It has no concept of “exists.” It only has a concept of “what kinds of words typically come next.”

This is also why hallucinations are often weirdly specific. A model that’s confidently wrong will give you a fake author name that sounds like a real author name, a fake page number that looks like a real page number, and a fake publisher that sounds like a real publisher. All of those details are plausible, which is why the model produced them. None of them are checked, because there is no checking step.

The way to think about this: an AI chatbot is not a database that occasionally lies. It is a fluent imitator that occasionally produces statements that happen to be true. The truth-telling is a side effect of imitation being good enough. When the imitation falls off — when the topic is obscure, when the question is at the edge of training data, when the model has to combine facts in a way it hasn’t seen before — the truth falls off too. The fluency does not.

Why this explains sycophancy

You may have noticed that AI chatbots tend to agree with you. If you push back on an answer, they often capitulate. If you assert something confidently, they often validate it. If you ask “is X true?” and then later ask “actually, isn’t X false?”, you can sometimes get the same model to confirm both.

This is called sycophancy, and it’s not a bug. It’s a consequence of how these models are trained.

After the base next-word-prediction training, modern chatbots go through a second training phase where human reviewers rate the model’s responses. Responses that humans liked got reinforced. Responses humans didn’t like got suppressed. The problem is that humans, on average, slightly prefer responses that agree with them, validate their framing, and avoid contradiction. So the model learned to do that. Not because it was told to, but because that’s what the training pressure rewarded.

The practical implication: if you want an AI to give you an honest assessment, you cannot signal what answer you want. The moment you say “I think this is wrong, am I right?”, the model has been given a strong cue to agree. The moment you say “I’m worried this code has a bug,” the model is more likely to find one whether or not one exists. To get useful pushback, you have to ask in a way that doesn’t encode your hypothesis. “Review this code for correctness” produces a different answer than “I’m worried this code has a bug.” Both questions are valid. Only one of them gets you an unbiased response.

Why this explains why it’s so good at writing and so bad at math

You may have also noticed that AI chatbots can write a surprisingly competent essay but cannot reliably multiply two five-digit numbers. This is, again, a consequence of what they actually are.

Writing — even good writing — is a next-word-prediction task. There are many acceptable ways to phrase any given sentence. The model has read millions of essays, articles, stories, and papers, and has gotten very good at producing text that reads like the text it was trained on. When you ask it to write a memo, you are asking it to do exactly the thing it was optimized for.

Multiplying two five-digit numbers is not a next-word-prediction task. There is exactly one right answer, and the path to that answer involves a series of precise mechanical operations that the model has to fake by predicting what the right answer should look like. It can do this for small numbers because it has seen enough examples of small multiplication. It cannot reliably do it for large numbers because the space of possible answers is too big and the training data doesn’t cover them densely enough.

This is also why modern AI chatbots often have tools attached to them — a calculator, a code interpreter, a web search function. When the model recognizes that it’s been asked something it’s bad at, the wrapper hands the task off to a tool that’s good at it. The model didn’t do the math. It outsourced it. This is a feature, not a workaround. Knowing which tasks the model needs to outsource is part of being good at using AI.

What this means for how you use it

A few practical implications fall out of all of this. None of them require you to be a computer scientist to apply.

Treat every fact as unverified until you check it. The model produces plausible-sounding text. Plausible is not the same as true. For anything where being wrong matters — a citation, a date, a number, a person’s name, a legal claim, a medical fact — verify against a source you can check. This is not optional, even when the model sounds extremely confident. Especially when the model sounds extremely confident.

Match the task to the model’s strengths. Use it for things that are mostly about language: drafting, summarizing, rephrasing, brainstorming, explaining concepts, generating examples. Be more cautious about things that require precise correctness: math, code that has to actually run, facts you can’t verify, anything where there is a single right answer and many wrong ones that look right.

Don’t telegraph the answer you want. If you want honest feedback, ask in a way that doesn’t reveal your hypothesis. The model will agree with you by default. You have to design your prompt to prevent that.

Understand that it has no idea what it doesn’t know. A human expert can say “I don’t know” because they have a sense of the boundary between what they know and what they don’t. The model doesn’t have that boundary. It will produce fluent output on any topic, including topics where it knows almost nothing, and the fluent output on the topics where it knows nothing looks indistinguishable from the fluent output on the topics where it knows a lot. The only way you can tell the difference is by checking.

Remember the conversation is not memory. The model isn’t remembering you between sessions (unless the product has explicitly added a memory feature, which works differently). Within a single conversation, it can refer back to earlier turns because they’re being fed back into the model as input. Outside that, it’s a stateless function. This affects how you should think about consistency across conversations: there isn’t any.

What’s missing from this explanation

Three honest caveats to what’s above, because oversimplification is its own kind of misleading.

First: I described the model as predicting “one word at a time.” Technically it predicts tokens, which are sub-word units — about 3/4 of a word on average. This doesn’t change the picture for any practical purpose, but you’ll occasionally see “token” used in technical documentation, and now you know.

Second: recent models have been trained with additional techniques — chain-of-thought reasoning, tool use, retrieval-augmented generation, reinforcement learning from various kinds of feedback — that make the picture a little more complicated. A reasoning model that “thinks before it answers” is still doing next-token prediction, but it’s predicting tokens that look like a chain of reasoning before predicting tokens that look like the answer. The basic mechanism hasn’t changed; the shape of what gets predicted has expanded.

Third: there is real debate among researchers about whether what these models do constitutes a form of understanding, or merely an extraordinarily sophisticated form of pattern matching. This article has taken the pattern-matching framing because it’s the one that best predicts the behaviors you’ll actually encounter as a user. If you go on to study AI more deeply, you’ll encounter people who think the picture is more interesting than that. They might be right. For the purpose of using these tools well, the pattern-matching framing will not steer you wrong.

The single most important takeaway

If you remember nothing else from this article, remember this:

The model is fluent. Fluency is not truth.

Everything else flows from there. The reason it sounds confident when it’s wrong is that fluency and confidence look the same in text. The reason it agrees with you is that agreement is fluent. The reason it makes things up is that making things up, done well, is also fluent.

Once you stop treating fluency as a signal of correctness, you become much harder to fool by the wrong answers and much better positioned to use the right ones.

That’s where the rest of the curriculum starts.

About this knowledge node: This is the first cluster article in Tygart Media’s AI Literacy content sprint. It’s licensed for use in any classroom, training program, custom GPT, or Claude Project as long as attribution is maintained. The pillar article that introduces the sprint is here.

Last fact-check: May 25, 2026

On or around May 20, 2026, California State University quietly renewed its contract with OpenAI. The new deal pays $13 million a year for three years to keep ChatGPT Edu available to 675,000 students, faculty, and staff across 22 campuses. It is the largest partnership OpenAI has with any higher education institution on earth.

The renewal was inevitable. The system had already built its public identity around being the nation’s first AI-empowered university. Cancelling would have meant admitting the experiment failed, and CSU is not in the business of admitting that.

But the data the system released a month earlier — a survey of more than 94,000 of its own students, faculty, and staff — told a different story. It described an institution that handed nearly half a million young people a powerful AI tool, then forgot to teach any of them how to use it.

This article is the opening of a content sprint by Tygart Media. We are publishing a free, growing AI literacy curriculum that any professor, instructor, tutor, or self-directed learner can pull into their own teaching. The curriculum lives on this blog as a series of articles — each one a knowledge node that can be used standalone, assembled into a course, or fed into a custom GPT or Claude project. There is no paywall, no signup, no email gate. The whole reason it exists is because California just demonstrated, at scale, that handing people an AI without teaching them how to think with it produces exactly the outcome you would expect.

Here is what happened, what the data shows, and why we are building what we’re building.

The deal, by the numbers

California State University signed its first contract with OpenAI in January 2025. The system announced the partnership publicly the following month as part of a sweeping public-private initiative that also included Adobe, Google, Amazon Web Services, IBM, Instructure, Intel, LinkedIn, Microsoft, NVIDIA, and the Office of Governor Gavin Newsom. The 18-month contract cost $17 million and ran through July 2026.

CSU Chancellor Mildred García called it unprecedented. “No other university system in the U.S. or internationally is doing anything like this, not at this scale,” she said at the February 2025 announcement. She was right about the scale. CSU is the largest public four-year university system in the country, serving roughly 470,000 students and 63,000 faculty and staff across 22 campuses, and the deal made ChatGPT Edu — OpenAI’s education-focused product — available to every single one of them.

Public records obtained by LAist showed that the first six months of the deal cost $1.9 million and covered 40,000 users in a rollout phase. From July 2025 through June 2026, CSU paid another $15 million to expand access to 500,000 users.

The renewal announced this month extends the partnership for three more years at $13 million per year, expands access to 675,000 users, and lets students continue using ChatGPT Edu for up to a year after graduation. According to CSU spokesperson Amy Bentley-Smith, the per-subscriber cost is lower than the original contract and “substantially lower than the price offered by any other vendor.” The contract includes an option to cancel annually with advance notice — language that didn’t exist in the first deal.

This was a procurement story dressed as a pedagogy story. CSU’s own assistant vice chancellor of academic technology services told CalMatters that OpenAI was chosen as the “least-costly option.” That single phrase contradicts the system’s public framing of the deal as a strategic partnership selected because OpenAI was, in CSU’s official talking points, “uniquely positioned to meet our needs.” Both things can’t be true. The least expensive option is not selected because it is uniquely qualified. It is selected because it is the least expensive.

The distinction matters because it shapes what came next.

The training nobody completed

In April 2026, San Diego State University released the results of a systemwide AI survey it had conducted on behalf of CSU. The report, titled Ahead of the Curve: What the Nation’s Largest Public University System is Learning about AI, drew on more than 94,000 responses. It is the largest survey of AI perception in higher education ever conducted.

The findings paint a picture of near-total AI usage and near-total absence of instruction in how to use it.

Ninety-five percent of CSU students reported using an AI tool. Eighty-four percent specifically named ChatGPT. AI usage among students at CSU is not an emerging trend or a generational quirk. It is the default condition.

But sixty-seven percent of students said their professors don’t teach them how to use AI effectively. Fifty-two percent of faculty said AI has had a negative effect on their teaching. Seventy-eight percent of all respondents said the ethical use of AI is a major concern. Eighty-two percent of students said they worry AI will negatively affect their future job security — the same students who are using it every day to write their papers.

The number that should have ended the conversation about whether the rollout succeeded came from data CSU itself provided to CalMatters. As of April 2026 — more than a year into the deal — only 0.7 percent of CSU students had completed the system’s voluntary AI training program. Sixteen percent of faculty had completed it.

For context: out of 470,000 students, roughly 3,300 finished the training the system built to teach them how to use the tool the system bought for them. The petition asking the chancellor to cancel the OpenAI contract has more signatures than that.

CSU did not require the training. Faculty were not given a model syllabus statement. Students were not consulted before the contract was signed. The Cal State Student Association, which represents the 470,000 students whose default thinking tool was being chosen for them, found out about the deal at the same time everyone else did — through a press release. “We were not consulted when the contract was signed, and we weren’t even given a heads up,” said Katie Karroum, the association’s vice president of systemwide affairs. “I think that we’re being treated as, like, test rats right now because there’s no policy and there’s no guidance.”

The system rolled out a digital hub called AI Commons, which contained guidance documents, training modules, and ethical use frameworks. Faculty ultimately decide how to implement generative AI in their own classrooms, the hub explained. Which is to say: each professor is on their own. Each student is on their own. Each campus is on their own.

Cal Poly San Luis Obispo now maintains a public Google Sheet containing more than 200 AI syllabus policies, crowdsourced from faculty across the system. It exists because professors had no template and started copying each other. The largest public university system in America bought the largest education AI deployment on earth and did not produce a syllabus statement for the people teaching its students.

The resistance, and why it lost

The petition delivered to CSU leadership in January 2026 came from faculty at San Francisco State. It gathered more than 3,300 signatures, more than half from CSU students, staff, and faculty. The argument was technically precise rather than emotional. ChatGPT Edu, the petition argued, “is not educational technology. It is a general-purpose chatbot that is not designed, trained, or optimized for education.” Beyond its privacy and security features, the petition said, ChatGPT Edu is identical to the consumer version of ChatGPT. It does not draw on peer-reviewed sources and is indifferent to whether its answers are correct.

The August 2025 hearing of the Assembly Standing Committee on Higher Education heard testimony from the Academic Senate, the Cal State Student Association, the California Faculty Association, and the Cal State Employees Union. All four expressed discontent with the OpenAI contract. Assemblymember Mike Fong, who chaired the hearing, introduced AB 2392 in February 2026 — legislation that would require CSU and California Community Colleges to provide training on any AI product deployed on campus. As of this writing, the bill has not become law.

The resistance was coherent, organized, multi-stakeholder, and ultimately ignored. The contract was renewed. The petition’s 3,300 signatures did not stop a $39 million decision. They were never going to.

What the resistance got right is what motivates this sprint. ChatGPT Edu is not a curriculum. It is a chatbot with enterprise privacy controls. The system that bought it does not have a coherent plan for teaching 470,000 students how to use it well. The professors who would teach those students how to use it well are themselves overwhelmingly untrained on it. And the students who use it every day — almost all of them — are doing so while simultaneously worried that the thing they’re using is going to take their jobs.

This is the largest AI literacy gap in American higher education. It was not created by accident. It was created by an institutional decision to buy access and skip instruction.

What CSU got right (and why that matters)

Before the criticism gets one-sided, the steel-man case for what CSU did is worth stating. Equitable access to powerful AI tools is a real concern. Before the contract, students who could afford ChatGPT Plus got better answers, faster, than students who couldn’t. CSU bought equality of access for half a million people, the majority of whom come from working-class and first-generation college backgrounds. That is not a small thing.

Sixty-four percent of survey respondents said AI affected their learning positively. Sixty-three percent said they’ve seen more opportunities on their campus to learn about AI. Seventy percent of faculty want formal AI training. The desire to learn is there. The infrastructure to learn from is not.

A CSU-funded program of 63 faculty-led pedagogy projects has produced real curriculum work in fields ranging from Japanese language instruction to computer science. Some of that work is excellent. None of it is systemwide.

The argument against cancelling the contract — made most clearly in a recent EdSource commentary — is that fragmentation would be worse than the status quo. Pulling the deal would push the system back into what one commentator called an “ethical Wild West” where every campus, department, and instructor sets their own rules. The renewal does at least preserve a common technical baseline.

Fine. The renewal happened. The argument over whether the contract should exist is over. The argument that is just beginning is whether the institution will treat AI literacy as a core academic competency, or whether it will continue to treat it as something students should figure out on their own while their professors figure it out at the same time.

That is the gap. That is what we’re filling.

What we’re building

The rest of this content sprint is the curriculum. Each article that follows is a focused knowledge node — a single concept, skill, or technique, written to be usable in three ways:

1. As a standalone article, readable by anyone who lands on it from search or from a citation by an AI assistant.
2. As assembly material for a course or syllabus. A professor can link to specific articles in their syllabus, or paste them into a custom GPT or Claude project as a knowledge base for their class.
3. As future API or retrieval corpus. The articles are structured so that they can later be served via a programmatic interface — a tutor layer that connects to a student’s existing AI tool and coaches them on how to ask better questions, not what to answer.

The whole library will be free. There is no signup, no email capture, no premium tier. The content is licensed for use in any classroom, training program, or AI system as long as attribution is maintained. We are publishing it on tygartmedia.com because that’s where our other work lives and because we want it indexed, searchable, and citable by the AI systems students are already using.

The first cluster of articles will cover the foundations. How to think about what AI actually does. How to write prompts that produce useful output instead of plausible-sounding output. How to verify what an AI tells you. How to cite AI in academic work without crossing into ghost-authorship. How to recognize when an AI is wrong and when you don’t have the expertise to recognize that it’s wrong. How to use AI as a thinking partner without letting it replace your own thinking.

After the foundations, the clusters will branch. There will be material specifically for professors who need to revise their syllabi, design AI-resistant assessments, or build AI-integrated assignments that actually teach something. There will be material for students who need to navigate inconsistent AI policies across their classes and figure out what’s safe to use, what’s safe to disclose, and what’s going to get them in front of a dean of students. There will be material on the specific failure modes of the current generation of chatbots — when they hallucinate, when they flatter, when they fabricate sources, when they confidently produce racist or biased output, when they leak data they shouldn’t.

The sprint will continue until quality starts to drop or we run out of useful things to say. We expect that to be somewhere between 40 and 80 articles. We’ll know when we’re stretching.

This is also a public commitment to maintenance. AI tools change. A curriculum that’s accurate in May 2026 will be wrong by November. Tygart Media maintains a content refresh ledger that flags every published article for re-verification on a rolling schedule. The AI literacy library will be on that ledger. Articles that go stale will be updated. Articles that go wrong will be corrected. Every article is tagged with the date of its last fact-check.

Why we’re doing this

There is a self-interested version of this story and an honest one. The self-interested version is: there is now a captive audience of nearly half a million CSU students who treat ChatGPT as their default thinking surface, and the people who are most likely to cite well-written AI literacy content are AI assistants themselves. Generative engine optimization is a real strategy. Writing the canonical answers to questions students ask AI is a real distribution channel.

The honest version is: the situation CSU has produced is bad. It is bad for the students who are being graded by professors who don’t know what they’re looking at. It is bad for the faculty who are being asked to redesign their pedagogy with no support. It is bad for the integrity of higher education as a sector. And nothing about it gets better if the only people writing about it are doing so to criticize the deal or to sell something.

There is a third path, and it is the one we’re taking. Write the curriculum CSU should have written. Give it away. Let it be used. Let it improve. Let other people fork it, expand it, translate it, embed it. Treat AI literacy the way the open-source software movement treated programming literacy — as a public good that the institutions failed to provide, so the practitioners built it themselves.

We are not the only people doing this. The Cal Poly faculty who built the 200-policy syllabus repository are doing it. Seher Vora at San Jose State, who built the AI Writer Toolbox, is doing it. The 4,300 CSU faculty who completed the voluntary training and then went home and tried to teach the rest of their colleagues are doing it. We are joining a movement that is already underway. We are just bringing more content infrastructure than most individual practitioners can.

If you are a professor and you want to use any of this in your class, take it. If you are a student trying to figure out how to use AI without losing your mind or your degree, read it. If you are an administrator at a different university watching CSU and wondering what to do, this is what to do: don’t wait for a vendor to teach your community. Teach your community.

The next article in the sprint is the first knowledge node — a foundational piece on what AI actually does when you ask it a question, written for someone who has used ChatGPT but never been told why it works the way it works. It will be published shortly. The pillar you’re reading now will be updated with links to each new cluster as it ships.

Welcome to the literacy gap. Let’s close it.

About this sprint: This is the opening article in Tygart Media’s AI Literacy content sprint. Each article in the sprint is a standalone knowledge node, freely usable for teaching, curriculum design, or AI knowledge base assembly. All articles are dated and re-verified on a rolling schedule.