# AI Fundamentals

Source: John Bradshaw — https://bradshaw.cloud
URL: https://bradshaw.cloud/strategy/ai-fundamentals/
Type: insight
Date: 2026-04-01
Updated: 2026-09-17
Tags: Foundation, AI

> A business leader's guide to the building blocks of AI — no code, no jargon, just the mental models that matter.

## The building blocks

Click each concept to see the business analogy, what the thing actually is, and a visual explanation.

### Pre-training
_University education_

**Analogy:** Sending someone to university

You invest years and enormous cost in a broad education. The graduate doesn't know your specific business — but they can read, write, reason, and learn new things quickly. That general foundation is what makes everything else possible.

**What it actually is:** A base model is trained on trillions of tokens of text with one self-supervised objective: predict the next token. The task supplies its own answers — the target for each position is simply the token that follows, so no human labelling and no task-specific dataset are needed — and the billions of parameters are nudged by gradient descent, batch after batch, purely to get better at that prediction. Grammar, facts and reasoning patterns are what falls out of doing it well, across weeks of continuous training on thousands of accelerators.

**Business take:** Cost: millions. Time: months. You almost certainly don't do this yourself — you buy the graduate (base model) from someone who did.

### Embeddings
_Library filing system_

**Analogy:** A library shelved by meaning, not alphabet

Imagine a library where books aren't filed alphabetically but by meaning. Cookbooks sit near nutrition guides. Thrillers sit near crime fiction. The "address" of each book on the shelf IS its meaning — and nearby books are related.

**What it actually is:** An embedding model converts a piece of text into a vector — a list of several hundred to several thousand numbers — positioned so that texts with similar meaning sit close together. Closeness is then arithmetic, usually cosine similarity between the two vectors. A vector database stores millions of them and answers "what is nearest to this?" by approximate nearest-neighbour search, which is why the lookup stays fast as the corpus grows.

**Business take:** This is how AI understands similarity. When you search "revenue forecast", it also finds "financial projections" because they're shelved in the same area.

### Fine-tuning
_Specialist apprenticeship_

**Analogy:** A graduate doing a specialist apprenticeship

Your university graduate joins a law firm. Through months of supervised practice, they learn legal language, how to draft contracts, and what "good" looks like in this domain. They don't forget how to read or reason — they layer expertise on top of their general education.

**What it actually is:** Training continues from the pre-trained weights on a much smaller curated dataset — typically thousands of prompt-and-response pairs — at a low learning rate. The weights themselves change, so the behaviour is baked in and needs no prompt to invoke it. Push it too far and the model over-fits the narrow set and loses general ability: catastrophic forgetting. Preference-tuning methods can follow, teaching the model which of two answers is better rather than a single correct one.

**Business take:** Cost: thousands, not millions. Risk: over-specialise and they forget how to do anything else (catastrophic forgetting). Only fine-tune when cheaper levers genuinely fail.

### Retrieval-augmented generation
_Open-book exam_

**Analogy:** An employee with a well-indexed filing cabinet

Instead of memorising every fact, your employee keeps a well-indexed filing cabinet and looks things up when asked. "What's our refund policy?" — they flip to the right page, read the answer, and respond in their own words. The filing cabinet can be updated instantly; no retraining needed.

**What it actually is:** Documents are split into chunks, embedded, and stored in a vector index. At query time the question is embedded too, the closest chunks are retrieved — often reranked by a second, more precise model — and pasted into the prompt as context before the model answers. The weights never change, so nothing is trained: quality comes from both halves — the retrieval pipeline (chunking, index, reranking) decides which passages the model sees, and the model decides how faithfully it uses them — and the answer can cite the chunk it came from.

**Business take:** This is how you give AI access to your company data without retraining the model. New document? Drop it in the filing cabinet. Instant knowledge update, zero training cost.

### Prompt engineering
_Writing a clear brief_

**Analogy:** The quality of your instructions determines the quality of output

You don't retrain your employee — you give them better instructions. "Summarise this in 3 bullet points for the board" gets a very different result from "Tell me about this". The skill isn't in the employee's training; it's in how precisely you describe what you want.

**What it actually is:** The prompt is the model's entire conditioning at inference: a system instruction, any worked examples (few-shot), the retrieved context and the task itself, all as tokens in one finite context window. Nothing outside it exists to the model. Stating the reasoning steps to take, the output format to return, and one or two examples of a good answer changes the probability distribution the model samples from — no weight changes, no training run.

**Business take:** Zero cost, instant feedback. This is always your first lever. Most "AI doesn't work" complaints are actually "the brief was vague" problems.

### Inference
_Employee doing the work_

**Analogy:** The moment your trained employee sits down and produces output

All the education and training was preparation. Inference is the moment they sit down and produce output — one word at a time, reading what they've written so far to decide what comes next. This is where you pay per minute of their time.

**What it actually is:** Generation is autoregressive: one forward pass through the network produces a probability distribution over the next token, one token is sampled from it, appended, and the whole thing runs again. It splits into two phases with different costs — prefill reads the prompt in parallel and is compute-bound, then decode emits tokens one at a time and is bound by memory bandwidth, which is why output tokens are slower and dearer than input ones. A KV cache keeps the earlier tokens' intermediate state so each step does not recompute the whole sequence.

**Business take:** This is your running cost. Every API call, every chat response — it's all inference. Speed and cost per query matter here.

### LoRA and parameter-efficient fine-tuning
_Clip-on specialist badge_

**Analogy:** A tiny reference card that shifts behaviour without retraining

Instead of sending your employee back to university, you give them a laminated reference card for a specific domain. They clip it on, check it when needed, and their answers shift toward that speciality. Swap the card for a different one and they're instantly re-specialised.

**What it actually is:** Low-rank adaptation freezes every base weight and trains a pair of small matrices injected alongside the model's existing projections. Their product has the same shape as the weight it adjusts but a fraction of the parameters — commonly well under 1% — so training needs far less memory and produces an adapter file rather than a new model. Adapters can be merged into the weights for serving, or kept separate and switched per request on top of one shared base model in GPU memory.

**Business take:** One base model, many cheap adapters. Your legal card, medical card, and finance card all share the same employee. Storage: megabytes, not gigabytes.

### Quantisation
_Photo compression_

**Analogy:** RAW photo to JPEG: dramatically smaller, barely visible quality loss

A RAW photo is 50 MB but a JPEG is 5 MB — and you can barely tell the difference. Quantisation does the same to a model: it reduces the precision of every number from 32-bit to 16-bit, 8-bit, or 4-bit. The model gets dramatically smaller and faster, with minimal quality loss.

**What it actually is:** Each weight is stored at lower numeric precision — 16-bit floating point down to 8- or 4-bit integers — with a scale factor per small group of weights to map the integers back to roughly their original values. Memory falls close to linearly with the bit width, and because decoding is memory-bandwidth bound, throughput improves as well. Accuracy loss stays small when the scheme is calibrated on representative data and the layers most sensitive to rounding are left at higher precision.

**Business take:** This is how you fit a large model onto cheaper hardware. A 28 GB model becomes 3.5 GB at 4-bit — runnable on a single consumer GPU instead of an expensive server.

## Decision framework

### Internal: can better instructions fix it?

**Yes → prompt engineering. Free, instant.**

80% of enterprise AI use cases are solved by better prompts. Try system prompts, few-shot examples, and chain-of-thought before reaching for heavier tooling.

### Internal: does it need access to your data?

**Yes → RAG with an API model. Low cost, always current.**

RAG keeps your data out of the model's weights — easier to update, audit, and delete. Start with a vector store and 50 documents before scaling.

### External: will volume exceed 10K queries/day?

**Yes → self-host. Fine-tune + quantise a 7B–14B model on your own GPUs.**

At 10K queries/day, API costs compound fast. A single A100 GPU running a quantised 14B model pays for itself within weeks at that volume.

### External: does a small model handle it?

**No → hybrid approach. SLM for 95% bulk, frontier API for 5% hard cases.**

Route 95% of traffic to your SLM and reserve frontier APIs for edge cases requiring complex reasoning. Monitor quality drift weekly.

## The decision ladder

Two different playbooks depending on whether you're building internal tools or shipping a product.

### Internal: productivity tooling

Boosting employees, internal tools, knowledge management

- Prompt engineering — Write a better brief — Free
- RAG — Give them a filing cabinet — Low
- Fine-tuning / LoRA — Rarely needed — Occasional

_API-based models work well — volume is low, value per query is high._

### External: product integration

Embedding AI into products, pipelines, customer-facing systems

- Prompt engineering — Still your first lever — Free
- RAG + self-hosted SLMs — Your data, your infra — Medium
- Fine-tuning / LoRA — Domain-specific models — High
- Quantisation — Compress for cheaper hardware — Essential

_API pricing is lethal at scale — self-hosted SLMs become the only viable path._

## Frequently asked questions

### What are the building blocks of AI a business leader actually needs to understand?

Eight, and none of them require code. Pre-training is the general education you buy rather than fund. Embeddings are how a model understands similarity. Prompting is the brief you write. RAG gives the model access to your data without retraining. Fine-tuning and LoRA layer domain expertise on top. Quantisation shrinks a model to fit cheaper hardware. Inference is the moment it does the work — and the line item you pay every month.

### Should I use RAG or fine-tuning to give a model knowledge of my business?

Start with RAG in almost every case. RAG keeps your data out of the model weights, which makes it far easier to update, audit, and delete — drop a new document in and the knowledge is current immediately, with no retraining cost. Fine-tuning changes how a model behaves rather than what it knows, and it carries a real risk of over-specialisation. Reach for it only when the cheaper levers have genuinely failed.

### Do we need to train our own model?

Almost certainly not. Pre-training a base model costs millions and takes months, and the result is a general graduate who still knows nothing about your business. You buy the graduate from someone who did it, then specialise them — with a better brief, a filing cabinet of your own documents, or a lightweight adapter. Training from scratch is a research programme, not a product decision.

### What is quantisation and why does it matter commercially?

Quantisation reduces the numeric precision of a model — 32-bit down to 16, 8, or 4 — much as a RAW photo becomes a JPEG. The model gets dramatically smaller and faster with minimal quality loss. Commercially, that is the difference between an expensive multi-GPU server and a single consumer card: a 28 GB model becomes roughly 3.5 GB at 4-bit. It is the technique that makes self-hosting affordable.

### Should internal tools and customer-facing products use the same AI approach?

No — the economics point in opposite directions. Internal productivity tooling is low-volume and high-value per query, so API-based models work well and the ladder rarely climbs past RAG. Product integration is the reverse: volume is high, value per query is low, and per-token API pricing becomes lethal at scale. That path runs through self-hosted small models, and usually ends at quantisation.

### What is the cheapest lever to pull first?

A better brief. Prompt engineering is free, gives instant feedback, and resolves the large majority of enterprise use cases on its own — system prompts, a few worked examples, and asking the model to show its reasoning. Most complaints that "AI does not work" turn out to be vague-instruction problems, not model problems. Exhaust that before you spend anything.

## Diagrams

Standalone SVG diagrams, licensed CC BY 4.0 with attribution to John Bradshaw — link back to https://bradshaw.cloud/strategy/ai-fundamentals/ when embedding.

- [Pre-training (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/pretrain.svg)
- [Embeddings (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/embed.svg)
- [Fine-tuning (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/finetune.svg)
- [Retrieval-augmented generation (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/rag.svg)
- [Prompt engineering (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/prompt.svg)
- [Inference (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/infer.svg)
- [LoRA and parameter-efficient fine-tuning (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/lora.svg)
- [Quantisation (SVG)](https://bradshaw.cloud/strategy/ai-fundamentals/diagrams/quant.svg)

## Related

- [Frontier models](https://bradshaw.cloud/strategy/frontier-models/) — which model to reach for, and when.
- [Learn about MCP](https://bradshaw.cloud/strategy/mcp/) — the protocol that makes AI tool integration practical at scale.
- [AI cost curves](https://bradshaw.cloud/strategy/ai-cost-curves/) — when to move from API to self-hosted.
- [Browse all insights](https://bradshaw.cloud/strategy/)