Contents

What's Inside

Chapter One

How AI Actually Works

Let's begin with a small confession: most of what you've heard about AI is either breathless hype or doom-laden panic, and neither is terribly useful when you're just trying to get an email written. So before we touch a single tool, I'd like to give you something far more valuable — an accurate mental model of what's actually happening when you type a message into ChatGPT, Claude or Gemini.

Here's the heart of it. A Large Language Model doesn't know anything in the way you and I know things. It's an extraordinarily sophisticated pattern-matching machine — autocomplete on steroids, if you like. Once you understand that, everything else about working with AI starts to make sense: why it's brilliant at some tasks, why it confidently makes things up, and why the way you phrase a request matters so much.

The journey of a prompt

When you press send, your message goes on a five-step journey:

1. Your prompt arrives as raw text. The model receives nothing but the words you typed. It has no idea who you are, what you look like, or what you had for breakfast.
2. Tokenisation. Your text is chopped into tokens — chunks of words, subwords or characters. "Understanding" might become ["Under", "stand", "ing"]. Each token maps to a number, because computers deal in numbers.
3. Embedding and attention. Each token becomes a position in "meaning space", and the attention mechanism works out which words relate to which. "Bank" near "river" means something quite different from "bank" near "money" — and the model can tell.
4. Next-token prediction. The model calculates the probability of every possible next token. It doesn't know the answer — it predicts what text is statistically most likely to follow.
5. Token-by-token output. One token is chosen, appended, and the whole process repeats. That's why responses appear to "stream" in — they're being built one piece at a time.

Three dials that control behaviour

Three concepts govern how these models behave, what they cost, and how creative or focused their output is.

Tokens are the currency of AI. Everything you send and everything you receive is measured in them, and API pricing is charged by them. (For most individuals, mind, a flat monthly subscription is far better value than paying per token — API pricing matters mainly if you're building products on AI.)

The context window is the model's working memory — how much text it can consider at once. In 2026 most frontier models offer windows of a million tokens or more, enough to paste in entire books. But bigger isn't always better: models can lose focus in very long contexts, so put your most critical content at the beginning or the end of your prompt.

Temperature controls how "random" the model's choices are. Low temperature (0.0–0.3) gives focused, predictable output — ideal for factual tasks, code and data extraction. Medium (0.5–0.8) suits writing and general conversation. High (1.0+) is for brainstorming and creative work, where you want delightful surprises rather than safe answers.

Hallucinations: the confident fib

Because the model predicts plausible text rather than checking facts, it will sometimes state things that are completely false — with total confidence. We call these hallucinations, and they are not a bug you can switch off; they're a direct consequence of how the technology works.

The answer isn't to distrust everything, but to scale your verification to the stakes. A casual email? A quick scan for howlers will do. A legal contract, a financial report, a medical question? Check every claim. A sensible verification habit looks like this:

• Check names, dates, statistics and citations against original sources — these are hallucination hotspots.
• Ask the model "How confident are you in that? What might be wrong?" — it's surprisingly good at second-guessing itself.
• Cross-check important answers with a second model or a proper search.
• Never forward AI output on a high-stakes matter without a human read-through. That human is you.

Your new mental model

Pull all of this together and you get a picture worth keeping: AI is a brilliant, tireless, occasionally over-confident assistant with no memory of who you are, an encyclopaedic feel for patterns in human writing, and absolutely no stake in whether what it tells you is true. Treat it accordingly — delegate generously, verify proportionately — and you'll get enormous value from every chapter that follows.

Chapter Two

Prompt Engineering Essentials

If Chapter One was about how the machine thinks, this chapter is about how you should talk to it. Prompt engineering sounds frightfully technical, but it's really just the craft of being clear — and it's the single highest-leverage skill in this entire book. A vague input produces a vague output. The model completes what you start, so start well.

The Act-Explain-Please framework

The course's core framework has three parts, and the name tells you the order:

• Act — tell the AI who to be. "Act as a professional communications coach." A role sets the expertise, tone and vocabulary of everything that follows.
• Explain — give it the context only you possess. The situation, the audience, the constraints, the history. You know your world intimately; the AI knows none of it until you say so.
• Please — state exactly what you want, including the format. Length, structure, tone, deliverable.

Watch what this does to an everyday request. Before:

And after:

The AI now knows who to be, what it's working with, and exactly what you want. That single habit will improve the majority of your AI interactions overnight. (If you've read my RCTF article — Role, Context, Task, Format — you'll recognise the same DNA. Use whichever sticks.)

Scaffolding: stop asking for everything at once

For anything complex, don't request the finished article in one go. Break the task into steps that build on each other, like scaffolding around a building. Ask for an outline first, refine it, then ask for each part in turn. You stay in control of direction, and the quality of the final output rises dramatically because each step rests on an approved foundation.

Chain-of-thought: make it show its working

For reasoning tasks — analysis, maths, anything with logic — add one magic ingredient: ask the model to think step by step before answering.

This dramatically improves accuracy, and as a bonus you can inspect the reasoning and spot exactly where it went astray.

Teaching by example: few-shot prompting

Zero-shot means asking without examples — fine for common, well-understood tasks. Few-shot means showing the model two or three examples of what good looks like before asking for your version. If you want output in a particular voice, structure or style, a few examples beat a paragraph of description every time. Reach for few-shot whenever the task is unusual, the format is fussy, or the first zero-shot attempt missed the mark.

Advanced patterns

Once the basics are second nature, professionals stack a few extra patterns on top:

• Persona stacking — combine roles: "Act as a copywriter with a background in behavioural psychology."
• Output formatting — specify the exact shape: a table with named columns, a numbered checklist, JSON.
• Constraint setting — say what to avoid: "No jargon. Under 200 words. Don't mention price."
• Meta-prompting — ask the AI to improve your prompt before you run it. Delightfully circular, remarkably effective.
• System prompts — standing instructions that set behaviour for a whole conversation, like giving someone their job description before their first day.

The most effective prompts often combine two or three of these — persona stacking plus formatting plus constraints is a particularly happy marriage.

Chapter Three

Thinking With AI

Most people treat AI like a search engine: ask a question, take the answer, move on. That's leaving most of the value on the table. The real magic begins when you use AI as a thinking partner — a tireless collaborator that helps you reframe problems, challenge your assumptions, and stress-test decisions before you commit to them.

From answers to conversations

A thinking partnership is a dialogue, not a transaction. Bring the AI a genuinely knotty problem and work through it in stages: describe the challenge, ask the AI to restate it from three different perspectives, have it list the assumptions hiding in your framing, then explore solutions. The more honestly you describe your real situation, the better the thinking that comes back.

Better decisions with structure

For decisions with real stakes, structure beats vibes. Build a simple decision matrix: list your options, define your criteria, weight each criterion by importance, and score every option against every criterion. Then — and this is the step most people skip — hand the whole thing to the AI and ask it to argue with you:

You remain the decision-maker. The AI's job is to make sure you've earned your conclusion.

Brainstorming that actually works

AI is a phenomenal ideation partner because it never gets tired, embarrassed, or attached to its own ideas. Classic brainstorming methods adapt beautifully: SCAMPER (substitute, combine, adapt, modify, put to other use, eliminate, reverse), reverse brainstorming ("how would we make this problem worse?"), six thinking hats, and simple volume games ("give me thirty ideas; the first twenty will be obvious — push on"). Ask for quantity first and quality second; you can always cull, but you can't cull what was never suggested.

Analysis and strategy

The classic strategy frameworks — SWOT, Porter's Five Forces, PESTLE and friends — pair wonderfully with AI. Fill in a SWOT grid yourself (you know your business; it doesn't), then ask the AI for the cross-quadrant analysis humans rarely bother with: How can strength X neutralise threat Y? Which weaknesses make which opportunities unreachable? That second-order thinking is where strategy actually lives.

Evaluating what comes back

Not all AI output deserves your trust, and the skill of critical evaluation is what separates professionals from passengers. Rate any important output against six criteria: accuracy, completeness, relevance, reasoning quality, clarity, and usefulness. Where it falls short, don't start again — refine:

Chapter Four · Tool facts checked June 2026

The Chatbots: ChatGPT, Claude & Gemini

Now that you can prompt properly, let's talk about where to point those prompts. The chatbots are your daily drivers — and the question I'm asked most often is "which one is best?" The honest answer: there isn't one. The best model is the one that's best for your specific task, and many professionals happily use two or three a day, switching as the job changes. Think of them as tools in a toolbox, not competitors in a race.

The big three (plus a useful fourth)

ChatGPT (OpenAI) is the all-rounder — superb at general tasks, writing and analysis, with the largest ecosystem of features bolted on: image generation, voice, custom GPTs and more. If you only use one tool, this is the safest default.

Claude (Anthropic) excels at nuanced reasoning and long-form work. Writers tend to fall for its prose style; analysts appreciate how well it holds an argument together across a long document. It's the one I reach for when the thinking matters more than the speed.

Gemini (Google) is the research and multimodal champion, with deep Google integration and class-leading recall across enormous contexts — handy when you're working with very long documents or live information.

Perplexity deserves an honourable mention as the search specialist: it answers with citations by default, which makes it a lovely first stop for factual research (more on research workflows in Chapter Six).

Choosing in practice

Two practical notes. First, the model versions and headline features change every few months — that's precisely why this is a living book, so trust the online edition over an old PDF. Second, your prompting skills transfer completely: everything from Chapter Two works on all of these tools, which is why we learned the craft before the brands.

Chapter Five · Tool facts checked June 2026

Image Generation: Midjourney, ChatGPT Images & Nano Banana

AI image generation has crossed the line from party trick to professional tool, and the difference between amateur and professional results is — you guessed it — the prompt. The good news: everything you learned in Chapter Two applies here too, just with a visual vocabulary.

The anatomy of an image prompt

Strong image prompts share a common skeleton: subject (what we're looking at), setting (where), style (photographic? watercolour? 3D render?), composition (framing, angle, rule of thirds), lighting (golden hour, studio softbox, neon), and mood. When a prompt disappoints, diagnose it against that list — nine times out of ten, a component is simply missing. A useful habit is prompt deconstruction: when you see an AI image you admire, reverse-engineer which of those components produced each quality.

Midjourney: the stylist

Midjourney remains the tool of choice when aesthetic quality is the point. It rewards structured prompts and offers parameters that work like dials on a camera:

• --stylize — low values follow your prompt literally; high values let Midjourney be more artistic.
• --chaos — higher values produce more varied, unexpected results between generations.
• --weird — introduces experimental, unconventional aesthetics. Use sparingly, or don't — I'm not your mum.
• --q (quality) — trades generation speed against detail.

ChatGPT Images: the conversationalist

ChatGPT's image generation shines for iterative work — because it lives inside a conversation, you can generate an image and then simply say "warmer lighting, move the subject left, make it square". For composition control, describe placement explicitly (foreground/background, left third, eye level) and specify aspect ratio. Build a personal library of style keywords — film stocks, lighting setups, art movements — and your consistency improves enormously.

Style consistency across a project

One beautiful image is luck; ten cohesive ones are craft. The trick is a style lock: a fixed prompt prefix capturing palette, lighting, medium and mood, which you reuse verbatim across every image in the project, changing only the subject. Write it once, save it somewhere safe, and your brand assets stop looking like ten different artists had a disagreement.

Nano Banana and AI photo editing

Editing existing photos with natural language — remove this, relight that, extend the background — has become genuinely practical. Google's Nano Banana (in AI Studio and the Gemini app) leads this category: upload a photo and describe the change in plain English. The craft is in precise instructions: name the element, the change, and what must stay untouched — "Remove the parked car on the left; keep the lighting and everything else exactly as it is."

Chapter Six · Tool facts checked June 2026

Research & Creation: NotebookLM, Suno, Gamma & AI Video

This chapter is a tour of the specialist tools — the ones that do a single job remarkably well. Each gets a compact treatment: what it's for, how to prompt it, and the one habit that separates good results from great ones.

Deep research with NotebookLM

Google's NotebookLM flips the usual AI arrangement on its head: instead of answering from its training data, it answers only from sources you upload — papers, reports, transcripts, web pages. That makes it the antidote to hallucination for research work: every answer is grounded in, and cited against, your own materials. Use it to interrogate long documents, generate study guides, and produce its rather famous audio overviews. The habit that matters: structure your research as a plan before you start — define the question, gather diverse sources, interrogate them, then fact-check the synthesis. AI accelerates every phase, but the sequence is yours to drive.

Music with Suno

Suno generates complete songs — vocals, instruments, structure — from a text prompt. The craft is specificity: genre (or a fusion of two), mood, tempo, vocal style, and song structure all belong in the prompt, and lyrics can be your own. It's marvellous for jingles, podcast themes, mood pieces and the sheer joy of hearing your shopping list performed as a power ballad.

Presentations with Gamma

Gamma turns a structured brief into a designed deck in minutes. The mistake is asking for "a presentation about X"; the craft is writing a proper brief — audience, purpose, number of slides, and a slide-by-slide outline of the argument. Gamma handles the design; you keep custody of the thinking. Then refine: check flow, trim text-heavy slides, and make sure each slide earns its place.

AI video

Text-to-video is the youngest of these crafts and the fastest-moving — current leaders include Google's Gemini-powered video tools and Runway. Video prompts borrow the image checklist from Chapter Five and add motion: camera movement (slow dolly in, handheld, aerial), subject action, and pacing. Keep clips short and specific, and plan a sequence of shots rather than one long take — exactly as a filmmaker would. Speaking as one: storyboards still matter.

From experiments to production

The thread joining all of these: moving AI from party trick to daily workflow. Pick the use cases that recur — the weekly report, the monthly deck, the social assets — and build a repeatable template around each: a saved prompt, a style lock, a checklist. Production AI is boring AI, and boring is where the hours come back.

Chapter Seven · Tool facts checked June 2026

Agentic Workflows: Zapier & Make

Everything so far has been you and an AI, taking turns. This chapter is where AI starts doing things while you're at lunch — and where a little engineering discipline pays for itself many times over.

Chat, workflow, or agent?

There are three levels of AI autonomy, and choosing the right one is half the battle:

• Chat — you ask, it answers, you act. Full human control. Right for anything novel, sensitive or one-off.
• Workflow — a predefined sequence of steps that runs automatically, with AI handling specific stages. Right for repetitive, predictable tasks.
• Agent — AI that decides for itself which steps to take towards a goal. Powerful, and the level demanding the most caution.

Most of the value for most people lives in the middle. Resist the siren call of full autonomy until the workflow version has run reliably for a while.

Designing multi-step systems

Good automations are designed like good recipes: explicit steps, clear handoffs, and human checkpoints wherever a mistake would be costly. The pattern to memorise: trigger → gather → AI step → human review → action. An email arrives (trigger), relevant data is collected (gather), AI drafts a response (AI step), you approve it (review), it sends (action). As trust builds, you widen the AI's lane — but you decide when, based on observed performance rather than optimism.

Zapier: the friendly one

Zapier is the easiest way in: thousands of app integrations and a gentle interface for "when this happens, do that" automations. Classic wins include summarising incoming enquiries into Slack, drafting personalised follow-up emails from form submissions, and auto-tagging support tickets by topic and urgency. A lovely trick from the course: describe your repetitive task to ChatGPT in plain English and ask it to design the Zap — steps, apps and prompts included.

Make: the powerful one

Make (formerly Integromat) is Zapier's more technical sibling — a visual canvas of nodes and branches suited to complex scenarios: multi-path logic, loops, data transformation. It's typically cheaper at volume and considerably more flexible, at the cost of a steeper learning curve. The honest rule of thumb: start with Zapier; move a workflow to Make when it outgrows straight lines.

Agent risk: the six questions

Before giving any AI system autonomy, score it against six dimensions — this is the course's risk scorecard, and it fits on a sticky note:

1. Data sensitivity — what can it read?
2. Autonomy — what can it do without asking?
3. Blast radius — how much damage could one bad action cause?
4. Reversibility — can mistakes be undone?
5. Regulatory exposure — does it touch anything compliance cares about?
6. Public visibility — do its mistakes happen in front of customers?

High scores don't mean "don't" — they mean smaller steps, more checkpoints, and a human hand on the tiller a while longer.

Chapter Eight · Tool facts checked June 2026

Vibe Coding: Building Your Own Apps

Here's a sentence that would have sounded absurd a few years ago: you can now build working software without knowing how to program. Vibe coding is the art of describing what you want and letting AI build it. You don't need to know HTML, CSS or JavaScript — you need to know what you want and how to describe it clearly. Which, conveniently, is the skill this book has been teaching you since Chapter Two.

Your first mini-app

Start small and personal: a unit converter for your hobby, a habit tracker, a quiz for your kids, a calculator for your business's pricing. Describe it to ChatGPT or Claude and ask for a single, self-contained HTML file you can open in a browser. The key insight from the course bears repeating: you describe WHAT you want, not HOW to build it.

Spec first, build second

For anything beyond a toy, think before you build. Write a short specification — purpose, users, the screens, the data it handles, what "done" looks like — and then convert the spec into a build prompt. Good specs lead to dramatically better AI-generated code on the first attempt, for exactly the reason good briefs lead to better essays. (You can even have the AI draft the spec: describe your idea roughly and ask it to write the specification, then correct it. Reviewing is easier than authoring.)

Choosing a platform

When a single HTML file stops being enough, AI-powered development platforms take over. The 2026 landscape, briskly:

Steal like a describer

A skill the course calls reverse engineering: when you see an app or interface you admire, practise describing it precisely — the layout, the components, the interactions, the states. "A three-column kanban board with drag-and-drop cards, each card showing title, due date and a coloured priority dot." The better you can describe what you see, the better you can summon what you imagine.

When it breaks (it will)

Error messages aren't scary; they're information. The debugging ritual: copy the full error, describe what you expected, what happened instead, and what you'd just changed — then hand the lot to the AI.

Chapter Nine

Safety, Ethics & Good Judgement

If the rest of this book has been about what AI can do, this chapter is about what it should do — and more importantly, what you should do with it. None of this is hand-wringing; it's professionalism. The people who use AI well for the next decade will be the ones others trust with it.

The honest limitations

Let's gather the caveats scattered through this book into one place. AI systems hallucinate confidently (Chapter One). They reflect the biases of the text they were trained on — which means the biases of us, at scale. They have no understanding of consequences. And they're persuasive, which makes their errors more dangerous than a clumsy tool's would be. None of this argues against using AI; all of it argues for using AI with your eyes open.

Everyday ethics

The thorny moments aren't sci-fi scenarios; they're Tuesday afternoons. Should you tell a client AI drafted the report? (If they'd feel deceived on finding out — yes.) Can you feed customer data into a chatbot? (Not without checking where that data goes and what your privacy commitments say.) Is AI-assisted work still your work? (The judgement, the verification and the accountability are yours; that's precisely what makes it yours.) A reliable compass for the grey areas:

• Transparency — would you be comfortable if everyone involved knew how this was made?
• Accountability — you own the output. "The AI got it wrong" is not a defence anyone accepts.
• Privacy — never paste in personal or confidential data without knowing where it goes.
• Proportionality — match your verification effort to the stakes (the rule from Chapter One, promoted to a principle).

A policy worth having

If you lead a team, the question isn't whether your people use AI — they already do — but whether they're using it consistently and safely. A useful AI policy fits on a page and answers five questions: which tools are approved, what data may never be shared, where human review is mandatory, how AI use is disclosed, and who to ask when unsure. Write it with your team rather than at them; the conversation is half the value.

Chapter Ten

Your AI Roadmap

We've reached the final chapter, which is really the first chapter of what you do next. Knowledge that isn't scheduled tends to evaporate — so let's turn everything you've read into a plan.

Take stock honestly

Start with a candid self-assessment across the book's four sections: How sound is your mental model of AI? How strong is your prompting? Which tools have you actually used, rather than read about? Have you automated anything? Built anything? Score yourself from one to five on each — no one's watching. Your lowest scores are your syllabus.

The 90-day plan

Ninety days is long enough to transform your working habits and short enough to stay interesting. A shape that works:

• Weeks 1–3: Foundations. Daily AI use with Act-Explain-Please. Build your personal prompt library — every prompt that works gets saved.
• Weeks 4–6: Tools. Run the model comparison from Chapter Four. Adopt one specialist tool from Chapters Five and Six properly.
• Weeks 7–9: Building. Ship one automation (Chapter Seven) and one mini-app (Chapter Eight). Modest is fine; shipped is mandatory.
• Weeks 10–12: Integration. Write your AI policy, fold the best workflows into your real work, and teach someone else what you've learned.

That last item is no afterthought. Teaching is the fastest way to discover what you actually understand — plan a thirty-minute "introduction to AI" session for a colleague, a friend or your long-suffering family, and your own knowledge will reorganise itself remarkably.

Keeping up without drowning

The field moves weekly and you have a life. The sane approach: pick two or three trusted sources and ignore the rest of the noise — one newsletter, one community or podcast, plus this book's online edition, which is updated as the tools change. Then protect a fortnightly half-hour of tinkering time to try one new thing. Skills compound; panic doesn't.

Where it's all heading

From the vantage point of 2026: models keep getting more capable and cheaper, agents are graduating from demos to dependable colleagues, and the gap that matters is no longer access to AI — everyone has access — but skill in directing it. That's the gap this book was built to close. The curve from 2022's chatbot curiosity to today's agentic tools has been steep, and there's no sign of a plateau; the habits you've built here — clear briefs, healthy scepticism, proportionate trust — are precisely the ones that transfer to whatever arrives next.