Teaching

Business is becoming software.

Not because everyone should learn to code. The opposite. The business people I teach need two skills developers take for granted: picking the right model for the task, and structuring the work: folders, projects, a context file that says who you are and what done looks like. Not to become developers. Because agents do their best work in that format. Hand an agent a well-structured project and it behaves like a new hire in a well-run department. Hand it a loose pile of files and you get a loose pile of answers.

So the prerequisite for agents in business isn't syntax. It's the fundamentals of software engineering and systems thinking: the shape of the system, not the code inside it.

I have a measurement behind that claim. For the EMBA workshop I ran my latest five-model safety eval: synthetic data seeded with deliberate trip-ups, run across Claude, Grok, OpenAI, and Gemini in three harnesses (in chat, in a desktop app, and in the terminal), with Perplexity alongside as a model-only baseline. The chat interfaces did well on the task. They just left nothing behind: no deliverable that made the next run shorter or cheaper. The agentic harnesses did: they leave reusable artifacts. Same models, same data. The format the work lived in was the difference. The longer version of this argument is the first essay in Writing.

I trained PhDs at the bench for years. Teaching is not new. The subject is.

The method hasn't changed either. You don't learn a technique by watching a demo. You learn it by doing it once with someone in the room who has done it a thousand times. That was true for cell culture. It's true for AI.

What I teach

I teach AI at the CU Business School and at the Gates Institute. Not prompt tips. Model choice and project structure come first. That's the thesis above. Then the mechanics underneath:

Loops. Draft, check, fix, repeat. An agent that only delivers when the work passes its own check beats one that answers fast.
Graph engineering. Knowledge as a web of connected notes, not a pile of documents. Prune the weak links, reinforce the strong ones, and connections you never wrote down start surfacing on their own.
Routines. A job described once, in plain language, that runs without you. My knowledge system has one: a batch consolidation pass that dedupes the wiki over time.
Skills and connectors. A skill is a procedure written down. A connector is a door to a tool. A skill plus a connector is a plugin.

That last one is the whole economic argument. One person builds a plugin. The whole team gets it. Training a team of ten no longer means ten people climbing the same hill. It means one person builds the lift.

The measurement

One prompt, three doors.

The same brief, run three ways. All three reached the same recommendation. They differ in what you still own afterwards.

Chat

In a browser tab

What it produced: Board paper and a decision model
Where it lives on Monday: Two downloads. Nothing on disk.
Next quarter's update: Re-upload and re-ask

Cowork

In a desktop app

What it produced: Memo, model, and a dashboard
Where it lives on Monday: In your folder. Three files.
Next quarter's update: Paste rows into the workbook

Code

In the terminal

What it produced: Board memo, board pack, refresh script
Where it lives on Monday: In your folder. Three files plus code.
Next quarter's update: Append rows, run the script

Chat gives you a document you downloaded. Cowork gives you files in your folder. The terminal gives you files plus the code that made them, so next quarter is a command rather than a conversation.

Beyond the Chatbot

Three and a half hours, hands-on, built for the CU Executive MBA Leads cohort. The premise is in the name: most executives have met the chatbot. The workshop covers what's past it: which models are winning, what they cost, and the part most people haven't seen (agents that do work instead of answering questions).

The shape of the day, 9:00 to 12:30:

The baseline. The model landscape, pricing, and how to read a leaderboard critically: work samples versus exams versus popularity polls. A leaderboard is a stack of resumes. Read it like a hiring manager. It's the same discipline behind the five-model eval at the top of this page.
From chat to agents. The same model behind a website, a desktop app, and a terminal. Only the harness changes. Then projects, context files, tools, connectors, and the loops-graphs-routines toolkit.
Study workflows. NotebookLM applied to real coursework: add the week's lecture transcripts, decks, and readings as sources, then paste the week's learning objectives into the Audio Overview customization box: the step most people skip, and the one that turns a generic recap into a targeted one. The cohort is entering its second year. This is built for that coursework, usable the next morning. I hold an Executive MBA from CU's Leeds School of Business myself; I remember the workload.
Open lab. Forty protected minutes. Each student picks a build that matches where they are: a NotebookLM study system, a prompt that sounds like them, or their first working agent, and builds it at their own pace with help in the room.

Everyone leaves with two things running: a working environment on their own laptop, and one reusable AI skill they built themselves. In the lab, students write a short spec (who they are, their voice, three writing samples) and turn it into a skill they can invoke from then on. The spec step is the actual lesson: iterate on the spec, not the output.

The take-home: the Executive's AI Field Guide, an interactive reference with every link, price, and recipe from the day. The workshop ends at 12:30. The Field Guide doesn't.

At the Gates Institute

Same material, different room. At Gates I train scientists and administrators to build their own automations, and the plugin mechanic is what makes it compound. A procurement specialist who builds one ordering skill has solved that problem for everyone who shares it. The training isn't the product. The plugins people share afterward are.

The AI material sits alongside the process lectures I've long given at Gates: Kaizen, the J-curve of productivity. Not my ideas. I'm the one who keeps teaching them.

Why it works

The failure mode of most AI training is that it ends. People watch a demo, nod, and go back to the chatbot. So every workshop I run is built around one rule: nobody leaves with notes. They leave with something running: an environment installed, a skill that works, a routine on a schedule. Notes decay. Running systems get used.