Last updated: 2026-10-09
A measured, non-commercial course on personal productivity for anyone working alongside an AI assistant. Twenty-two lessons across six modules: see your work before you augment it, learn the toolkit and its economics, build the knowledge layer, codify expertise as skills, orchestrate agents while knowing the limits of delegation, and close with the discipline of doing fewer things better. No pitches, no upsells, no proprietary frameworks invented for this course.
Self-paced. Honour-based. Not accredited.
Six short modules that move from the elimination-first hierarchy through the impact equation, model routing, the three-layer knowledge base, codified skills, sub-agents and worktrees, the peer-reviewed out-of-the-loop performance problem, and the slow-productivity counterweight at the close. Practical frame, no jargon, no salesmanship.
Each module sets up the next, and every lesson pairs a productivity-tradition idea with the AI pattern that translates it into practice. The arc takes a beginner through to advanced material without skipping the foundations.
The elimination-first hierarchy, the three-term impact equation, the context audit, and the deep-shallow distinction. The honest map of where time actually goes before any tool is chosen.
Renting versus owning. Models, context windows, and routing economics. Local versus cloud, tokens, and cost discipline. Visual, desktop, and terminal surfaces. Prompts, permissions, and safe defaults.
Capture without friction, the four-folder PARA structure, the three-layer raw, wiki, and schema knowledge base, and context engineering as a systems discipline at agentic scope.
The assembly-line decomposition, the codify-before-build rule, the five-step skill construction loop, persistent memory across sessions, and outcome-named shortcuts that stay legible months later.
Sub-agents, worktrees, the routing decision, chains of skills, hooks as the deterministic layer, MCP as the integration substrate, and the peer-reviewed out-of-the-loop performance literature.
Auto-research loops, the Ralph pattern, headless workflows on current agent CLIs, dashboards as the emerging interface, and the slow-productivity counterweight that closes the course.
Start with the order of operations the rest of the course rests on: eliminate first, then automate, then delegate. The opening lesson is short and changes how the next twenty-one are read.
The first two modules assume no prior knowledge and move slowly enough that a reader who has never used an assistant agent before will keep up. The later modules introduce sub-agents, hooks, MCP, and headless workflows, but each is grounded in the foundations laid earlier. If you have been using an assistant ad hoc and want a working frame for thinking about it, this is for you. For the everyday office basics (email, meetings, spreadsheets and data policy), start with AI at Work.
The course deliberately draws on a wide set of voices across two literatures. From the productivity tradition: Drucker, Newport (Deep Work, A World Without Email, Slow Productivity), Allen, Forte, Ahrens, Ferriss, Covey, Kahneman, Csikszentmihalyi, Clear, Ohno on the Toyota production system, Boyd on the OODA loop, and the peer-reviewed human-factors literature on automation (Endsley and Kiris, Parasuraman and Riley). From the contemporary AI discourse: Engelbart and Licklider on augmentation, the published Anthropic engineering posts on how internal teams use Claude, the Karpathy LLM knowledge-base pattern, the published Model Context Protocol specification, and the recent writing on context engineering. The point of the course is to let you read all of them — and then form your own view.
Course progress, exam results, and certificate details are stored in this browser on this device. They may be removed if you clear browser data. Nothing is sent to a server.
A new tool tempts you to apply it everywhere. Most of the time saved by speeding up a task is undone by the fact the task should not have been done at all. Order of operations matters as much as the operations themselves.
Time spent and intensity of effort together produce output, but only some of that output is the kind anyone wanted. The honest equation has three terms, and improving any one of them at the cost of the others is a recognisable failure pattern.
Before any tool is chosen, the honest first step is to look at where time has gone over a recent week. The exercise is uncomfortable because the answer is almost never the answer one had in mind.
Knowledge work splits along a recognisable seam. On one side, the cognitively demanding work that produces durable value. On the other, the logistical work that keeps the lights on. Both are necessary; only one rewards an assistant well.
An assistant given nothing about you returns work that could have been written for anyone. The fix is rarely a better prompt. It is the slow accumulation of the artefacts that make the assistant yours, kept in a place you control.
Behind the assistant sits a family of models with different speeds, costs, and ceilings. Around them sits a short-term memory that fills up and degrades. Understanding both, in plain terms, is the difference between using the tool well and being puzzled by it.
Where the work actually executes, how much each interaction costs, and which model is doing the work are three decisions usually made by accident. A small amount of deliberate routing recovers the largest single source of silent waste in a productivity stack.
There is no single right place to use an assistant. There are three surfaces, well-suited to three quite different users, and the workable productivity stance is to use each for the work it was built for rather than forcing one to do everything.
A prompt that works is rarely the cleverest one. It is the one that describes the task in the way a competent collaborator would describe it. Around the prompt sits a layer of permissions whose defaults reward a little deliberate thought.
Knowledge that is not captured the moment it appears tends to evaporate by the end of the day. A capture system that lives outside the head, takes seconds to use, and trusts a tidying step later, recovers most of what otherwise leaks.
An inbox without structure is a swamp. The minimum useful structure for personal knowledge work is a small set of folders, each with a clear question it answers, and each item linked to whatever it depends on or produces.
A corpus that an assistant can reason over needs more than a flat folder. Three layers — raw sources at the bottom, a curated wiki in the middle, and a schema file at the top — produce a knowledge base that compounds rather than rots.
Prompting is about what to say. Context engineering is about what the assistant can see while you say it. The two overlap at small scale and diverge at agentic scale, where the discipline becomes one of systems design rather than wording.
Asking an assistant to do a complex thing in one shot tends to produce a competent but generic result. The remedy is older than computing: take the thing apart, work on each piece, and then put it back together in sequence.
A skill is a small file that turns a decomposed routine into a single command. The rule that matters is not how to write the file. It is that the worker writes down what good looks like, in their own judgement, before the skill is built.
Two small layers turn a tidy assistant setup into something yours: persistent memory across sessions, and named shortcuts that make a recurring move take one command. Name them after the outcome, not the mechanism.
When one assistant becomes several, the question is no longer how to prompt well but how to assign the work. Three patterns — a single agent, a sub-agent, a team of agents — cover most cases, and choosing the wrong one is more expensive than choosing the wrong words.
Skills are useful in isolation and more useful still when each feeds the next. A short chain of well-named skills produces a working system; a chain that improves its own components on every run produces compounding.
Some moves should not require an assistant to think about them at all. A hook is an event-driven script that fires the moment a defined trigger occurs. Used well, hooks remove cost; used badly, they create silent failures the assistant never notices.
Connecting an assistant to the tools you already use multiplies what it can do. It also multiplies the cost when the human disengages. The peer-reviewed literature on automation has been clear about this for thirty years.
When a task has a mechanical measure of success, a small loop can produce improvements without supervision. When it does not, the same loop produces convincing nonsense at scale. The honest practice is to use both patterns where each applies and not where they do not.
The last frontier here is the move from supervised assistance to unattended work — headless runs, scheduled tasks, the second wave of agent CLIs. The course closes with the discipline that keeps a system from chasing volume.