From zero to AI expert

What you need to understand

Artificial Intelligence

The umbrella field: getting machines to do tasks we associate with intelligence.

Machine Learning

The system learns patterns from data instead of following hand-written rules.

Deep Learning

Machine Learning with many-layered neural networks. The basis of almost all modern AI.

Generative AI

Models that create new content: text, images, code or audio.

LLM

Large Language Model: a model trained on huge amounts of text to predict the next word.

APIs and JSON

How your code talks to other services, AI models included, and the data format they use.

Data with Python

NumPy, pandas and some SQL: loading, cleaning and exploring data. Almost every AI project starts here.

How to do it

1. Watch a few explainer videos to get your bearings (3Blue1Brown and Karpathy's talks are great starting points).
2. Learn Python with a complete course and do every exercise.
3. Learn just enough Git: clone, commit, branches, push and pull.
4. Practise calling a public API from Python and processing the JSON it returns.
5. Learn the basics of pandas and SQL with a real dataset you care about.
6. If you come from web development, learn TypeScript too: you can do Camps I to III entirely with it (see the “Python or TypeScript?” section).

Gear for the climb

What you need to understand

Token

The unit a model splits text into. Usage is billed and limited in tokens.

Context window

Everything the model can see at once: conversation, documents and response.

Temperature

Controls randomness. Low gives predictable answers; high gives more creative ones.

Prompt engineering

Clear instructions with context, examples (few-shot), expected format and steps.

Hallucination

When the model confidently makes things up.

Coding assistants

Claude Code, Cursor, GitHub Copilot: tools you delegate programming tasks to.

Reasoning models

Models that think step by step before answering. Slower and pricier, but much better at complex problems.

Vibe coding

Programming by describing what you want and accepting the code with barely any review. Handy for quick prototypes, risky in production.

Context files

CLAUDE.md or AGENTS.md: a file in your repo that tells the agent what the project is like, its conventions and how to run the tests. It's read every session.

Spec-Driven Development (SDD)

The opposite of vibe coding: you first write a specification of what to build, the agent turns it into a plan and a task list, and only then writes the code. Everything traces back to the spec.

How to do it

1. Watch Karpathy's introductory talk on LLMs.
2. Work through Anthropic's interactive prompt engineering tutorial.
3. Use a coding assistant daily for two weeks and note where it gets things right and wrong.
4. Compare the same prompt across two or three models to build intuition.
5. Add a CLAUDE.md or AGENTS.md to your project and watch how the agent's work improves.
6. Build the same feature twice, once with vibe coding and once with SDD using Spec Kit, and compare the results.

Gear for the climb

What you need to understand

LLM API

Calling the model from your code: messages, roles and the system prompt.

Structured outputs

Responses in valid JSON so your program can process them.

Streaming

Receiving the response token by token so the interface feels fast.

Tool use

The model calls functions you define. It's the gateway to agents.

Embeddings

Text turned into vectors: similar texts produce nearby vectors.

Vector databases

Store embeddings and search by similarity: pgvector, Qdrant, Chroma, Pinecone.

RAG

Retrieving relevant documents and giving them to the model so it answers with your information.

Frameworks

LangChain, LlamaIndex, Vercel AI SDK. Useful, but understand what they do first.

Multimodality

APIs accept images, PDFs and audio, and there are real-time voice and image-generation APIs. Many useful apps combine several.

Prompt, RAG or fine-tuning

The key decision at this level. Always start with the prompt; add RAG if the model lacks knowledge; use fine-tuning only if you need to change its behaviour or format consistently.

How to do it

1. Take Anthropic's API fundamentals and tool use courses.
2. Build a RAG pipeline by hand, no frameworks: chunk, embed, search and answer.
3. Rebuild it with LlamaIndex or LangChain and compare what the framework saves you.
4. Read Chip Huyen's AI Engineering alongside.

Gear for the climb

What you need to understand

Agent

An LLM in a loop: it plans, uses tools, observes the result and decides the next step.

MCP

Model Context Protocol: an open standard for connecting models to tools and data.

Agent Skills

Folders with a SKILL.md file (instructions) and optionally scripts and templates that teach the agent a specific task. At startup it loads only each skill's name and description, and reads the rest when needed. MCP gives the agent tools; skills teach it how to use them.

Context engineering

The evolution of prompt engineering: deciding what information goes into the agent's context at each moment (instructions, tools, memory, documents) so it performs well without getting overloaded.

Subagents

Secondary agents the main one launches for specific tasks, each with its own clean context. They stop a single conversation from filling up with noise.

Hooks and commands

Hooks: scripts that run automatically at certain moments (before an edit, after a commit). Commands: reusable shortcuts you trigger with a slash, like /review.

A2A

Agent2Agent: an open protocol for agents from different vendors to talk to each other and delegate tasks.

Multi-agent

Several specialised agents working together: planner, executor, reviewer.

Evals

Systematic tests to measure quality. What separates a prototype from a product.

Observability

Tracing every call, cost and latency to find failures.

Guardrails

Defences against prompt injection, output validation and permission control.

Optimisation

Prompt caching, choosing the right model for each task and batch processing.

Memory

How an agent remembers across sessions: summaries, note files or databases it looks up when needed.

Computer use

Agents that operate a browser or desktop like a person: they see the screen, click and type. Powerful, but slow and security-sensitive.

Deployment

Taking the system to production: containers, queues for long tasks, rate limits, retries and sandboxing everything the agent executes.

How to do it

1. Read Anthropic's Building effective agents before touching any agent framework.
2. Build an agent with a loop you write yourself and two or three real tools.
3. Create your own MCP server that exposes one of your tools.
4. Write two or three skills for tasks you repeat (reviewing PRs, generating reports) and check when the agent triggers them.
5. Split a large task across subagents and add a hook that runs the tests before each change.
6. Write evals from day one, add tracing and review the OWASP Top 10 for LLMs.

Gear for the climb

What you need to understand

Maths

Linear algebra, calculus (derivatives, gradients) and probability.

Neural networks

Neurons, layers, activations, backpropagation and gradient descent.

PyTorch

The standard framework for building and training models.

Transformer

The architecture behind LLMs, introduced in Attention Is All You Need (2017).

Attention

Each token looks at the others to understand context. The core idea of the Transformer.

Lifecycle

Pre-training, fine-tuning and alignment with RLHF.

LoRA and QLoRA

Adapting large models by training only a small part of them.

Local inference

Open models with Ollama or vLLM, and quantisation so they fit on your machine.

How to do it

1. Brush up on the maths with 3Blue1Brown.
2. Do Karpathy's Neural Networks: Zero to Hero, typing every line yourself.
3. Complement it with fast.ai or Andrew Ng's specialisation.
4. Read The Illustrated Transformer and then the original paper.
5. Finish with fine-tuning: Maxime Labonne's LLM Course and Unsloth.

Gear for the climb

What you need to understand

Training at scale

Distributed training across many GPUs, scaling laws and massive datasets.

MLOps / LLMOps

Deployment, monitoring, versioning and cost control.

Interpretability

Understanding what a model represents internally and why it does what it does.

Alignment

Making increasingly capable systems behave the way we intend.

Multimodality

Models that combine text, image, audio and video.

Research

Reading papers comfortably, reproducing results and contributing something new.

How to do it

1. Take a frontier course such as Stanford's CS224N or CS336.
2. Read the Ultra-Scale Playbook to understand distributed training.
3. Pick a specialism (interpretability, alignment, systems, multimodal) and go deep.
4. Reproduce a recent paper every month and publish your results.

Gear for the climb