Search

28 posts indexed.

• Why I treat AI agents as identities first

  Why I govern AI agents as identities with delegated authority: who acted, for whom, under which rule, and how to stop it. A personal take on six layers.

• What goes into my AI agent harness (and what I leave out)

  What's in my AI agent harness: one way out to the models, narrow retries, approval-gated write tools, per-step cost records and evals, and what I cut.

• Bounded contexts and monadic composition: how I structure code for AI coding agents

  How I structure code for AI coding agents: bounded contexts as packages with tested edges, typed errors, effects kept at the edges and a short AGENTS.md.

• The evals I actually run on LLM features, and how I roll them back

  The evals I run on LLM features: a small fixed task set, deterministic checks, a two-vendor judge panel, a written promotion rule and settings rollback.

• Quality gates for AI-written code: what I check before anything merges

  The gates AI-written code passes before merge: decision records first, ordered CI checks, hard and advisory gates, ratchets, and checks I stopped running.

• Building Grid: a dashboard of Britain's electricity system from public data

  Grid is a public dashboard of Great Britain's electricity system, built from Elexon, NESO, Carbon Intensity API and Sheffield Solar PV Live data.

• Why I named my company Comonad

  What a comonad is, how it mirrors the monad, where it shows up in real code, and how the idea maps onto the work of a London applied-AI company.

• We are what we think

  How I changed what I read and watched, and who I spent time with, and why cutting back on short-form video and negative news eased my anxiety.

• Fail fast: sunk cost, ego and knowing when to stop

  Why stopping early is a skill: how sunk cost and ego keep us on the wrong path, and how I decide to stop and move on faster.

• Why I journal

  How daily journaling helped me with anxiety, focus and memory, why it was hard at first, and how it taught me to separate what I control from what I don't.

• Every skill is learnable

  Almost everything is a skill you can learn: languages, sales, leadership. Why I think small daily practice beats talent, and how I apply it.

• Become a doer

  I have always preferred theory to practice. How I work on becoming a doer: why interest fades after the idea, and what gets me to finish things.

• Entrepreneur Revolution and Key Person of Influence - Daniel Priestley

  My notes on two Daniel Priestley books: Entrepreneur Revolution, on creating rather than consuming, and Key Person of Influence, with its five Ps.

• Turning disaster recovery into an engaging game

  How I turned dull disaster recovery training into a game, with a game master, players and one goal: recover the system. What changed in the team.

• Think Big - Dr Grace Lordan

  My notes on Dr Grace Lordan's Think Big: small steps, behavioural science and Stoic ideas, and the effort-and-luck point I keep coming back to.

• The Phoenix Project - Gene Kim, Kevin Behr and George Spafford

  My notes on The Phoenix Project by Gene Kim, Kevin Behr and George Spafford: flow, work in progress and DevOps lessons from a software architect.

• Stillness Is the Key - Ryan Holiday

  My notes on Ryan Holiday's Stillness Is the Key: Seneca, Marcus Aurelius and practical ways to find calm and focus in a noisy life.

• Ten common anti-patterns in software development

  Ten common anti-patterns (global state, god objects, spaghetti code, magic numbers and more), each with why it happens and why it hurts.

• SOLID principles, with pros and cons

  The five SOLID principles (SRP, OCP, LSP, ISP, DIP), each with a plain definition, a short formal view, and the trade-offs of applying it.

• Architecture styles: a working vocabulary

  Monolith, n-tier, event-driven, microkernel, microservices, serverless and CQRS: what each architecture pattern is, where it fits and its trade-offs.

• Side effects and I/O: containing the parts that touch the world

  Why side effects and I/O are unavoidable, why they make code harder to reason about, and how to isolate them behind clear boundaries.

• Monads 101: the common ones in plain terms

  A plain guide to monads without category theory: Identity, Maybe, Either, List, State, IO, Reader, Writer and Continuation, with what each is for.

• Ego Is the Enemy - Ryan Holiday

  My notes on Ryan Holiday's Ego Is the Enemy: ego as an unhealthy belief in our own importance, and how it gets in the way of ambition and success.

• The GIL and JIT compilation in Python

  What Python's Global Interpreter Lock and JIT compilation are, how they affect performance and concurrency, and how they differ. Updated for 2026.

• Types of databases: relational, column, document, graph and time-series

  Relational, column-based, document, graph and time-series databases: how each stores data, when to use it, and the maths underneath.

• Translating Python to JavaScript with the ast module

  Build a small Python-to-JavaScript translator with Python's ast module: parse to an abstract syntax tree, walk the nodes and emit JavaScript.

• Cyclomatic complexity in Python, measured with ast

  What cyclomatic complexity is (McCabe, 1976), why it matters, and how to calculate it for any Python file with the standard ast module.

• The Obstacle Is the Way - Ryan Holiday

  My notes on Ryan Holiday's The Obstacle Is the Way (perception, action and will) and Courage Is Calling, the first book in his series on Stoic virtues.