The Field Guide to AI

Everything a working professional actually needs to know — the history, the vocabulary, the tools people use at work, and a first build you run tonight. One page. Bookmark it.

McKinsey surveyed 1,993 organisations across 105 countries last year. 88% reported using AI somewhere in the business. About 5.5% reported that more than 5% of their profit could be attributed to it.

That gap is the whole story of AI at work right now. Adoption is universal. Value is rare. And the people closing that gap aren't the ones who read the most AI newsletters. They're the ones who understand enough of the machinery to point it at a real problem and check its work.

Five parts: where this came from, what the words mean, where it actually works, what people are using, and how you build something yourself. The last part ends with a prompt you can paste tonight.

Part 1: How we got here

You do not need the full history. You need four moments, because each one explains something about why the tools behave the way they do today.

1956 — the field gets a name

A summer workshop at Dartmouth College coins the term "artificial intelligence." For the next fifty years, the dominant approach is to write down rules: if the patient has a fever and a rash, consider measles. These are called expert systems. They work in narrow domains and shatter outside them, because nobody can write down every rule.

1997 — Deep Blue beats Kasparov

IBM's chess machine beats the world champion. This is the high-water mark of the rules-and-search approach, and it's worth knowing why it doesn't generalise: Deep Blue could evaluate 200 million chess positions per second and knew nothing else. It could not tell you what a chess piece was. Brute force in a closed world.

2012 — the machine learns instead of being told

Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton enter an image-recognition competition with a neural network called AlexNet. It scores a 15.3% error rate. Second place scores 26.2%. In machine learning, you do not win by eleven points. That gap ended the argument. Nobody wrote rules for what a cat looks like; the system learned it from examples. Everything after this is downstream of that shift, from being told to learning from data.

2017 — the architecture behind every chatbot you've used

Eight researchers at Google publish a paper titled "Attention Is All You Need," introducing the transformer. Its trick is attention: when processing a word, the model weighs how much every other word in the text matters to it. Crucially, this can be done in parallel rather than one word at a time, which means you can throw enormous amounts of computing power at it. Scale it up and you get GPT, Claude, Gemini. The "T" in ChatGPT is Transformer.

Then it left the lab. ChatGPT launched on 30 November 2022 and hit 100 million users in about two months. That was the fastest consumer-product ramp analysts at UBS had recorded in twenty years. Instagram took roughly two and a half years to do the same.

And in 2024 the field collected its receipts. Hopfield and Hinton took the Nobel Prize in Physics for the foundations of neural networks. Hassabis and Jumper took a share of the Chemistry prize for AlphaFold, which predicted the 3D structures of over 200 million proteins. Biologists had been stuck on that problem for fifty years. Two Nobel Prizes in one week. That is not a hype cycle. That is a scientific instrument.

Part 2: The vocabulary

Every field uses jargon to sort insiders from outsiders. Here's the decoder. I've ordered these so each one builds on the last.

Machine learning (ML)

Any system that improves at a task by processing data rather than by being explicitly programmed. The umbrella term. Your spam filter is machine learning.

Neural network

The specific structure used for most modern ML. Layers of simple mathematical units, loosely inspired by neurons, where the strength of each connection gets tuned during training. "Deep learning" just means a neural network with many layers.

Model

The trained artefact. The frozen result of all that tuning. When someone says "which model are you using," they mean which trained system, the way you'd ask which engine is in a car.

Parameters

The tuned numbers inside a model. Modern frontier models have hundreds of billions. Roughly a measure of capacity, not intelligence, and the labs have largely stopped publishing the counts.

Training vs. inference

Training is the months-long, hugely expensive process of building the model. Inference is what happens when you type a question and it answers. You only ever touch inference. Training already happened, which is why models have a knowledge cutoff date.

LLM (Large Language Model)

A very large transformer trained on text. Claude, ChatGPT, Gemini. It predicts the next chunk of text, over and over, faster than you can read.

Token

The unit an LLM reads and writes. Not quite a word; roughly ¾ of one. "Unbelievable" might be three tokens. Everything is priced per token, so tokens are the unit you're billed in.

Context window

How much text the model can hold in mind at once, measured in tokens. This is the single most practical spec. A large context window means you can paste an entire contract, a quarter of meeting notes, or a whole codebase and have it reason across all of it. Current frontier models handle roughly a million tokens, which is several full-length books.

Prompt / prompt engineering

Prompt — what you type. Prompt engineering — the entirely unglamorous discovery that specific, structured instructions produce dramatically better output than vague ones. This is the single highest-return skill on this page, and it's just writing a clear work instruction.

Hallucination

When the model states something false with complete confidence. Not a bug being patched; a direct consequence of "predicts plausible next text." It will invent a case citation, a statistic, a file that doesn't exist. This is the whole reason you stay in the loop. Never ship a number, name, or quote from a model without checking it.

RAG (Retrieval-Augmented Generation)

Before answering, the system searches a document store and pastes the relevant passages into the prompt. This is how "chat with your company's documents" works. It reduces hallucination because the model is reading rather than recalling.

Fine-tuning

Further training of an existing model on your specific data to change its behaviour or style. Expensive, and usually the wrong first answer. Try a better prompt, then RAG, then consider fine-tuning.

Multimodal

A model that handles images, audio and documents, not just text. You can photograph a whiteboard, a broken part, or a spreadsheet and ask about it.

Reasoning model

A model that works through a problem step by step before answering, effectively thinking longer for harder questions. Slower, more expensive, considerably better at maths, logic and multi-step planning.

Agent

A model given tools (search the web, read a file, run a command, call an API) and a goal, which then loops: act, observe the result, decide the next action. The distinction that matters: a chatbot tells you what to do. An agent does it and reports back. Nearly all the useful work of the last two years lives here.

MCP (Model Context Protocol)

An open standard Anthropic released in November 2024 for connecting AI systems to tools and data sources. OpenAI and Google DeepMind both adopted it. Its practical effect: instead of every tool needing a bespoke integration, there's one plug shape. If someone says "we exposed our database over MCP," they mean an agent can now query it.

RLHF (Reinforcement Learning from Human Feedback)

How a raw text-predictor is turned into something helpful and hard to misuse. Humans rank outputs; the model is trained toward the preferred ones. It's why the assistant is polite, and part of why it sometimes agrees with you too readily.

Part 3: Where AI actually earns its keep at work

Return to that opening statistic. 88% adopting, 5.5% seeing profit. The failures are not random. They cluster in a recognisable pattern, and so do the wins.

The wins share one property: the output is verifiable by someone who knows the domain. That's it. That's the rule. Where you can check the work, AI compounds your expertise. Where you can't, it manufactures confident nonsense at scale.

Six categories where it reliably pays, roughly in order of how quickly you'll see the benefit:

1. Compression

Turning a lot of text into a little. Fifty pages of tender response into a one-page risk summary. A quarter of customer complaints into the seven themes that actually recur. You can verify this by spot-checking the source, which is why it works.

2. Transformation

Same information, different shape. Meeting notes into a project plan. A rambling voice memo into a structured brief. An engineer's explanation into something a customer can read. Low risk, high frequency, saves hours a week.

3. The blank page

Not the finished draft. The terrible first one that gives you something to argue with. Most professionals are far better editors than they are starters. Getting to draft two in ten minutes is worth more than any "AI writes your emails" demo.

4. Extraction

Pulling structure out of mess. Every action item, owner and due date from a folder of notes. Every payment term from forty contracts. Every part number from a supplier PDF. This is where non-developers get their first genuine surprise.

5. Analysis with a checkable answer

Give a model a spreadsheet and ask which regions are underperforming and why. It's fast. It's also occasionally confidently wrong, so you check. Because you know the business, checking takes you a minute.

6. A competent, tireless colleague who has read everything

Underrated. "Argue the other side of this." "What would a sceptical CFO ask?" "What am I missing?" It has no ego and infinite patience and it will not tell your boss you asked a basic question.

And where it fails, so you don't learn this the expensive way: anything where being wrong is costly and checking is hard. Legal advice you can't evaluate. Medical judgment. Statistics you can't source. Any decision where "it sounded right" is your only quality gate. The hallucination problem doesn't get solved by trusting harder.

Here is the part most AI content will not tell you. In every one of those six categories, the bottleneck is not the model. It's knowing which problem to point it at. That judgment comes from twenty years in a domain, and it is not something the model has. Your expertise is the scarce input. The AI is just the factory.

Part 4: The tools people are actually using

Three tiers. Most professionals live in tier one and never discover that tiers two and three exist, which is where the real gains are.

Tier 1 — The chat interface

ChatGPT (OpenAI), Claude (Anthropic), Gemini (Google). All three offer a free tier, a personal paid tier around $20/month, and business plans. They are more alike than different, and the honest advice is to pick one and learn it properly rather than sampling all three badly.

The upgrade that costs nothing: stop treating it as a search box. The most valuable feature across all three is the persistent workspace (Projects in Claude and ChatGPT, Gems in Gemini). Load a project with your background documents, your style guide, your context, and a standing instruction for how to behave. Every conversation in that project starts with all of it loaded. You stop re-explaining yourself every morning.

The upgrade that costs money: Anthropic and OpenAI both shipped an agentic mode on their personal plans within days of each other in July 2026 — Claude Cowork (Pro and up, rolling out gradually) and ChatGPT Work (Plus and up). Both work the same way: you describe an outcome instead of asking a question, the agent works for minutes or hours across your files and connected apps — building a spreadsheet, drafting a deck, turning a folder of notes into a report — and reports back when it's done, including while you've closed the laptop. It's the same shift Tier 3 below describes (an agent that does the work and reports back, not one that just tells you what to do), except it now lives inside the chat app you already pay for, not a separate command-line tool.

Tier 2 — AI inside the software you already have

Microsoft 365 Copilot and Google Workspace Gemini put a model inside Word, Excel, Outlook, Docs, Sheets. The pitch is that it already has your documents and email, so you don't paste anything anywhere.

The honest read: the wins here are real but narrow. Summarising a meeting you missed, drafting a reply in the thread it lives in, asking a spreadsheet a question in English. The gap between the demo and the daily reality is wider than in tier one. This is the tier most enterprises buy and most employees quietly stop using. A decent chunk of that 88%-adopting, 5.5%-profiting gap sits right here.

Claude Team and ChatGPT Business sit between tiers: chat interfaces with company data connected, usually via MCP.

Tier 3 — Agents that use tools and touch real files

This is where the work gets done, and where almost no non-developers are standing.

Claude Code and OpenAI's Codex are command-line agents. They run in your terminal, see a folder of your actual files, and do real work across all of them: read, edit, run things, report what changed. Cursor is the same idea inside a code editor.

The name is the marketing problem. "Claude Code" sounds like it's for programmers. What it actually is: an agent that can operate on a folder of files and explain itself in plain English. The folder does not have to contain code. It can contain your meeting notes, two hundred supplier contracts, or a decade of project retrospectives.

I pointed it at a folder of 30 meeting-note files and had it add a one-line summary to the top of every one. One prompt. Under a minute of its time, about 30 minutes of mine including the install. That is not a coding task. That is admin, done once, by something that never gets bored.

Part 5: Building something

Here's the reframe. You are not going to write the code. You are going to learn to specify, and then check the result.

That's the job you already have. You've written requirements. You've reviewed a supplier's work against a spec. You've caught the thing that was technically delivered and completely wrong. Those are the skills. The typing was never the valuable part.

Andrej Karpathy, formerly of Tesla and OpenAI, named the phenomenon in February 2025: vibe coding, meaning you describe what you want in natural language and let the model produce the implementation. It became Collins Dictionary's word of the year. It's also a decent description of how to build something small and a terrible description of how to build something you'll depend on. The difference is entirely in whether you check the work.

The shapes of things you can build

When someone says "I built an app," they mean one of about five things. Knowing which one you want is most of the battle.

"Client/server" just means the split between the bit the user sees (client, in the browser) and the bit that stores and computes (server). A script has neither. That's why it's the right place to start.

The four rules that separate a useful build from a wasted weekend

1. Solve a problem you personally have

Not a portfolio project. The tedious thing you do every month. You'll know instantly whether it works, because you're the user.

2. Make it read before it writes

The first prompt in any session should change nothing. Ask it to look, describe what it sees, and tell you its plan. Half of all disasters are the model working confidently on the wrong folder.

3. Test on one before you run on all

One file. Check the result. Then let it loose on the rest. This is not timidity, it's the same instinct that stops you sending an untested mail-merge to your whole customer list.

4. Know your undo

Before anything is modified, know how to get back. Duplicate the folder. Learn one git command. Never skip this, and never let a tool talk you past it.

Your first build

This is a real script that solves a real problem: a folder of files you can never find anything in. Install Claude Code, point your terminal at a folder you own, and paste the prompt below.

I want to build a small tool, and I am not a developer. Explain each step
in plain English and stop for my approval before you create or change
any file.

WHAT I WANT:
A script that reads every PDF and Word document in this folder and
produces a single file called `index.md` containing, for each document:
  - the filename
  - a one-sentence summary of what it is
  - the date it refers to (from the contents, not the file timestamp)
  - any people or companies named in it

Sorted newest first.

HOW WE WILL WORK:
1. First, don't write anything. List what you can see in this folder
   and tell me how many documents there are and what types.
2. Then tell me your plan and what could go wrong. Wait for me to say go.
3. Then build it, but run it on THREE documents only and show me the
   output so I can check the summaries are accurate.
4. Once I confirm, run it across everything.
5. Finally, tell me in plain English how to run this again next month,
   and how to undo anything you've changed.

RULES:
- Never modify the original documents. Read only.
- If you are unsure what a document is, say "unclear" rather than guessing.
- Explain any technical term the first time you use it.

Read that prompt again, because the structure is the lesson. It states the outcome. It defines the shape of the output. It forces a read-only pass first, a plan second, a three-document sample third. It bans guessing. It demands the undo.

That is not a coding skill. That is a work instruction written for a fast, capable, slightly overconfident new hire. You have written a thousand of them.

The tools will change. The version numbers on this page will be stale within months. What won't change is the shape of the job: know which problem is worth solving, describe it precisely, check the work, keep the undo. That was your job before any of this existed.

Do it this week

Open the folder on your machine that you dread. Not a metaphor. The actual folder, the one with four years of documents and no naming convention.

Run the prompt above against it. Read the index.md it produces. Check three summaries against the real documents, and see how it did.

You'll learn more about what this technology is and isn't in that twenty minutes than in six months of reading about it. Including, when one of those summaries is confidently wrong, the most important lesson on this page.