Most AI tutorials are a pile of tips with no order to them. This is the order. Ten stages, each one building on the last — starting with how a language model actually works, ending with agents, MCP and evals you can put in production.
32 topics are published today and 36 more are queued. New tutorials land Monday, Wednesday and Thursday, with a hands-on project every Friday.
What an AI engineer actually does, and how to set up a workspace you will keep using.
How the role differs from an ML engineer, and what you actually need to know.
Tool fatigue is real. Choose a daily driver before you optimise anything.
The single habit that improves output more than any prompt template.
Install, authenticate, and run your first session in a real project.
What is safe to paste into a model, and what should never leave your machine.
The mental model everything else is built on. Skipping this is why most people plateau.
Next-token prediction, transformers, and why a model has no memory between calls.
What a token really is, why cost and limits are measured in them, and how to count.
The model's working memory: what fits, what falls out, and what that costs you.
Reading a usage object, estimating spend, and cutting a bill without losing quality.
Where confident wrong answers come from, and the habits that catch them early.
The knobs that control randomness, and when changing them actually helps.
Hosted APIs, open weights, and how to choose without reading a benchmark table.
When extended thinking earns its cost, and when it is pure overhead.
Reliable prompting is the highest-leverage skill on this map. Everything downstream depends on it.
Zero-shot, few-shot, and the anatomy of a prompt that behaves predictably.
Give a model a role and a rulebook so it acts like a specialist, not a generalist.
Layering personas to get answers with genuine expertise behind them.
Ask for reasoning steps and watch accuracy on multi-step problems jump.
Split a task across several calls so each one has a single, clear job.
Get JSON you can parse every time instead of prose you have to scrape.
How to give feedback that actually moves the output, instead of restarting.
How untrusted text hijacks a model, and the boundaries that stop it.
Prompting is one message. Context engineering is managing everything the model can see.
Why the field moved on, and what changes when you think in windows not prompts.
Keep long conversations sharp by cutting what the model no longer needs.
Summarise history automatically so a long session survives the context limit.
Move between tasks without dragging stale context along behind you.
Persisting facts across sessions, and deciding what deserves to persist.
CLAUDE.md and friends: standing rules a model reads on every run.
Poisoning, distraction and drift — how long contexts quietly go wrong.
Turning meaning into numbers. The retrieval half of RAG starts here.
Text as vectors, and why "similar meaning" becomes "close together".
Dimensions, cost and quality — the tradeoffs that actually matter.
Pinecone, Chroma, Qdrant, pgvector: what they do and when you need one.
How you split documents decides how good your retrieval can ever be.
Build search that understands intent instead of matching keywords.
Retrieval-augmented generation: give a model your data without retraining it.
The retrieve-then-generate loop, and the problem it exists to solve.
Ingest, chunk, embed, index, retrieve, generate — end to end.
Re-ranking, hybrid search and filters, for when the right chunk never surfaces.
Knowledge or behaviour? The question that settles which one you need.
Make answers traceable to sources so hallucinations become visible.
Measure retrieval and generation separately, or you will debug blind.
Models that choose their own next step. The biggest leap in capability — and in failure modes.
The loop that separates an agent from a very good prompt.
Give a model real capabilities, and define them so it uses them correctly.
A working loop from scratch: tools, results, and knowing when to stop.
What an agent carries between steps, and where to keep it.
Delegation, sub-agents and orchestration — plus when one agent is plenty.
Claude Agent SDK, LangChain, LlamaIndex: what each buys you.
Fire your own code at defined points in an agent's lifecycle.
Route each step to the model that handles it best.
The Model Context Protocol: one standard way to plug tools and data into any model.
Hosts, clients and servers — the shape of the protocol in one page.
From empty folder to a server Claude can actually call.
Let a model read and write local files, safely and on purpose.
Query Postgres in plain English through an MCP server.
Give controlled access to specific projects instead of your whole disk.
Automate issues, PRs and reviews straight from your editor.
Let a server ask the model for a decision mid-task.
stdio versus HTTP, and which to reach for when.
Changing the model itself. Powerful, frequently unnecessary, and worth understanding either way.
The honest checklist — most problems are prompting or retrieval problems.
Dataset size, format and quality, which decide the whole outcome.
Walk one end to end and read what the training metrics are telling you.
Adapt a model without retraining all of it.
Prove it beat the base model instead of assuming it did.
The difference between a demo and something you can put in front of real users.
Without a scoreboard, every prompt change is a guess.
Real cases, expected outputs, and a script that runs in one command.
Automated checks that catch confident nonsense before your users do.
Use a model to grade a model — and know where that breaks down.
See every call, token and tool result when something goes wrong in prod.
Caching, batching and model choice, measured per completed task.
Turn a model into a reliable second reviewer on your own work.
Generate a test suite that actually guards against regressions.
New tutorials three times a week, following this exact path. Subscribe with any RSS reader and they arrive as they publish.
https://danbyers.ai/feed.xml