Thinking out loud.
Building in the open.
Notes on AI engineering, distributed systems, and the products I build along the way, alongside guest editions from my coauthor Shamim Bhuiyan.
Research. Field notes.
Questions worth asking.
Two deploy traps after a day of parallel agents
Five agents worked on one repo for a day. The code was fine. Deploying it was the risky part, and a handoff file kept me safe.
The cliff in the Crystal Palace garden: a bug that was not the terrain
A grey cliff appeared in my 3D map of Porto. The terrain data looked guilty. It was innocent. The cause was a level pad cut 61.6 metres deep.
Capturing UI inspiration with headless Playwright
How I collect daily UI inspiration from product sites with a headless browser, and the small rules that keep the captures clean.
Cleaning 98 GB down to 21 GB, and the backup I chose not to make
An audit of my Dev folder removed 77 GB. The more useful part was a plan I did not run.
Moving a small site off WordPress to a Cloudflare Worker
A WordPress site became a static site on a Cloudflare Worker, with the same design and a mobile PageSpeed score of 93. What worked and what did not.
One engine, many cities: what I learned scaling a 3D map
Braga became four city maps on one engine. Notes on forks versus monorepos, performance work, and keeping long agent runs recoverable.
Building Braga in 3D at real scale
How I built an interactive map of Braga where every building sits on its real footprint, and the rule that kept it honest.
How the Claude Code team does code review: a short summary
A short summary of Anthropic's engineering post on reviewing code at high volume: machines read first, people spend their time where risk is highest.
From Copilot to Colleague: the book and how I built it
A ten-chapter book on AI engineering, built from 794 practitioner talks, where every claim points to the exact moment it came from.
AI engineering starts when answers become delegated work
Chapter 1 argues the hard problem in AI is no longer better answers. It is trusting a system that comes back with work done.
Five checks to run before you delegate work to an AI
Turn the Chapter 1 checklist into a week of small, concrete steps that show whether your AI system is ready to take on delegated work.
Meridian's coding agent worked until the scope grew
A composite fintech case from Chapter 1 shows why erratic agent quality often points to the workplace, not the model.
When code gets cheap, judgment gets expensive
Chapter 2 argues that cheap generation does not remove the human contribution. It makes taste, the ability to tell good from convincing, easier to see.
A week-long plan to keep taste in your AI workflow
Five habits from the Chapter 2 checklist, laid out as steps a team can start this week to protect quality as generation gets cheap.
The Friday app and the Monday rewrite
Corey Gallon's vibe-coding hangover, quoted in Chapter 2, shows when a fast exploratory build has outlived its usefulness.
Blame the workplace before you blame the model
When coding agents disappoint, the cause is often a repository nobody made legible. Chapter 3 argues the harness matters before the model does.
Five repo changes that make agents useful this week
A practical plan from Chapter 3. Five steps a team can start this week to turn a repository into a place where a coding agent can work.
A Tuesday in the slop era
A migration passes every test and still breaks two rules nobody wrote down. A scene from Chapter 3 shows why the agent guessed.
A working demo is not a control loop
Models look right often enough that teams stop measuring. Chapter 4 argues that evals are the control system that makes delegation safe to trust.
Build an eval habit from your own failures
Five steps from Chapter 4 that a team can take this week to turn real failures into evals, traces, and a habit that keeps improving the system.
The patch that looked fine and stalled the backfills
A rate-limiting patch compiles, passes tests, and still drifts production. A scene from Chapter 4 shows what a regression case is for.
Context is the working set, not the knowledge base
The book argues that AI systems fail when they assemble the wrong working set, not only when the model is weak. Here is the idea in short.
A week of context checks for your retrieval system
Five checks from the Chapter 5 checklist that a team can run in one week to find out whether context assembly or the model is the problem.
The deduction that cited the wrong source
A tax assistant at Hargrove ranked a public explainer above a senior attorney's matter note. The fix taught the team what context topology means.
Agents are stateful workflows with probabilistic nodes
Chapter 6 argues that a production agent needs durable state, recovery, and human review points. A chat transcript cannot supply them.
Runtime decisions to settle before you add more agents
Five checklist items from Chapter 6 turned into steps a team can take this week, from replay versus snapshots to isolated environments for each worker.
When Meridian's subagents disagreed
Meridian asked its agents to investigate, patch, and report, and parallel work turned into fragments. The scene shows why coordination is the missing piece.
Build so that an agent being wrong is survivable
A model should never enforce its own power. Chapter 7 argues for sandboxes, narrow scopes, and boundaries that hold when the model is wrong.
Five agent security steps a team can take this week
Chapter 7 ends with a short checklist. Here is how a team can turn it into five concrete actions before the next sprint ends.
The day a client disputes what the assistant filed
A scene from Chapter 7 shows why audit trails matter as much as blocking bad actions, and what a partner can say when asked what happened.
Voice is a stress test for the whole agent system
Text chat forgives weak design. Chapter 8 argues that voice removes that mercy and shows whether the loop around the model is sound.
Five voice agent changes a team can try this week
Chapter 8 ends with five practical rules for realtime agents. Here is how to apply each one in a week without rebuilding your stack.
When a caller interrupts, your runtime gets tested
A support-call scene from Chapter 8 shows that interruption handling is about execution semantics, not UX polish, and what to design for.
AI moves the bottleneck from typing to judgment
The biggest gains from AI come from redesigning the organization, not from better tools for individuals. Scarcity moves upward, and work must follow.
Five checks to run on your AI-native team this week
Chapter 9 ends with a practical checklist. Here is how a team can turn each item into a concrete step in one week, starting with the queue.
A Monday morning at Meridian, and the coherence problem
A staff engineer returns to twelve pull requests and no reckless act. The scene in Chapter 9 shows why output is no longer the scarce thing.
What endures in AI engineering is constrained delegation
Frameworks, models and interfaces will keep changing. Chapter 10 argues that one pattern for turning machine capability into dependable work will last.
A week of work toward constrained delegation
Chapter 10 closes with five practical steps. Here is how a team can run the diagnostic, set an autonomy dial and name an owner in one week.
What remains human is responsibility, not typing
Chapter 10 argues the lasting human role in AI work is responsibility. A six-month test shows whether you have actually assigned it.
Specifications that outlast the model
Models change quickly. A clear description of intended behaviour gives an engineering team something stable to build and review against.
Building Zonelyte: from an AI prototype to a tool my team could use
What building a timezone workspace taught me about AI prototyping, Firebase, early feedback, and the work between a demo and a product.
AI progress, and the developers living through it
A revised personal reflection on AI-assisted development, career uncertainty, engineering judgment, and the distance between capability and dependable work.
Our generative AI book reaches a Russian edition
A personal publishing milestone: the Russian edition of our book, copies arriving from Bombora, and the pleasure of sharing the work beyond its original audience.
Missing Directus translations? Check the related collection permissions
A debugging note from my Stack Overflow answer: separate the translation query from the permissions needed to read the related records.
Better AI agents show their work
Why editable intermediate work can make an AI assistant easier to guide, verify, and improve.
MCP and REST APIs, part 3: build an inspectable Python agent
Use mcp-agent to connect tool discovery, local inference, and a warehouse summary without hiding the application’s responsibilities.
MCP and REST APIs, part 2: connect a local model to the service
Connect Ollama and mcp-cli to the warehouse example, then separate tool discovery from correct execution.
MCP and REST APIs, part 1: expose warehouse operations as tools
Build the service boundary first: FastAPI operations, Redis data, MCP tools, and direct inspection before adding a model.
Local AI content pipelines: build a reviewable draft, then publish
Use local models to structure research, drafting, and editing without confusing generated volume with useful technical content.
A2A in practice: a travel planner with separate agent services
Follow a historical weather, search, and local-model example to understand discovery, service boundaries, and task coordination.
OpenAI Agents SDK with a local model: make the workflow explicit
A planner-and-writer example that separates local inference, search tools, orchestration, and tracing.
MCP with local language models: host, client, server, and tools
Understand where the local model sits in an MCP application and how to test a small tool integration before adding more servers.
Minion and Minions: testing collaboration between local and cloud models
A historical experiment with HazyResearch’s local/cloud model collaboration, and the measurements that make its tradeoffs visible.
Project One: Daily Affirmations
Web crawling for local RAG: keep the evidence visible
Extend a local retrieval pipeline with Crawl4AI, while retaining source URLs and checking what the crawler actually captured.
What local AI meant to my work at the end of 2024
A revised year-end note on government-contract projects, local language models, and choosing a useful workflow before choosing a model.
From a school charity market to a New Year’s Ideas Generator
A paper box of celebration ideas became a small bilingual web app. A project note about preserving the human interaction that made the idea work.
Welcome to My World of Innovation, Leadership, and Cutting-Edge Technology 🚀
Local RAG: from documents to answers you can inspect
Follow the path from source text to retrieved passages and a local answer, with a clear distinction between embeddings and evidence.
Llama 3.2 Vision: understanding the local inference workflow
A historical walkthrough of image-and-text inference using a vision model, its processor, and a notebook you can inspect.
Installing your first local LLM: a small, useful starting point
Start with one local model, verify inference, and understand the boundary between your machine, its network, and optional tools.
Returning to coauthoring: from Apache Ignite to generative AI
Seven years after our Apache Ignite book, Shamim Bhuiyan and I returned to writing together with a hands-on guide to building AI applications.
Lightbend Reactive Architecture Learning Path
Documenting Play Framework with Swagger
Showing 64 of 64 articles