Lessons

Fine-tuning and retrieval are usually presented as alternatives when they change different things. This lesson separates them precisely: fine-tuning adjusts weights and teaches behaviour, retrieval supplies context and teaches nothing, and the question that decides between them is whether your problem is knowledge or form.

Dense vectors miss exact terms, so production retrieval combines them with lexical search. This lesson covers hybrid retrieval and reciprocal rank fusion, a tuning method that starts from a stated recall target, capacity planning, the operational failures that catch teams, and how to choose between running your own index and buying a service.

Three ideas carry almost all production vector search. This lesson covers HNSW as a navigable small-world graph with its M and ef parameters, IVF as coarse partitioning with nprobe, and the quantization schemes that cut memory by an order of magnitude, plus how they compose into the hybrid indexes real systems actually run.

Vector search exists because exact nearest neighbour search is intractable at scale and the curse of dimensionality defeats the classical index structures. This lesson covers distance metrics and when each is right, why brute force costs what it does, why k-d trees fail above a few dozen dimensions, and the recall-latency trade that every approximate index makes.

An audit is only useful if it produces a decision. This lesson covers the audit sequence end to end, the three families of mitigation and what each costs, why some findings cannot be fixed at the model layer, documenting a trade-off you can defend, and monitoring for the drift that reopens a closed finding.

Fairness has several formal definitions that sound equally reasonable and cannot all hold at once. This lesson covers demographic parity, equal opportunity, equalized odds and calibration, the impossibility result proved independently by Chouldechova and by Kleinberg and colleagues, and how to choose one deliberately and defend it.

The word bias carries three unrelated meanings that get argued past each other. This lesson separates them, then traces the six points where disparity enters a machine learning system, from historical data through label definition and objective choice to deployment, and explains why removing a protected attribute does not remove its influence.

A responsible AI programme is judged by what happens after launch. This lesson covers recognising an AI harm, building a redress route for people affected, reviewing incidents for the decisions that caused them, measuring the programme honestly, and the failure modes that hollow it out over a year.

Controls only work if a team meets them inside their normal process at a point where answers can still change the design. This lesson covers the three gates, writing a checklist that produces decisions rather than ticks, model and system cards, and giving someone the authority to stop a launch.

Almost every organisation has AI principles and almost none can point to a shipping decision they changed. This lesson covers why abstract commitments fail to bind, the specific gap between a value and a decision rule, ethics washing, and what a principle needs before it can affect anything.

A redesign has to be introduced into a process that is still running and still has customers. This lesson covers sequencing, running the old and new paths together, the counterweight metrics that catch a hollow win, the failure modes that end these efforts, and how to know when not to redesign at all.

When one step becomes cheap, the optimal shape of the whole process changes. This lesson covers the six moves that follow, why the review stage almost always needs relocating, what business process reengineering actually taught, and the honest state of the evidence on how often these efforts succeed.

You cannot redesign a process you have not observed, and the documented process is rarely the real one. This lesson covers task-level decomposition, finding where time and waiting actually go, identifying the constraint that governs throughput, and the measurements to take before any AI is introduced.

Mandated adoption produces compliance behaviour and licence-seat metrics that measure nothing. This lesson covers why mandates fail, what resistance is actually telling you, measuring adoption in a way that survives scrutiny, the equity problems that appear inside a team, and how to run the change without losing the people carrying it.

Delegating to AI is a management decision with the same structure as delegating to a person, and one crucial difference. This lesson covers the criteria that make a task a good candidate, the verification tax that determines whether delegation actually saves anything, disclosure norms, and redesigning a workflow rather than bolting AI onto it.

AI changes tasks rather than jobs, which means it redistributes work inside a role instead of removing the role. This lesson covers what that does to a manager: where review load lands, why self-reported productivity is unreliable, the skill-formation problem for junior staff, and which management assumptions stop holding.

An AI QA function has to be built while features are already shipping. This lesson covers the order of work that produces something useful fast, where the function should sit, how to handle a team that resists a new gate, what to measure about the function itself, and the failure modes that quietly end it.

A release gate turns evaluation results into a decision someone can defend. This lesson covers what belongs in the gate, setting thresholds before you see results, blocking versus flagging, how to gate a provider model change you did not initiate, and running the gate so it stays credible rather than becoming a formality.

Software QA assumes a specification, deterministic behaviour, and a system that changes only when you change it. AI features violate all three. This lesson covers what actually breaks, why test counts and pass rates stop meaning anything, and the shift from verifying correctness to characterising a distribution of behaviour.

The most valuable behaviour an AI system can have is refusing to answer when it should not. This lesson covers calibration and why stated confidence is unreliable, selective prediction and the coverage-accuracy trade, conformal methods that give guarantees, designing abstention users accept, and measuring all of it in production.

Since a model cannot judge its own output, detection has to compare it against something external. This lesson covers grounding through retrieval and why it reduces rather than eliminates the problem, then the detection methods that work: self-consistency sampling, entailment checking against sources, claim decomposition, and chain-of-verification.

Hallucination is not a bug that will be patched out. This lesson covers why a next-token predictor produces confident falsehoods, the dual-axis taxonomy separating intrinsic from extrinsic and factuality from faithfulness, why fluency carries no signal about truth, and the theoretical result that the problem cannot be fully eliminated.

Validation was built for models that produce a number, not for systems that produce prose. This lesson covers conceptual soundness, outcomes analysis and ongoing monitoring applied to modern AI, what changes for generative systems, the pre-deployment evidence pack, and how to document a position when no framework covers your system.

Human oversight is the control regulators lean on hardest and the one most often decorative. This lesson covers the four conditions that make it real, how to evidence each rather than assert it, the override rate as the diagnostic, and the audit trail needed to reconstruct a single decision eighteen months later.