Learn
1306 pages on how language models behave at inference time, and what that costs.
LLM fundamentals & architecture
What a language model actually does when it answers you, and which parts of the architecture you can feel in latency, quality and cost.
Tokens, tokenization & context windows
The unit you are billed in, the limit you keep hitting, and the arithmetic that connects the two.
Prompt engineering
Which prompting techniques actually change a model's output, which ones better models absorbed, and how to tell the difference on your own workload.
Reasoning models & test-time compute
What changes when a model spends tokens thinking before it answers — in the bill, in the latency, and in the set of tasks that actually get better.
Multimodal AI: vision, audio, video
How models take in pixels, audio and frames — what that costs, where it fails, and which parts of the job still belong to a specialised tool.
RAG & retrieval
How to put your own documents in front of a model: chunking, ranking, filtering, evaluating and paying for the pipeline that does it.
Embeddings & vector search
How text becomes a vector, what nearness in that space does and does not mean, and what it costs to store and search a few hundred million of them.
AI agents & tool use
What an agent actually is once you strip the marketing off it: a loop, a set of tools, and a budget — plus everything that goes wrong when you run one against production.
Structured output & function calling
How to make a next-token predictor emit JSON your program can rely on — what each enforcement mechanism actually guarantees, and what you still have to check yourself.
Fine-tuning & post-training
When changing a model's weights is the right answer, what each method actually costs, and the failure modes that make most fine-tunes a waste of a fortnight.
Inference, serving & latency
What actually happens when a request reaches a model server, and how to reason about latency, throughput, limits and failures instead of guessing at them.
Evaluation, benchmarks & LLM-as-judge
How to find out whether a model is good at your task, when the public numbers stop being evidence, and how to grade at scale without lying to yourself.
Observability & LLMOps
How to see what your model calls are doing in production — what to log, how to trace it, what to alert on, and how to attribute the bill.
Hallucination & failure modes
Why a language model states false things fluently, which distinct failures the word hides, and how to detect each one in your own system rather than arguing about it.
LLM cost engineering
What an inference bill is actually made of, and the arithmetic for deciding which change to it is worth an engineer's week.
AI security & prompt injection
The vulnerability classes that come with putting a language model in production, and the architectural controls that actually reduce them.
Privacy, compliance & data residency
Where a prompt physically goes, who processes it on the way, what is kept and for how long — and which of those are decisions you control.
AI governance, policy & society
How the rules around AI are actually built — which institutions have real authority, how each policy instrument bites, and where the evidence is genuinely unsettled.
Building reliable AI applications
The distributed-systems patterns an AI feature needs — idempotency, deadlines, breakers, queues, degradation — and the parts of each that change when the dependency is slow, non-deterministic and billed per attempt.
AI hardware, GPUs & compute
The arithmetic that decides what a model costs to run: memory bandwidth, VRAM, interconnect and utilisation, derived rather than benchmarked.
Open-weight models & local inference
What you can actually run on hardware you control, what the licence actually lets you do with it, and how to work both out from first principles rather than from folklore.
AI for developers & coding agents
What a model can and cannot do to a codebase, and the loops, context and review workflow that decide which of those you get.
AI in industry: vertical playbooks
What changes when a language model meets a specific industry: the sign-off that has to happen, the format the data arrives in, the metric that decides whether it works, and the failure that costs money.
AGI, superintelligence, alignment & the long future
The arguments about where AI is going, stated at the strength their proponents state them — with the definitions pinned down, the evidence attributed, and the predictions labelled as predictions.
- What Would Count as AGI? Definitions That Can Be Tested
- The Technological Singularity, Explained
- Intelligence Explosion: The Argument and Its Weak Points
37 more in agi, superintelligence, alignment & the long future →
Machine learning foundations
The layer under the language models: how a model is fitted, how it fails, and how you find out which of those is happening.
NLP fundamentals & classical tasks
The pre-2020 toolkit — tokenizing, BM25, taggers, classifiers, edit distance — and an honest account of which parts a language model has replaced and which parts still win.
Data engineering for AI
Getting documents out of the formats they arrive in and into a store you can index, update and reproduce — the part of an AI feature that is most of the work and none of the demos.
Synthetic data & dataset curation
How to generate, filter, deduplicate and document a dataset — and what the published research actually says about training on data a model produced.
AI product design & UX
How to design an interface around a component that is slow, non-deterministic, sometimes confidently wrong, and billed per interaction.
Search, ranking & recommendation
How a ranked list is built, measured and defended — the evaluation mathematics, the tuning loop and the product decisions that sit on top of whatever retrieval engine you chose.
Enterprise adoption & change management
The artefacts an AI programme actually runs on — the scoring rubric, the pilot charter, the budget structure, the risk register — rather than a maturity model.
AI careers, skills & teams
What the work in this field actually consists of, what each role produces, and how to learn, hire, interview for and survive it without believing anybody's forecast.
Reading AI research
How to read a machine learning paper well enough to tell a real result from a well-presented one, and what the field's landmark papers actually say.
AI in science & discovery
Where machine learning has genuinely changed how research gets done, described by the method and by the verification step that still has to happen.
Robotics & embodied AI
Why putting a model in a body is a different problem from putting one behind an API — the control deadline, the missing data, the simulation gap and the fact that failure is physical.
AI economics, markets & business models
The structure underneath the industry's numbers — where value is captured, why prices fall, and what a metered cost of goods does to a software business.
AI myths, hype & media literacy
How to read a claim about AI — from a launch post, a demo or a headline — by finding the step where the evidence stops supporting the conclusion.
Context engineering
What occupies the model's window on this request, in what order, assembled by what code, and what gets evicted when the next thing no longer fits.
Shipping AI features: patterns & anti-patterns
The decisions around shipping an AI feature — what to build first, which shape works, what not to build at all, and the anti-patterns that are attractive enough to cost you a quarter.
Build it: end-to-end AI tutorials
Twenty complete AI builds — architecture, the code that runs, the failure you will actually hit, and what the thing costs to keep running.
Python for AI: hands-on recipes
Twenty short Python recipes for calling, streaming, retrying, parsing, caching, testing and profiling language models, each ending in code that runs.
TypeScript, React and the web
Calling models from TypeScript and getting the tokens into a browser: streaming, cancellation, sanitising, auth, rate limits and the runtime limits you will hit.
Frameworks and SDKs
What each AI framework's core abstraction actually is, how a real project is structured around it, where the abstraction stops helping, and what it costs to leave.
Errors and troubleshooting
The error strings a model API actually returns, what the numbers inside them mean, and how to tell which of the causes you have before you start changing things.
AI facts, numbers and statistics
The numbers behind AI, either derived in front of you from first principles or traced to the publisher who actually produced them.
The history of AI
What the founding documents of artificial intelligence actually said, separated from the folklore that grew up around them.
The maths behind AI
The twenty pieces of maths that actually appear in a working language model, each derived on the page with arithmetic you can reproduce.
Architectures beyond the transformer
How the other neural architectures work — convolutions, recurrence, state space models, autoencoders, diffusion, splatting — and what each one traded to get what it got.
Reinforcement learning
The field behind RLHF, explained for an engineer who knows language models and has never trained an agent: policies, rewards, value, and the arithmetic underneath each.
Diffusion and generative media
How diffusion models turn noise into an image, what every dial in a generation UI multiplies, and the arithmetic behind the GPU-seconds each picture costs.
Speech, audio and voice engineering
How speech becomes tokens and tokens become speech, and the latency and cost arithmetic that decides whether a voice product feels human.
Benchmarks, one at a time
What each named LLM benchmark actually contains, the exact arithmetic that turns answers into a score, and what that score does and does not license you to conclude.
AI search visibility
How assistants find, fetch and cite pages — separating the mechanisms you can verify from the tactics that are only being sold.
Infrastructure and operations
Running AI systems that are already live: containers, Kubernetes, autoscaling, spot capacity, deploys, monitoring, runbooks and the quarterly capacity review.
Databases and storage for AI
Postgres, pgvector, SQLite, Redis and object storage for AI applications — real DDL, real index parameters, and the storage arithmetic worked out rather than asserted.
Knowledge graphs and structured knowledge
How to model, extract, resolve and query structured knowledge — with the queries that similarity search cannot answer, and the parts that break at scale.
Classical ML in production
The working practice of machine learning on tables: label definitions, leakage, calibration, thresholds and causal claims, worked with numbers.
Regulation, jurisdiction by jurisdiction
What the AI rules of each major jurisdiction actually require, which of them are in force, and the documents you need when somebody asks you to prove it.
Prompt recipes and pattern library
Twenty complete, copyable prompts — one per task — each annotated line by line, with the failure it prevents and the signal that says it has stopped working.
AI for people who do not write code
Methods for using AI well without programming: how to ask, how to check the answer, and where the honest limits are.
Writing, media and creative work
Where a language model genuinely helps a writer, where it flattens the work, and the specific edits and checks that tell the two apart.
Edge and on-device AI
Running models on phones, laptops, single-board computers and microcontrollers, where memory, power and bundle size are hard limits rather than line items.
Interpretability and model internals
What is actually inside a trained model, how researchers find out, and which of those techniques survive contact with a real system.
Field notes
First-hand accounts of building and running an LLM gateway, alongside the engineering procedures that came out of them.