Understanding & using AI24 posts
A course, not an archive: numbered in reading order, start at 01. Every post stands alone if you already know the piece before it.
From zeroFoundations · 17
What an LLM is, what a GPU does, and how to run one. No background needed.
What is an LLM, and how does it actually make words?
A jargon-free explanation of large language models: what they are, why they're basically a very good autocomplete, and how they write one word at a time.
Why run AI on your own machine?
Cloud chatbots are easy and, honestly, hard to beat. The real and narrower case for running a model yourself, and the big things you give up to do it.
What a GPU is, and why AI needs one
Why running AI means buying a graphics card, what makes a GPU different from a CPU, and why the amount of memory on the card is the number that really matters.
How a 30-billion-parameter model fits on one card
Quantisation, explained for normal people: how shrinking each number in a model lets a giant fit on a desktop graphics card, and what it costs.
How to read a model's name and specs
Model names like Qwen3-30B-A3B-Q4_K_M look like a cat walked across the keyboard. Here's how to decode them, and the handful of specs that actually matter.
Mixture of Experts: how a 30B model runs like a 3B one
The trick behind names like Qwen3-30B-A3B: split the model into many experts, run only a few per token. Why it suits a single GPU so well, and the headaches it brings.
How a model learns: training, in plain words
Every LLM starts as random noise and is shaped by one repeated loop: guess, measure the error, nudge billions of dials. Here's how that training actually works, and why it costs a fortune.
Pretraining, fine-tuning, and RLHF
A raw trained model can continue text but won't answer you. The three stages that turn a text-continuer into a helpful assistant, and which one you actually need.
AI that isn't an LLM
Language models get all the attention, but they're one corner of AI. A quick tour of the other big families, what each is for, and how to tell when an LLM is the wrong tool.
What an AI agent actually is
Strip the buzzword and an agent is one simple thing: a language model put in a loop and handed tools, so it can do things instead of just talking about them.
How an agent uses tools and memory
The loop, one level down: how the model actually requests a tool, why its whole memory is just the growing transcript, and why long multi-step tasks fall apart.
Why an LLM trips over the r's in 'strawberry'
Ask a top model to count the letters in a word and it often gets it wrong. Not a bug, and not stupidity: it's because the model never sees letters at all. A plain-words tour of tokens.
Why you get a different answer every time
Ask a model the same thing twice and you can get two different replies. That's a deliberate dice-roll, not a glitch, and one knob controls how loaded the dice are. Meet temperature.
Why models make things up
A model will hand you a wrong fact, a fake citation or an invented function with total confidence. It's not lying and it's not broken. Here's where 'hallucinations' actually come from, and how to work around them.
What the model remembers: the context window
An LLM has no memory between messages. Everything it 'knows' about your conversation is re-read from scratch each turn, and it only fits so much. Meet the context window, the single most useful thing to understand about how chatbots behave.
How a model sees a picture
You can hand a modern AI a photo and ask about it. But a language model only understands tokens, so what happens to the image? A plain-words look at how vision gets bolted onto a model that only ever knew words.
How to actually ask: prompting without the magic words
There are no secret incantations. Good prompting is just clear instructions to a brilliant, literal-minded assistant with no memory. A practical guide that follows straight from how the model works.
Using AI for realOps & infra · 7
Twenty years of running infrastructure, pointed at using AI in practice. The honest version.
What an LLM can and can't do in your infrastructure
After twenty years of keeping systems running and a couple of years deep in LLMs, an honest split: where AI genuinely helps an ops team, and where it's a liability waiting to happen.
LLMs in the terminal: a sysadmin's honest list
The concrete, everyday ways an LLM actually earns its place in a sysadmin's workflow, and the handful of rules that keep it from causing real damage.
Self-hosting an LLM for your team: usually don't
The tempting case for running your own model, and the honest reason most teams shouldn't: a small model's error rate burns more working time than the API fees it saves. Plus the cases where it still wins.
When not to use AI: an ops take
The unfashionable half of the conversation. The cases where reaching for an LLM is the wrong choice, and a simple heuristic for telling them apart from the good ones.
When to let an agent loose: an ops take
An agent that can act can also act wrongly. After twenty years of running systems, here's how I decide how much rope to give one, and the guardrails that earn their keep.
Pointing an LLM at your own documents (RAG, honestly)
Everyone wants 'a ChatGPT that knows our internal docs'. The mechanism is called RAG, it's simpler than the hype, and most of the work is the boring retrieval half nobody demos. An ops-eye view.
Prompt injection: the security hole in every LLM app
The moment your AI reads anything an attacker can influence, a web page, an email, a document, that content can hijack it. There's no clean fix, only containment. The honest ops briefing on the vulnerability nobody demos.