// Read top to bottom – or jump in by who you are:
Knowledge Was Never the Commodity
What AI actually disrupts – and what it never will. Twenty-four years of evidence on which learning decays and which compounds, why the engine underneath matters more than the technology of the year, and a starting shelf with a pointer to the full signal map.
The Six Fields AI Reaches Next
Before the mechanics, the map. Coding, hacking, robotics, politics, biology, forecasting – one honest section per field, each sorted into what currently exists, what is emerging, and what is still science fiction.
You Already Know AI – You Just Called It Search
Everything in modern AI traces back to the search engine you already know. Tokens, attention, vector retrieval, ranking – the vocabulary changed in 2017, the problems did not. The lineage, plus a real search engine taken apart into the algorithms that became AI, each one playable.
Inside the Language Model
The other half of the lineage: the machine itself. The four-layer stack the 2017 architecture produced – LLM, RAG, MCP, agents – and the AI lifecycle from prompt to answer, with tokenisation, embeddings, attention and next-token generation each one playable, inline.
What Agents Actually Need
How to actually run an agent against real systems. The three roles every production setup needs, Domain-Driven Design as the unit of agent scope, the seven requirements an agent cannot work without, and the five things you should never delegate.
AI Adoption Is Not a Tooling Problem
The teams struggling with AI are not struggling because they have bad tools. They adopted AI into processes that were never designed for it. Nine SDLC phases, one concrete failure per phase, and where things actually go wrong.
How Software Gets Built: A Field Guide to the Lifecycles
Before the forces, the ground they stand on. Every way software gets built – Waterfall, the corrective era between (prototyping, spiral, RAD), Agile, mobile-first, API-first, AI-first, spec-driven, vibe coding, agentic, loop and harness engineering – sorted into three layers over one SDLC spine, with a fingerprint and a failure mode for each.
8 Forces Reshaping How Software Gets Built
The overview map: all eight structural forces end-to-end, from requirements to reliability. Each force gets its own card – what is driving it, honest trade-offs, concrete tools, and what it means in practice. The four chapters that follow walk each pair in depth.
Before the First Line of Code: Forces 01–02
Requirements now have three readers: the user, the AI agent, and the reviewer. Domain models are the language of agent delegation. How to write for all three, and why DDD became a hard prerequisite for AI-augmented development.
The Build and the Store: Forces 03–04
Full-stack in 2026 is six parallel tracks – most teams run two. The database decision is now four decisions – most teams make one. What both forces require when AI agents are doing the building and the data has to support semantic retrieval.
The Pipeline and the Cache: Forces 05–06
One feature, five artifact types, one coordinated release – and the genuinely unsolved cross-track dependency problem. Plus the middleware layer where semantic caching quietly removes 40–70% of your AI inference bill if you design it right.
The Eval and the Runbook: Forces 07–08
Nothing in your current monitoring tells you if your AI feature is confidently wrong. The fourth test layer nobody has built, new SLOs for hallucination rate and retrieval precision, and why autonomous agent rollback is a post-hoc audit, not a recovery strategy.
AI Across the Full SDLC: A Practitioner’s Map
Where AI creates real leverage – and where it creates real risk – across each phase of software delivery. Eight forces × nine SDLC phases, with tools, impact levels, and honest annotations at every intersection. Keep it open in another tab.
AI Is Not Free – And That Was Always the Plan
The trillion-dollar infrastructure bet and the bill it produces at every level: nuclear contracts and HBM economics above you, a €1,000/month personal stack, the enterprise, and the startup paying $500K/month for 5–10 autonomous agents. The complete cost conversation, with receipts.
Where This Is Going: An Honest Look at AI Forecasts
What the most credible forecasting work – the AI Futures Project, AI-2027, METR’s time-horizon data – actually says about the next three years, and the moment a model first outran me in my own domain. No hype, no doom. Forecasts, error bars, and what to do about them.
The Adolescence of Technology, Read from the Engine Room
Dario Amodei’s January 2026 essay names five civilisational risk categories. A practitioner’s reading: which of those risks pass through the systems you and I build – and what an engineer actually controls about each one.
Securing Systems When the Attacker Has Agents Too
AI does not tilt the security balance – it speeds up both ends and adds a door nobody had to guard before: the model’s own willingness to follow instructions. Prompt injection, agent permission models, and the posture a practitioner actually owns.
Who to Actually Follow: A Signal Map for AI
The expanded version of Chapter 1’s signal shelf: who to read, what each source is actually for, a weekly rhythm, and how to build a low-noise information diet in a field where most of the loudest voices are selling something.
The Forward Deployed Engineer: A Roadmap
If you want one role to aim at, aim here: the last-mile engineer who carries AI from demo to production inside a real customer's world, where software, product, and the model meet. A learnable route across seven stages, now one of the roles mapped in From Engineer to AI Engineer.
The Model Is a Procurement Decision
A model family is not a technology choice, it is a vendor you are signing with. Five questions a procurement process already asks, aimed at Claude, GPT, Gemini, and the open-weights door, and the licence clause almost everyone skips reading.
The Smallest Thing That Works: How an AI Chat Assistant Works
A chat assistant is not an invention, it is an integration: the model, the window, retrieval, and the index wired so one question walks through all four and comes out grounded. The smallest complete system, traced end to end, and the seams where a system of correct parts still lies.
The Payload Contract: Context Engineering 101
The context window is a contract with a budget: every token either earns its seat or costs you one. The five claimants competing for the window, the five moves that ration it, why bigger windows did not fix anything, and when a few sharp tools beat an index.
The Search Engine Under the Answer: How RAG Works
Search failed loudly, with ten visibly wrong links; RAG fails quietly, in confident prose. The two pipelines under every RAG system, chunking as an editorial act, hybrid retrieval and rerankers, and the five production failure modes with the symptoms that give them away.
The Index Allowed to Be Wrong: How Vector Databases Work
Every index you ever trusted promised exactness; this one trades it for speed, on purpose. Meaning as coordinates, the graph you hop and the partitions you probe, quantization, the recall dial you must measure, and when a plain scan beats the whole machine.
One Contract, Every Tool: How MCP Works
The Model Context Protocol read like the API standard it is: the N-times-M integration problem it kills, the four-message conversation on the wire, the three primitives as trust boundaries, and why the model's confusion is your contract's failure rate.
The Loop Around the Model: How AI Agents Work
Think, act, observe, repeat: the mechanical floor under every agent. The three exits every sane loop needs, the autonomy dial from chat to fleet, and the reconciler you have run your whole career – with a learned policy where your hand-written one used to be.
The Node That Rebuilds Itself: Agent Memory 101
The transcript is what an agent remembers; memory is what it refuses to forget. The layers that outlive a run, each a different store with a different bill, why only one is ever a vector database, and the write path that decides what earns durability and who signs it.
The Moves the Loop Can Make: Agentic Patterns 101
A pattern is a name for a move you were already making, and the name is the part your teammates can use. The Gang of Four move applied to the agent loop: reflection, planning, routing, delegation, each with a shape and an overkill zone, and the line where a pattern becomes a fleet.
The Fleet Is a Distributed System: Multi-Agent Architectures 101
Split one agent into many and you re-inherit every distributed-systems problem a single loop let you ignore. The four topologies, the fallacies of distributed computing come back, and why a fleet you did not earn is a distributed monolith that also hallucinates.
One Contract, Every Agent: How A2A Works
MCP let a model reach down to your tools; A2A lets your agent reach across to someone else's. The same one-contract move, turned ninety degrees: agent cards, the task lifecycle, and the trust that now crosses an org line.
Tests, With a Probabilistic Twist: LLM Evals 101
An eval is a test that grades instead of asserts: a golden set instead of fixtures, a scorer instead of assertEquals, a threshold instead of a green bar. Judge models and their biases, offline gates and online truth, and why you grade an agent's journey, not just its answer.
The System That Learns Back: ML System Design 101
The go-deep door of Stage 06. ML system design is system design with one dependency promoted to first-class citizen: the data, which is the spec, decays under you, and feeds on your own outputs. The loop that can poison itself, and the non-functional requirements you already run, in new units.
The Reward Is the Whole Problem: Reinforcement Learning 101
You do not tell the model the right answer, you pay it for an outcome, and whatever you pay for is exactly what you get. Reinforcement learning at shape level, where you have already met it in the assistants you use, and why reward hacking is the cobra effect with a gradient.
The Metal Under the Model: AI Infrastructure 101
Everyone prices the model; almost nobody prices the serving. What actually happens between your API call and the GPU – prefill, decode, the KV cache – why GPUs refuse to autoscale like web servers, three doors to run a model through, and the six cost knobs a cloud architect already owns.
You Already Knew This: Agentic Engineering Concepts 101
Every dive on this shelf was one argument, seen from a different side. Agentic engineering is software engineering pointed at a component that reasons instead of returns, and every hard part is an old rigour applied to the one new part. You already knew this. Now you know its name.
We Learned to Code So That Others Could Type a Prompt
What it actually means that the next generation may never write a line of code – and why that is both true and more complicated than the headline.
Read →Baba, What Should I Study?
My son asked me what to study in a world reshaped by AI. This is what I told him – not as a shortcut, but as a genuine answer about foundations.
Read →My Father's Gamble
In 2002, I built an AI-powered trip planner for my master's project. The technology did not exist to make it work. Twenty years later, it does. What that gap taught me.
Read →