The Ten Things You Actually Need to Understand About AI
A practical guide to the foundational concepts, mental models, and building blocks that make modern AI work—and work for you.
There's a moment, familiar to anyone who's tried to follow the AI conversation this year, where the ground shifts beneath your feet. You were keeping up—chatbots, prompts, maybe you've even used Claude or ChatGPT for something useful—and then suddenly the conversation leaps ahead. Agents. Context windows. Skills. Inference. Vibe coding. The words pile up like luggage at a carousel that's moving too fast.
This guide is for that moment. Not a glossary, not a hype piece—a practical map of the ten foundational ideas you need to hold in your head to genuinely understand what's happening with AI right now, and to start using it with intention rather than confusion.
Think of these as primitives. In the same way that understanding notes, rhythm, and harmony lets you hear music rather than just noise, these concepts will let you see the architecture beneath the surface.
1. An LLM Is a New Kind of Computer Programme
Start here, because everything else builds on it.
Traditional computer programmes are recipes: exact instructions, typed out by a human, telling a machine precise steps. They're brilliant at arithmetic and terrible at telling jokes—because you can't encode the steps that make something funny. The unexpected is, by definition, not in the recipe.
A large language model (LLM) is a different beast. It does everything traditional programmes were bad at—writing stories, generating art, coding, reasoning through ambiguity—while retaining the old capabilities. It's not magic. It's a genuinely new way of using computers.
The practical takeaway: Stop thinking of AI as a search engine with better answers. Think of it as a new kind of programme that can handle the messy, creative, ambiguous work that rigid code never could.
2. A Model Is a File (and That Matters More Than You Think)
Here's something that clarifies enormously once you grasp it: a model is a file.
During training, vast quantities of internet text get compressed into a single file. The process discards the least important information and preserves the essential patterns, ideas, and relationships. What you're left with is a file that, given half a document, can plausibly complete the other half. That's the fundamental capability—document completion—dressed up to be useful.
The numbers inside this file are called weights. And here's where it gets political:
- Open models (like DeepSeek or Qwen) let you download that file and run it yourself.
- Closed models (like those from OpenAI or Anthropic) keep the file on their servers. You rent access.
The closed models tend to be slightly smarter. The open ones give you sovereignty. This tension—intelligence versus control—is one of the defining dynamics of the current moment.
The practical takeaway: When someone says "model," think "file." When they say "weights," think "what's inside the file." When they say "open source," they mean you can possess and run that file yourself.
3. Inference Is Just Running the Model
The word "inference" intimidated people for months. It needn't.
Inference simply means: running the model. Text goes in, text comes out. That's it. When you type a question into ChatGPT, inference is happening on a server somewhere. When you run a model locally using something like Ollama, inference is happening on your own machine.
The catch: running frontier open models locally requires serious hardware—roughly a $20,000 computer at the moment. That's the current barrier to full self-sovereignty. You can run an agent locally on a Raspberry Pi, but if it's making API calls to Claude or OpenAI for the actual thinking, the inference is still happening in someone else's cloud.
This distinction matters. Running your agent locally while the inference happens remotely is a meaningful step toward sovereignty—your memories, your data, your orchestration are yours—but it's not the whole journey.
The practical takeaway: "Inference" = "running the model." Local inference = full control. Cloud inference = convenience with trade-offs. Know which one you're doing.
4. Context Is the Scarce Resource (and This Changes Everything)
If there is one concept that separates people who understand AI from people who merely use it, it's context.
LLMs are stateless. Every single interaction starts from scratch. The model remembers nothing between conversations. If you and I both use ChatGPT, we get exactly the same model. Any personalisation—your preferences, your history—comes from elsewhere, injected into the conversation, not baked into the model itself.
Here's how the illusion of memory works: every round of conversation, the system sends the entire history back to the model. Your eleventh message doesn't arrive alone—it brings the previous ten exchanges with it, plus a hidden preamble called the system prompt (think of it as the Ten Commandments for that session—instructions from the developer about how the model should behave).
All of this—the system prompt, the conversation history, your current message—is the context. And context is finite. The longer the conversation grows, the more confused the model becomes. Eventually, you hit the limit and must start over (a process called compaction, and it degrades everything).
This is why context engineering—the art of managing what goes into that window—has been the single most important area of practical AI development over the past year. Not smarter models. Smarter management of the scarce resource those models depend on.
The practical takeaway: Context is the conversation. It's finite and precious. Everything the model knows in a given session must fit inside it. Learning to manage context—what to include, what to defer, what to summarise—is the most important practical skill in working with AI today.
5. The System Prompt Is the Invisible Hand
Buried at the top of every context window is the system prompt: instructions you don't see, written by the developer (or sometimes by you), telling the model how to behave.
This is where things get ethically interesting. If you're using a cloud AI service that introduces advertising, there's nothing stopping the provider from inserting instructions into that hidden preamble—nudging the model to favour certain products, perspectives, or behaviours. You'd never see it. The model would simply... lean.
The AI experience will always be shaped by something. The question is whether that something is an advertiser, a corporation, a government, or you. Local AI—where you control the system prompt—is the only arrangement where the answer is definitively "you."
The practical takeaway: Whoever writes the system prompt shapes the model's behaviour. If you can't see or control it, someone else is steering your AI. That alone is reason enough to care about self-sovereign setups.
6. Tools Turn Text Into Action
An LLM can only do one thing: produce text. It can't search the web, open a browser, send a message, or book a flight. It can only write about doing those things.
So how does it act in the world? Through tools.
A tool is an agreement. In the system prompt, the model is told: "If you want to search the web, output this special marker with your query inside it." The agent software watches for that marker, intercepts it, performs the actual web search, and feeds the results back to the model. The model never touched the internet—it just asked, in a very specific format, and the surrounding software did the work.
This pattern extends to everything: controlling a browser, sending a Telegram message, reading a file, managing a calendar. Each capability is a tool—a bridge between the model's text output and real-world action.
The practical takeaway: Tools are how AI gets things done. The model thinks in text; tools translate that text into action. The more tools available, the more capable the agent—but also the more you need to understand what you're authorising it to do.
7. Just-in-Time Beats Just-in-Case (The MCP-to-Skills Revolution)
A year ago, the standard approach was to load everything into the context window upfront—every possible tool, every instruction, every contingency. This is just-in-case prompting, and it's the equivalent of reading an entire encyclopaedia before answering a single question. The model would arrive at your first message already half-confused, its context window bloated with things it might never need.
The revolution was just-in-time prompting. Instead of cramming ten thousand commandments into the system prompt, you give the model ten—plus a shelf of manuals it can see but doesn't read until needed. It sees the titles on the spines. When your intent matches a manual, it pulls it down and reads it.
This is the shift from MCP (Model Context Protocol—an early standard for sharing tools) to skills. A skill is a folder containing two things:
- A prompt—plain English describing when and how to do something ("When the user wants to book a flight, open the browser, go to Kayak, wait for them to enter their password...")
- A programme—traditional code that handles the mechanical steps the model would struggle with (navigating specific UI elements, entering credit card details, clicking the right buttons)
Skills are the closest analogue to apps in the old world. They map a user's intent to an action, blending the model's intelligence with traditional programming's reliability. And because they're loaded on demand rather than upfront, they don't waste context.
The practical takeaway: Don't dump everything into the prompt. Structure your AI setup so information is discoverable but loaded only when needed. If you're building with AI tools, think in terms of skills: intent → action, with just enough prompt to guide and just enough code to execute.
8. An Agent Is a Marriage Between Old and New
With all the pieces in place, we can define what an agent actually is.
An agent is software that:
- Makes requests to an LLM
- Manages the context window
- Intercepts tool calls and executes them
- Loops until the task is done (or the model responds without a tool call, signalling completion)
It's a marriage between traditional programming (controlling files, browsers, APIs, operating systems) and the new capability of LLMs (understanding intent, generating solutions, reasoning through ambiguity).
The ChatGPT website is an agent. Claude Code is an agent. OpenClaw is an agent. The difference is scope and sovereignty—where the agent runs, what tools it has access to, and who controls it.
The practical takeaway: An agent is the orchestration layer that makes an LLM useful in the real world. It's not the model itself—it's the software that gives the model hands.
9. Vibe Coding Changed Who Gets to Build
A year ago, writing software required the blinders on: exact syntax, precise logic, one misplaced semicolon and nothing works. Vibe coding is the opposite. You put your feet on the desk and say, "Build me a movie player app that downloads from Dropbox," and you watch it happen.
Here's what's actually occurring: you describe what you want. The agent asks clarifying questions, then enters a loop—searching the web, reading files, writing code, running the programme, testing it, iterating—until it judges the task complete (signalled by a response without a tool call). You steer along the way: "I want blue, not purple." "Add an export button."
A year ago, this was shaky. Today, it works reliably enough that Andrej Karpathy—the former head of AI at Tesla, who essentially coined the term—reports he's gone from 20% vibe coding to 80%.
The implications are seismic. The cost of software production is approaching zero. A Cuban activist who needs a specific Bitcoin wallet for her community's needs will, within a year, be able to describe it to a computer and have it built—open source, tailored, functional. One developer, Peter Steinberger, vibe-coded the entirety of OpenClaw—a project that amassed 160,000 GitHub stars in seven weeks (Bitcoin, after fifteen years, has 80,000).
The practical takeaway: You don't need to be a programmer to build software anymore. You need to be clear about what you want. The ability to articulate intent precisely—to describe the thing in your head so specifically that a machine can build it—is becoming one of the most valuable skills alive.
10. Sovereignty Is the Point
Every concept in this guide converges on a single question: who controls your AI?
When the model is closed and runs on someone else's servers, with a system prompt you can't see, using tools they chose, storing memories on their infrastructure—you are a tenant. Your experience can be shaped, your data harvested, your outputs nudged in directions that serve the platform rather than you.
When the agent runs locally, with open models you can inspect, a system prompt you wrote, tools you chose, and memories stored on your own machine—you have sovereignty. Not perfect sovereignty, not yet (the hardware costs are real, the security surface is enormous, and the open models aren't quite as capable as the closed ones)—but meaningful sovereignty. A direction, not a destination.
The trajectory is clear: open models are catching up to closed ones. Hardware is getting cheaper. Context engineering is getting smarter. The gap between what a well-configured local setup can do and what a frontier cloud model offers is narrowing by the month.
Persistent local memory alone changes the equation dramatically. A lesser model that remembers every interaction, that builds a deepening understanding of your work, your preferences, your context—that model, over time, outperforms a brilliant model that forgets you exist every time you close the tab.
The practical takeaway: Start moving toward sovereignty now, even incrementally. Use privacy-respecting tools where you can. Understand what you're trading when you use cloud AI. The goal isn't to reject all cloud services tomorrow—it's to build the muscle, the understanding, and the infrastructure so that when full self-sovereignty becomes practical, you're ready.
Where to Start (Right Now)
If you've read this far and want to act, here's a practical ladder:
Use a chatbot intentionally. If you're still just dabbling with ChatGPT, commit to using it (or Claude, or a privacy-respecting alternative) daily for real work. Learn what it's good at and where it breaks.
Try a creator tool. Claude Code, Cursor, or Replit will show you what AI looks like when it can use tools—not just generate text, but build things. Even with zero technical background, you can build a working app on Replit today.
Understand context by feel. Start a long conversation and notice when the model gets confused or forgetful. That's compaction. That's the context window filling up. Developing an intuition for this is worth more than any technical explanation.
Explore local AI. Install Ollama. Run a small open model. It won't be as smart as Claude, but it'll be yours. The experience of talking to an AI that runs on your own hardware—no internet required, no data leaving your machine—is genuinely different. It changes your relationship with the technology.
Articulate with precision. Whether you're prompting, vibe coding, or describing a skill, the bottleneck is increasingly your ability to say what you mean. Practice describing what you want with sensory specificity—not "make it look good" but "a rotating globe with colour-coded civil liberties data, sortable by donor country, with a liquid glass aesthetic." The more precisely you can dream out loud, the more powerful these tools become.
The Bigger Picture
Five years ago, the prevailing fear was that AI would be inherently centralising—a surveillance machine, a tool of control, the end of individual agency. And parts of that fear were justified. Dictators will use AI. Corporations will use AI to extract. That's happening.
But what wasn't anticipated was the other side: AI as an asymmetric amplifier of individual capability. Encryption didn't just help governments—it gave individuals a shield that states, with all their resources, still struggle to pierce. Bitcoin didn't just help banks—it gave people money that can't be confiscated. AI is following the same pattern.
A single person can now vibe-code a tool that would have taken a team of engineers months to build. An activist can speak a complex research task into a phone and get back a rich, interactive visualisation in minutes. A small organisation can 10x or 100x its output without hiring anyone.
The cost of software creation is collapsing. The barrier between having an idea and having a working tool is dissolving. And the infrastructure for doing all of this privately, sovereignly, on your own terms—that infrastructure is being built right now, in the open, by people who believe it matters.
This is the moment. Not to be overwhelmed by the jargon. Not to sit on the sidelines waiting for it to stabilise. But to learn the primitives, build the intuition, and start using these tools with the same intentionality you'd bring to any craft worth mastering.
The future isn't arriving. It's being built—by anyone willing to describe, precisely, what they want it to look like.
Now go build something.
Top comments (0)