What is AI?

AI stands for artificial intelligence: computer systems that do things we normally associate with human thinking, such as writing, translating, recognizing a face in a photo, or answering a question asked in plain language. Ordinary software follows rules a programmer typed out. The systems people mean today did not get those rules. They found their own patterns across millions of photos or billions of pages of text, and they answer by predicting what fits.

Here is the difference in one example. An old spam filter runs on a rule a person wrote: if the subject line says FREE MONEY, bin it. A learned spam filter gets shown a million emails already sorted into spam and not spam, and works out the signals itself, including ones nobody would have thought to write down. Same job, opposite direction. You have been using this second kind for years without calling it AI: phone autocomplete, the photo app that finds every picture of your dog, the suggestions that decide what you watch next.

The idea is old, and for most of its life it ran the other way. John McCarthy coined the name in a 1955 proposal for a workshop held at Dartmouth College the following summer, and for decades after that AI mostly meant hand-written rules and logic. The field cycled between waves of funding and long dry spells. Learning from examples only became the mainstream approach in roughly the last fifteen years. Two things changed recently. One was capability, the other was access.

The capability change was scale, plus a design that Google researchers published in 2017 called the transformer. Earlier designs read text one word at a time. The transformer takes in a whole passage at once, which lets training run in parallel across thousands of chips and swallow far more text than before. Feed it enough text and enough computing power and you get a large language model: a system that has read a huge slice of everything people have written down and is good at predicting what comes next. That is what sits behind ChatGPT, Claude and Gemini.

The access change is the one that put AI in front of you. Early large models were awkward, because they completed text rather than answered questions. Training them on human feedback to follow instructions is what turned a text completer into something you could talk to, and putting that behind a chat box meant using it took no code, no training data, no technical setup. ChatGPT opened to the public on 30 November 2022 and reached a million users in five days. You typed a sentence in your own words and something sensible came back. That is when everyone started talking about it at once.

The same kind of model has kept growing since. It now reads your documents, looks at images, works through a problem in steps before it answers, and can connect to your calendar, your email and your files, so it carries out multi-step jobs instead of only replying to them.

That is why the conversation feels like it began with ChatGPT, even though the research is seventy years old. The pieces were not invented in 2022. They just got handed to everyone at once.

Everyone got the words at the same moment as the tool, which is why they get swapped around when they mean different things. Three of these fit inside each other, and the chatbot is the box you type into. A few neighbouring terms ride along with them, so they are in the table too. Artificial intelligence is the field. Machine learning is the method inside it, deep learning is the kind of machine learning that took over, and an LLM is one thing built that way. A chatbot is the window sitting in front of it.

Picture the nested ones as boxes inside boxes. The chatbot is not one of the boxes, it is the surface you reach through. An agent is that same model handed tools and a task. AGI is not in the stack at all: a destination, and for now mostly a word in sales copy.

When something goes wrong, people say the AI is broken, and they rarely know which part they mean. Sometimes it is the layer around the model: a search that pulled the wrong page, a file cut off before the model saw it, a tool that failed without a word. More often the answer came from the model itself, shaped by what it was and was not told. To see why that happens, it helps to know what the model is actually doing when it answers.

The same trick explains why it writes a usable email and why it will invent a fact with a straight face.

Your phone keyboard guesses your next word. A language model does the same thing, with far more of the sentence in view. You give it some text. It works out which small piece of text most plausibly follows, adds it, reads the whole thing again, and picks the next piece. It repeats until it stops. Those pieces are called tokens, roughly four characters each, so a short word is one token and a longer one splits into two or three. That is the core operation, and it is what sits inside ChatGPT, Claude, and Gemini. A large language model, or LLM, is a model built to do exactly this. There is no database it looks things up in. What it knows is baked into its internal settings, not filed as records it can pull up.

The guessing was learned, and that is what training means. The model was shown trillions of tokens, and every time its guess missed, its internal settings were nudged. Repeat that for months and you do not end up with a copy of the text. You end up with a compressed sense of how language tends to go. Then a second stage does something different. The model is trained again on human feedback about which answers people prefer, and for code and maths, on whether the answer actually passed a test. That second stage is what turns a text predictor into an assistant that answers you, and it matters for the rest of this.

That is enough to produce working code, because code is language with unusually strict habits. Most lines in a working function were predictable from the lines above them, and modern models get the rest by being graded on whether the code actually ran. Email is simpler. A polite follow-up has a familiar shape, and reproducing that shape is what the model is best at. Often it is all you needed, which is why these tools feel reliable well before they have earned it.

Nothing in that basic loop checks whether the text is true. Fluency and accuracy come out of the same process, so they arrive sounding alike. The model is not completely blind to its own ignorance: inside it there are signals that track whether it recognises what is being asked, and it does sometimes hedge or refuse. But those signals are unreliable, and they lean toward answering anyway. So when the model knows something, it sounds calm and certain. When it has no idea, it often sounds exactly the same. Part of the reason is how these models were graded: on most tests a confident guess scores better than "I do not know," so guessing is what got trained in. The usual word for the result is hallucination, which is too soft. The model is not lying. It is producing the most plausible continuation, and a plausible-looking citation is not the same as a real one.

So how confident an answer sounds is a weak guide to whether it is right, not a reliable one. A model that sounds certain is sometimes correct and sometimes inventing, and the tone barely shifts between the two. Names, dates, numbers, quotes, citations, anything you are about to act on: check it yourself. Asking for sources helps, and a tool that searches the web and cites what it found is a genuinely different proposition from one answering offline from memory. Just remember the citation is checkable too, and often worth checking. That one habit is most of the difference between people who get real value from these tools and people who get embarrassed by them.

That split runs right down the middle of what these tools can do. Current models are strong wherever the shape of the language is the job. Drafting, rewriting, translating. Writing and fixing code. Turning ten pages of notes into one page of structure, or explaining a field you are new to at whatever level you ask for. They are fast, and they do not get bored on the tenth revision.

They are unreliable about facts, for the reason the last section gave: nothing in predicting the next word checks whether the word is true. A model that does not know something often does not say so. It fills the gap with a thing shaped like an answer: a plausible date, a citation for a paper that does not exist, a confident paragraph about your industry that is half right.

One thing that trips people up: how you ask changes what you get. The same question, phrased two ways, can give two different answers, and a vague question gets a vague answer back.

And a model only knows what you put in front of it. Not your files, not your calendar, not what you told it yesterday. Those last gaps are where most people quietly decide these tools are not for their real work, and they are worth taking one at a time.

Ask ChatGPT what is on your calendar tomorrow. On its own, it cannot look. It can only read what you paste into the box. The model runs on a company's servers, your calendar sits in your Google account, your files sit on your laptop, and by default nothing joins them. You get a good conversation, and nothing on your desk moves.

What a real connection adds is not intelligence but reach. The same model that guessed at your week can open the calendar, read the project folder, and draft the reply with the real figures in it.

Each of those links used to be built by hand, a separate integration for every pairing of tool and app, so most people got none. MCP removed that work. It stands for Model Context Protocol, an open standard first published and open-sourced by Anthropic on 25 November 2024. It gives an app one shared way to plug into any tool. Someone builds the connector once, and any app that speaks MCP can use it, whichever model is inside. ChatGPT and Claude both speak it now.

Anthropic launched it with a handful of ready-made connectors, among them Google Drive, Slack, GitHub and Postgres. By 2026, public directories listed tens of thousands, though they count code repositories rather than distinct working tools, and they disagree with each other by a wide margin. The full explanation, with sources, is in what MCP is.

My own setup is one connector to a single folder of plain text notes I own. On Monday I asked which of last week's promises I had not kept, and instead of guessing it read the folder and gave me three. Two were right.

Access runs both ways. A model that can send mail can be talked into sending the wrong mail, and the talking is usually done by something it reads, a document or a web page, not by you. Connect one tool at a time, and know what each connection is allowed to touch.

Reach is one half of the gap. Memory is the other, and it is the one people ask about most, so it is worth answering plainly. A little. ChatGPT, Claude and Gemini now keep a few notes about you between chats. The model underneath keeps no memory of you, and those notes stay on the vendor's side, not yours.

The model itself carries nothing over. Open a new chat and it does not know your clients, your prices, or what you decided on Tuesday, unless that information is put in front of it again.

Whatever it knows about you at any moment sits in the context window: the text in front of it right now. Picture the whiteboard in a meeting room. Your question, the file you pasted, the model's own replies, all of it goes on the board and stays readable while the meeting runs. Then it gets wiped for the next group. In a long session it is not even a clean record. Once the board fills up, the earliest parts get summarised or pushed off to make room.

The board has a size, measured in those same tokens from earlier. The biggest models today take about a million tokens at once, a couple of thousand pages, which sounds generous right up until the wipe.

This is why demos go so well. Write a limerick. Cut this paragraph in half. Explain this article. Everything the model needs arrives with the request. Your real work arrives with nothing. A useful answer about your pricing depends on knowing your pricing, and none of your pricing is on the board. That is not mostly a prompting problem, and the product is not broken. It is how these systems work, which means better prompting alone will not close the gap.

So people repeat themselves. They keep a scratch document of background and paste it into every new chat, or they retype the same explanation until they decide the tool is more trouble than it is worth.

The memory feature helps with some of this. Underneath, it is a set of notes the system writes about you and slips back into the context window on your behalf. What goes into them is mostly the system's call, though you can open the list and read or edit what is there. The real limits are elsewhere. The notes live in the vendor's account, they hold what the system judged worth keeping rather than everything you know, and none of it follows you when you switch tools.

Which leaves the question that matters: if context is what makes AI useful to you, where should yours live?

Five things worth writing down, and why they belong in separate files.

Not in the vendor's account, is the honest answer. Their memory notes are useful and not yours: their file, in their format, on their servers, gone the day you switch tools. So decide for yourself what the model knows before each question. Write it down once, keep it in files on your own disk, and point whichever model you use at those files when a session starts. That sounds like one file. It is not. It is these five:

1. Constitution, the rules. Who you are, how you want the AI to talk to you, and what it has to ask before it acts.
2. Memory, what it knows. Your clients, your projects, your decisions and why you made them, in files you can read yourself.
3. Skills, the procedures. Jobs you want done the same way every time, written down as steps so you stop explaining them from scratch.
4. Tools, what it can touch. Your calendar, your email, your files, and where it has to stop.
5. Focus, what matters now. The one page that says what you are working on this week.

They belong apart because they change at very different rates. Your rules move rarely, and every move is a decision you sat down for. Your focus moves on Sunday evening. Keep all five in one lump and you rewrite the lump to move a single line.

You do not need all five to start. Write Focus first: one page, this week, what you are working on and what is in your way. Paste it in before your next question and see whether the answer gets sharper. If it does, the other four are the same move repeated.

None of it is clever. Plain text on your own disk, readable without an app and legible to whichever model you are paying for next year. You still rent the model. You stop renting the context. The layers in full.

Start smaller than five files. Open the plainest text editor on your computer. Not a new app, not another subscription. Write half a page about yourself, save it as a .txt or .md file, and keep it somewhere you can find it.

Put four things in it. What you do and who you do it for. What you are working on right now, with real names and real dates. The decisions you make most weeks. And how you want the answers back, down to the two or three lines on what it should never do. Write that fourth part as instructions: answer in short paragraphs, ask me before assuming anything about my business, say so when you do not know.

Then paste it at the top of your next conversation, above the actual question. The same file works in ChatGPT, Claude and Gemini, and it will still work next year when you switch. Write it once and you stop retyping it. Your file is the part of the context you chose, sitting in front of the model on purpose instead of by accident.

Mine is about a page, and a version of it goes into almost every conversation I have.

Starter files, including a sample you can edit line by line, are on /resources. Everything here is free and needs no signup.

If you want to know when the next one goes up, there is a waiting list. That one asks for an email, and it is the only thing here that does.