Field Guides

Building with AI,
without the fog.

Five guides for developers. Each one starts with the boring truth, explains the thing in plain words, and then lets you take it apart. Every page has a working lab in it, and nothing on any of them needs an API key.

01

Talking to an LLM

One function call, and what it costs

A model is a function: text in, text out, and then it forgets you. Tokens, the shape of a request, streaming, structured output, prompt caching, and what to do when it fails.

LabBuild a request and watch the price move

  • tokens
  • streaming
  • caching
  • retries
 02

Retrieval, vectors and RAG

Mostly it is search

What an embedding is, why chunking matters more than your database, hybrid search, reranking, and how to keep relational records and vectors in step without leaving ghosts behind.

LabChunk a document and watch three search methods disagree

  • embeddings
  • chunking
  • pgvector
  • dual store
 03

Running a model yourself

Will it fit, and will it be any good

Model sizes, quantization, the memory arithmetic, and why generation speed is set by memory bandwidth rather than compute. Honest about when this is worth doing and when it is not.

LabWill it fit on your card, and how fast

  • quantization
  • VRAM
  • KV cache
  • Ollama
 04

MCP

A standard plug for tools you did not write

What the Model Context Protocol actually is, which is less than you have been told. How to build a server, how to use one from your own app, and where the model sits in all of it.

LabBuild a working system out of blocks and run it

  • tools
  • stdio
  • transports
  • servers
 05

Shipping it

The unglamorous half

Evals, prompt injection, least privilege, cost, latency and observability — the things that decide whether an AI feature survives contact with real users.

LabWatch an injected document steal your customer list

  • evals
  • injection
  • cost
  • tracing

Starting from nothing

Read them in order. The first one is assumed by all the others, and it is the one nobody writes down.

  1. Talking to an LLM — everything else stands on this
  2. Retrieval and RAG — once you need it to know your data
  3. Shipping it — before anyone else touches it

Already shipping

Two sections earn their keep immediately, whatever else you skip.

  1. Prompt injection — the one genuinely dangerous thing
  2. Prompt caching — usually the largest line on the bill
  3. The dual store — if records and vectors both exist

Just curious

Three answers that surprise most people, each about a minute.

  1. What MCP actually is — less than advertised
  2. Why local models are slow — it is not the compute
  3. Why search misses things — similar is not relevant