Day 8 · the through-line

AI Agency

Borrow the tool — don't outsource the thinking

You can now turn to an AI and say "write me ten lines of Python to score the sentiment of these comments," and ten seconds later you have ten working lines. The question this course cares about isn't can the machine write the code — it plainly can. It's the one you'll have to answer about every line it hands you: do you understand it well enough to judge it?

The promise is real

Be fair to the tool first. AI-assisted coding genuinely lowers the barrier: you can act without having memorized every function, spend your energy on the question instead of the syntax, and build in an afternoon what used to take a semester. This is not cheating, and it isn't new in spirit — programmers have borrowed code from manuals, colleagues, and Stack Overflow for decades. Borrowing the tool is normal practice, and this course expects it; you'll lean on libraries you didn't write (VADER, pandas, Gensim) all term.

The risk is also real

The danger isn't borrowing — it's borrowing what you can't read. Code you didn't write and can't explain is a black box:

"It runs on my test data… but will it hold on real data? I can't tell — I don't actually know what it
does."

When the box breaks (and it will), you're stuck: you can't debug what you never understood. Subtler is the quiet failure — pseudo-agency: you feel powerful ("I built this!") while becoming more dependent, unable to modify, maintain, or vouch for the thing with your name on it. And you can't weigh the biases baked into the tool — whose data trained it, what it quietly treats as normal — if you take its output as a given.

Scaffold, not replacement

So the line isn't "AI or no AI." It's scaffold vs. replacement.

• Scaffold: the AI handles boilerplate; you hold the research question, the definitions, the interpretation — and you can explain, test, and extend every line. You come out understanding more.
• Replacement: you paste a prompt, paste the answer, submit. You come out understanding nothing, and the AI has spoken for you.

That's the gap between two literacies: one that can adapt, debug, and critique what it borrows, and one that can only copy and paste. The course's rule follows directly — and it's in your syllabus: you must be able to explain any code you submit, and you note in a #comment where AI helped and what you changed.

Learning a language vs. letting someone speak for you

Here's the distinction that decides which literacy you're building. Learning a language means you know what each piece does, you can adapt it to a new situation, and you can fix it when it breaks. The other thing — output that runs but that you can't explain, adapt, or repair — is ventriloquism: the words come out of your mouth, but someone else is choosing them.

This is where coding and writing meet, and where the rule flips. Nobody's voice lives in a stopword list, so borrow the tool freely — understand it, judge it, move on. But your reflections, your discussion posts, and your capstone essay are your voice, and a voice is forged only in the friction of finding your own words. Let an AI write your code and you've saved time; let it write your prose and you've handed away the one thing this course exists to grow. Borrow the tool; never outsource the voice — and know which is which. (Ted Chiang calls ChatGPT "a blurry JPEG of the web": a lossy copy of the text it learned from. A voice worth having is the opposite of a blur.)

Eloquence is not evidence

There's one more property of the machine's writing you have to reckon with: it is fluent — confident, structured, grammatically flawless — whether it is right or wrong.

That matters because of a shortcut your gut has been using your whole life. For a long time, polished prose was expensive: producing it usually meant someone had done real work, so polish was a rough (never perfect) proxy for the mind behind it. Language models broke that correlation. Fluency is now free — and it reads exactly the same when the claim is true and when it is invented. Our instincts haven't updated: a well-made paragraph still feels vetted before any judgment has convened. Stephen Colbert popularized a word for that feeling — truthiness, when something feels true from the gut before the evidence arrives. An AI is a machine for making anything feel gut-true.

Philosophy has a blunter word. Harry Frankfurt distinguished the liar — who knows the truth and conceals it — from the bullshitter, who simply doesn't care what's true, only what lands. Some philosophers now argue "hallucination" is the wrong name for AI errors: a hallucination implies a mind mistaking false for true, but a language model has no regard for truth at all — it produces the most plausible next words, and when they're true, that's incidental. On their argument (Hicks, Humphries and Slater, 2024), an LLM is a bullshit engine in Frankfurt's strict sense, even when it happens to be right. You don't have to accept the label to take the practical point: fluency can't count as evidence.

None of this is new; only the machinery is. In Plato's dialogue Gorgias, the rhetorician Gorgias boasts that a skilled speaker would beat the physician in a debate about medicine, before an audience that knew no medicine (Gorgias 456b–c; Socrates presses the "before the ignorant" point at 459a–b) — because eloquence feels like expertise from the inside. And Greek had a word for what settles into a person (or a city) that gets its beliefs that way: amathia. Plato uses it for a deeper kind of ignorance (see Laws 689a–b). The sharp contrast that follows is this course's interpretation, extended to the AI era, not a fixed Greek definition: not ignorance — agnoia, which more information fixes — but un-wisdom: the condition of the well-informed, well-assisted person whom nothing any longer teaches. Remember the Day-1 diagram? Amathia is the shadow at its bottom-right corner: knowledge that never becomes wisdom, because the labor between them — the friction where understanding actually happens — got outsourced.

Two things to carry out of that word. First, it points at us, never at them. Amathia is not a diagnosis you hand to the commenters in our data or to anyone across a political argument; it's the temptation you face every time an eloquent answer arrives faster than your judgment. Second, the fix is not an attitude ("trust AI less") — attitudes don't beat gut-level habits. The fix is procedural friction: run the code, check the citation, find the source, read the seams. Which is exactly where we're headed. The refrain to keep, right next to the score is never the meaning: eloquence is not evidence.

Today: read the seams

That's exactly today's lab. You'll take a chunk of AI-written code, read it line by line, and improve it — practicing the judgment that turns borrowing into understanding. Then we plant the stylometry seed: learning to read for the seams between human and machine writing — the tells of a voice that was averaged into being versus one that was lived into being.

Here is the kind of word counter an AI assistant will happily write for you:

def count_words(text):
    counts = {}
    for word in text.split():
        counts[word] = counts.get(word, 0) + 1
    return counts

It runs, and it looks finished. Reading it is another matter. What is word on each pass through the loop? What does .get(word, 0) do? You haven't seen it yet, which is exactly the situation borrowed code puts you in: find out before you trust it. And are "Commandments" and "commandments," one word or two? (Two. .split() keeps capital letters and punctuation, so the counter splits one word into several. Remember the 13 and the 25 from the opening lecture.)

What does "understanding the code" look like, concretely? You can say what each line takes in and hands back; name the type of each important variable; predict what an unusual input will do; name at least one thing the code gets wrong; and change one thing and test that the change worked. That's also what the syllabus asks of any code you borrow: be able to explain it, and note in your #comments where AI helped and what you changed.

Carry one question out of here: are you learning to think computationally, or just outsourcing the thinking? The same tool allows either. The difference is whether you can still explain, judge, and own what you made — and whether the words are finally yours. As always: make the choice visible — cite the AI, and say what you changed.

Going deeper (optional): Douglas Rushkoff, Program or Be Programmed; Ted Chiang, "ChatGPT Is a Blurry JPEG of the Web" (The New Yorker, 2023); Nick Montfort, Exploratory Programming for the Arts and Humanities; Harry Frankfurt, On Bullshit (2005); Michael Townsen Hicks, James Humphries & Joe Slater, "ChatGPT Is Bullshit" (Ethics and Information Technology, 2024); Plato, Gorgias (the original argument about persuasion without knowledge).