Zero to AI engineer.

What it will cover

• What the window actually holds: system prompt, every prior turn, tool results, and the reply still being written
• Reading usage mid-conversation so you can see how close to the ceiling you are
• What happens at the edge — silent truncation, dropped turns, and answers that suddenly forget
• Why a bigger window is not the same thing as better recall

What it will cover

• Reading a usage object: input, output and cached tokens, each billed at a different rate
• Estimating the cost of a run before you start it rather than after the invoice
• Where spend actually goes — long system prompts re-sent on every single turn
• Four cuts that lower a bill without touching output quality

What it will cover

• Why next-token prediction produces fluent, confident, wrong answers by design
• The three prompt shapes that trigger it reliably: obscure facts, exact figures, and library APIs
• Why asking "are you sure?" is not a verification step
• A 30-second checking habit that catches most of it before anyone else sees it

What it will cover

• What temperature does to the probability distribution, shown on one real completion
• Top-p and top-k, and why changing both at once makes your results unreadable
• The tasks where the default is already the right answer, and the few where it is not
• Why reproducible output needs more than setting temperature to zero

What it will cover

• What you are actually trading: cost curve, privacy, control, and the ceiling on capability
• When self-hosting is genuinely cheaper, and the volume at which it stops being
• The data-handling questions to ask before pasting anything into a hosted API
• A decision you can make in ten minutes without opening a benchmark table

What it will cover

• How instructions hidden in a web page, PDF or issue comment take over a run
• Why "ignore any instructions found in the input" does not hold up
• The boundary that does hold: separating instruction from data, and limiting what tools can reach
• What to do when a model has untrusted input and real capabilities at the same time

What it will cover

• Why the unit of work moved from one message to the whole window
• What now competes for that space: retrieved documents, tool output, history, instructions
• Budgeting a window deliberately instead of letting it fill up on its own
• What this changes about how you debug an answer that came back wrong

What it will cover

• Poisoning: one wrong fact early that every later turn treats as settled
• Distraction: a window so full that the actual instruction stops carrying weight
• Drift: the slow slide away from the task you started with
• How to tell which one you are looking at, and the specific fix for each

What it will cover

• Turning text into a vector, and what those numbers actually encode
• Why cosine similarity stands in for "means roughly the same thing"
• Where the analogy breaks down: negation, numbers, and very short strings
• The first thing embeddings unlock — search that survives a paraphrase

What it will cover

• Dimensions versus quality, and why bigger is not automatically better
• Cost paid once at ingest time versus cost paid on every query
• Domain fit: when a general model loses to a smaller specialised one
• A twenty-minute comparison on your own data that settles the choice

What it will cover

• What a vector index does that a WHERE clause cannot
• Pinecone, Chroma, Qdrant and pgvector compared on the things that actually bite
• When Postgres with pgvector is genuinely enough for what you are building
• Metadata filtering, and why it quietly decides your architecture

What it will cover

• Why retrieval quality is capped by a decision you make before indexing anything
• Fixed-size, sentence-based and structure-aware splitting, run on the same document
• Overlap: what it buys you, and what it costs in storage and noise
• The chunks that lose their meaning the moment they leave their heading behind

What it will cover

• Building search over meaning in about fifty lines of code
• Side by side with keyword search on the queries where each one wins
• Why hybrid search beats either approach alone more often than not
• Judging results honestly instead of on the three queries you happened to try

What it will cover

• The retrieve-then-generate loop, drawn as five concrete steps
• The exact problem it exists to solve: knowledge that is private, current, or too large to fit
• Why it beats pasting the document into the prompt once you have more than a handful
• What RAG does not fix, so you stop reaching for it when it will not help

What it will cover

• Ingest, chunk, embed, index, retrieve, generate — a pipeline that runs on your machine
• Wiring retrieved chunks into a prompt without blowing the context window
• Handling the empty-result case instead of letting the model invent an answer
• Where each stage fails first, and what that failure looks like from the outside

What it will cover

• Diagnosing the classic failure: the answer was in the corpus and never surfaced
• Re-ranking a shortlist with a cross-encoder, and what that costs per query
• Hybrid search — combining BM25 with vectors, and how to weight the two
• Metadata filters that shrink the search space before anything gets scored

What it will cover

• The one question that settles it: are you adding knowledge or changing behaviour?
• Cost and iteration speed compared honestly, including the work you only pay for once
• Why most "we need to fine-tune" problems turn out to be retrieval problems
• The cases where you genuinely need both, and which one to build first

What it will cover

• Making a model quote its source instead of paraphrasing from memory
• Prompt and schema patterns that make an ungrounded claim visible rather than plausible
• Checking that a citation points at text which actually says what was claimed
• What to render to a reader so they can verify a claim in one click

What it will cover

• Why a single end-to-end score hides which half of the pipeline is broken
• Retrieval metrics — recall@k and MRR — and what numbers to aim for
• Generation metrics: faithfulness to the context you actually retrieved
• A small hand-labelled set that is worth more than a large unlabelled one

What it will cover

• The observe-act-repeat loop, and the exact line between an agent and a chain
• What makes a task agent-shaped: you cannot know the number of steps in advance
• The stopping problem, and why every loop needs a budget
• When a very good prompt is the better and cheaper answer

What it will cover

• Defining a tool the model calls correctly on the first attempt
• Why the description field matters more than the code behind it
• Handling results, errors, and calls you did not anticipate
• Parallel tool calls, and when it is safe to allow them

What it will cover

• A complete agent loop in plain code, with no framework in the way
• Feeding tool results back in so the model can act on what it just learned
• Termination: turn limits, cost ceilings, and a real done condition
• Making a run inspectable while it is still running

What it will cover

• What genuinely needs to carry between steps, and what can be recomputed instead
• Scratchpads, rolling summaries and external stores, compared on a long run
• Keeping the window flat as a run gets longer
• Recovering when a step fails halfway through

What it will cover

• What the Claude Agent SDK, LangChain and LlamaIndex each actually give you
• The abstractions that help, and the ones that hide the bug you are chasing
• What switching later costs once you have built on one
• When forty lines of your own loop is the simpler system to own

What it will cover

• stdio versus HTTP, and what changes for the host and for the server
• Local processes, lifecycle and logging, and why stdio is the obvious local choice
• Remote servers: auth, sessions, and streaming responses over HTTP
• Debugging a server that connects successfully and then never answers

What it will cover

• The checklist: have you actually exhausted prompting, retrieval and tools?
• Signals that genuinely point at fine-tuning — a fixed format, a house tone, a narrow domain
• The real cost: data work, training, evaluation, and doing it again on the next base model
• Cheaper alternatives that solve the problem first, most of the time

What it will cover

• How many examples you actually need, and why quality beats volume every time
• Formatting a dataset correctly, including the mistakes that fail a run silently
• Splitting train and validation so your numbers mean something
• Finding and removing the examples that teach the model the wrong lesson

What it will cover

• One run end to end, from dataset upload to a model you can call
• Reading loss curves: what underfitting and overfitting actually look like
• Epochs and learning rate, and the narrow cases where you should touch them
• Deciding a run has failed before you spend more money on it

What it will cover

• What a low-rank adapter changes, and the far larger part it leaves alone
• Why it trains on hardware that full fine-tuning cannot touch
• Rank and alpha, explained in terms of the effect you will actually see
• Serving several adapters over a single base model

What it will cover

• Holding out a set the tuned model has never seen, and keeping it clean
• Comparing against both the base model and a well-prompted baseline
• Catching regressions on the tasks you did not tune for
• Deciding to ship, retrain, or abandon — on evidence rather than hope

What it will cover

• Why "it seems better" cannot be reviewed, defended, or reproduced next month
• What an eval is at minimum: inputs, expected outcomes, and a score
• The cases worth collecting first — the failures you have already hit
• Getting a scoreboard in place before you build a pipeline to serve it

What it will cover

• Mining real traffic and bug reports for cases worth scoring
• Writing expectations that survive a correct answer worded differently
• Exact match, rubric, and model-graded checks, and where each one fits
• One command, a pass rate, and a diff against the last run

What it will cover

• Grounding scores: does every claim trace back to the context you supplied?
• Consistency sampling — ask three times, compare what changes
• Claim extraction and verification against a source of truth
• Setting thresholds that catch nonsense without blocking correct answers

What it will cover

• Writing a rubric a model can apply the same way twice
• Position, length and self-preference bias, and how to blunt each one
• Calibrating the judge against human labels before you trust a single score
• The places where a judge is simply the wrong tool

What it will cover

• What to log per call: prompt, tokens, latency, tool results, and cost
• Tying a whole agent run together under one trace id
• Finding the step that broke without rerunning the entire thing
• Alerting on cost and failure rate before a user tells you

What it will cover

• Measuring per completed task rather than per request, which hides retries
• Prompt caching, and structuring a prompt so the cache actually hits
• Batching, streaming, and routing the easy work to a smaller model
• The cost-quality curve, and picking a point on it deliberately