AI Engineer
Model behaviour, retrieval, agents, and evaluation.
- Python for data — pandas, vectorisation, and polarsA measured 50x gap between a Python loop and a vectorised pandas operation, the SettingWithCopyWarning that means your edit silently didn't happen, and why polars closes both problems by construction rather than by convention.
- Document and PDF extractionWhy a PDF has no concept of a table, how layout-aware extraction reconstructs structure from position rather than reading markup that doesn't exist, and the silent column-misalignment failure that looks fine until someone checks the numbers.
- pgvectorVector search inside Postgres — what you gain by not standing up a second datastore, what HNSW costs in index build time and memory, and when the "one less service" argument stops being the right trade.
- Vector databases comparedPinecone, Qdrant, and Weaviate implement the same ANN algorithms pgvector does — what actually differs is operations, filtering, and how each one degrades at the corpus size pgvector stops being comfortable.
- How LLMs workThe mental model an engineer actually needs — next-token prediction, attention, context as the only state, and which observed behaviours follow from the architecture rather than from a bug.
- Tokens and samplingWhat temperature, top-p and top-k actually do to a probability distribution, why they interact, and why "set temperature to 0 for reproducibility" is only half true.
- PromptingWhat actually moves the needle — structure, examples, and output contracts — and how to tell a prompt problem from a retrieval problem before spending a week on the wrong one.
- Context engineeringThe context window is a budget, not a container. How to decide what goes in it, in what order, and what to do when the conversation outgrows it.
- HallucinationsWhy fabrication is a property of the training objective rather than a bug, what actually reduces it, and how to build a system that fails loudly instead of confidently.
- EvaluationHow to know whether a change made things better — building a golden set, choosing metrics that survive contact with production, and using an LLM judge without fooling yourself.
- EmbeddingsHow text becomes a vector, why similarity is an angle rather than a distance, and the failure modes that make a retrieval system quietly return the wrong documents.
- Vector searchApproximate nearest neighbour search — what HNSW actually trades away, why recall is a dial rather than a property, and the memory cliff that turns a fast index into a slow one.
- RAGRetrieval-augmented generation as a pipeline of separately-measurable stages — and why debugging it end-to-end is the most expensive mistake in the field.
- Chunking and retrievalWhy chunk size is not a knob you can reason about monotonically, what overlap actually buys, and how an answer that is provably in your corpus becomes unretrievable.
- Reranking and hybrid searchWhy embeddings are bad at identifiers, how to fuse two rankings whose scores are not comparable, and where a cross-encoder earns its latency.
- Tool useFunction calling as an interface design problem — why the schema is the prompt, what a tool should return, and the authorisation mistake that turns a helpful agent into a confused deputy.
- AgentsThe think-act-observe loop, the four ways it fails in production, and why the controls around the loop matter more than the model inside it.
- Agent orchestrationMulti-agent systems — when splitting genuinely helps, why context does not cross agent boundaries for free, and the coordination costs nobody budgets for.
- LLMOpsRunning LLM features in production — what to log when output is non-deterministic, where the cost actually goes, and how to ship a model upgrade without breaking things silently.
- GuardrailsPrompt injection has no clean fix, and understanding why tells you where the real controls go — output validation, capability limits, and authorisation that never trusts the model.
- Machine learning fundamentalsThe vocabulary an AI engineer needs — what training actually optimises, why accuracy is usually the wrong metric, and how to read a model someone else built.
- ML data preparationLeakage, splits, encoding and imbalance — the stage where most model quality is won or lost, and where the bugs are silent by construction.
- AI data readinessAssessing whether a corpus can support an AI feature at all — the audit to run before the project, and the findings that should stop it.
- Knowledge graphsWhen entities and relationships beat embeddings — multi-hop questions, aggregation, and the extraction cost that decides whether a graph is worth building.
- GPU serving — memory, batching, and the throughput you're leaving on the tableGPU memory and GPU utilisation are different numbers measuring different things, continuous batching is why vLLM serves several times the traffic of a naive loop, and CUDA OOM is almost never "just add more VRAM."
- LLM gateway — routing, fallback, and cost attribution across providersA gateway is the one place that knows every provider's health, every tenant's spend, and which request should fail over to what — pulling routing logic out of application code before the second provider makes it unavoidable.
- Prompt versioning — treating a prompt as a deployable artefactA prompt edit that quietly regresses quality is a deploy with no diff, no review, and no rollback unless prompts are versioned, tested, and released like code — not typed into a string constant and shipped.
- The incident method — why fixing is step sevenDetect, isolate, mitigate, investigate, fix, prevent — the order production incidents actually get resolved in, and why jumping straight to a fix is the single most common mistake under pressure.
- Reading the symptoms — CPU, latency, and what each combination rules outLow CPU and high latency means waiting, not working — measured from a real service genuinely faulted six different ways, not asserted. The single fact this whole section is built around.
- Distributed tracing — spans, context propagation, and where the time actually wentA trace is a tree of spans reconstructing one request across every service it touched. Drag one span's duration and watch why optimising the wrong one is arithmetically irrelevant.
- Cascading failures — how one slow dependency becomes a total outageA downstream 429 turned into a 5x amplification, captured for real — bulkheads, backpressure, and load shedding as the three mechanisms that stop one failure from becoming every failure.
- Capacity estimation — the back-of-the-envelope math that catches a bad plan earlyQPS, storage, bandwidth, and Little's Law worked as real arithmetic, not asserted — the estimate that tells you a plan won't work before you've built anything.
- AI incident catalogue — the failure modes unique to LLM systemsPrompt growth silently turning into a latency and cost regression, a retry loop between two agents that never terminates, a retrieval pipeline that went quiet — the incident shapes that don't show up in a normal backend's playbook.