❯ cat pov.md # a point of view · written the way i'd teach it
A point of view · written the way I'd teach it
What AI-native professionals need to learn right now
AI made producing output almost free. It did not make judgment free. The skills worth teaching in 2026 are the ones that close that gap - and they aren't just for engineers.
Ask most professionals how they use AI and you'll hear a version of the same workflow: prompt, paste, hope it works, patch what breaks. It feels productive. It often is productive. The catch is that AI quietly fills in whatever you leave unsaid -- confidently, and not always correctly -- so the result looks finished whether or not it's right. The workflow tops out at "interesting first draft," because the person never built the muscle to tell whether the output is actually right, or how to steer it when it isn't.
I teach non-programmers to build software at Kellogg, and I watch this play out every quarter. The students who plateau are the ones who treat AI like a vending machine. The ones who take off learn to treat it like a brilliant, fast, slightly unreliable collaborator - one whose work you have to specify, direct, and verify. That shift is the whole game, and it generalizes far beyond code. A marketer, an analyst, a recruiter, an operator -- anyone doing ambitious AI-native work -- is running into the exact same wall.
The old literacy was "how do I get the machine to produce this?" The new literacy is "how do I tell whether what it produced is right - and steer it when it's not?"
The bottleneck moved. So should the curriculum.
For decades, the scarce, teachable skill was production: writing the query, the code, the memo, the model. AI collapsed the cost of production toward zero. What stayed scarce -- what got more valuable -- is everything wrapped around production. Here's what I'd actually put in front of learners, in order:
Specification
say precisely what "good" looks like - context, constraints, and what "done" means
Decomposition
break a fuzzy goal into small, checkable, well-sequenced pieces
Verification
wrap a system that guesses in deterministic checks - tests, criteria, a source of truth
Extraction & reuse
notice the repeated move, name it once, reuse it
Taste & judgment
know what's worth doing - and whether it's actually good
Those definitions are deliberately thin, and that's the pedagogy: these skills are better felt than read. Rather than argue each one in the abstract, I built a ninety-second exercise that makes you feel all five at once - it's below, and the full argument waits on the other side of it.
Stop chasing the tools.
Notice what's not on the list: a specific tool, a specific model, a prompt library. That's deliberate - and it's the umbrella over everything I teach. The market is flooded with workshops on mastering whatever shipped last month, and they expire as fast as the tools they cover. The five skills above don't expire. They transfer across every stack and every model, which makes them the only layer worth building a curriculum on.
This was my philosophy before AI: the language and the stack matter far less than learning how to build software products - which is why my course swaps its entire toolset every quarter, on purpose. AI hasn't changed that; it's confirmed it. Agentic development isn't a new discipline. It's software development with a new collaborator. Teach the fundamentals -- how, when, and why to use them -- and the latest tool becomes an afternoon's orientation instead of another course.
A signature classroom activity · live demo
The Literal Machine
This is the exercise I run on day one - adapted from the classic "exact instructions challenge." You write plain-English instructions to make a peanut butter & jelly sandwich, and a robot (played by Claude) executes them with deadpan, malicious-compliance literalness - taking you exactly at your word and surfacing every gap. (Real AI isn't this stubborn; it fills the gaps for you, silently and unreliably - the robot just makes them visible.) I built it as a small live app:
how I'd run it in class
The order matters: feel it first, then name it. I never open with the takeaways - the robot's ninety seconds of friendly embarrassment is what makes the five skills stick. But I never gate a lesson, either:
see the takeaways → (no robot required)Why this is teachable - and why I care
None of this requires a CS degree. It requires meeting learners where they are and giving them more than one way in -- hands-on, written, visual, walked-through out loud -- because adults learn differently and I've yet to meet a cohort that learns the same way. I learned to code as an adult myself; I remember exactly where the floor drops out, which is why I still build every week alongside teaching. The material never goes stale when you're in the weeds with the people you're teaching.
The frontier keeps moving. The opportunity for an education program isn't to chase each new tool - it's to keep turning what the frontier teaches us into the durable skills people can actually carry forward. That's the work I want to do.