Blog
On engineering leadership, architecture, AI, and building things that last.
Bridging Strategy and Execution in the Age of AI Agents
AI changed what's fast. Nobody changed what's slow. Teams are merging twice as many pull requests while review times double and bug rates climb. The bottleneck moved — and most organisations are only now starting to notice.
Every Dependency Is a Decision You Didn't Make
Your lockfile is hundreds of trust relationships nobody negotiated. The highest-profile supply chain attacks of the last decade exploited trust, not code — and no scanner caught any of them in time.
Scaling from 5 to 40 Engineers Without Losing the Plot
The magic of a small team isn't culture — it's proximity. When you scale, you can't preserve it. You have to replace it with something deliberately designed. Most teams import a playbook from a company ten times their size instead.
Strangler Fig in Practice: Migrating Legacy Without the Big Bang
Everyone knows the strangler fig pattern. Few teams finish the migration. Here's what actually kills it — and the fixes that work.
Operating a Live Trading System: What Breaks and What Saves You
Operational failures kill more personal trading systems than bad strategies. What actually goes wrong at 3 a.m. — and the defences that earn their place.
Capital Safety Is an Architecture Decision
How Meridian — a personal crypto trading system — treats capital safety as a first-class architecture constraint, with defence in depth, state machines, and automatic emergency procedures.
Eight Editors, Zero Writers: Why I'm Building Scriptorium
I've finished books but never sent the fiction to agents — never felt it was ready. Twenty years later, I'm building the tool I wish I'd had: not an AI that writes for you, but one that reads like a professional editor.
Context Engineering: The Skill That Replaced Prompt Engineering
Everyone's talking about context engineering as if it's a prompting technique. It's not. It's the skill that determines whether your AI investment produces strategy or noise — and the part that matters most has nothing to do with code.
The First 90 Days as a Fractional CTO
The 90-day plan looks clean on paper. Discovery, diagnosis, roadmap. In practice, you're three weeks in and the client is asking you to ship a feature. Here's what actually happens — and the line you need to hold.
Micro-Frontends: When to Split and When to Stay
Micro-frontends solve a real problem — but only if you actually have that problem. A practical guide to when the split is worth it, what the architecture really costs, and the pain points nobody warns you about.
The Invisible Architecture: How Culture Eats Strategy in Engineering
Incentives, information flow, and the norms that survive scaling — the invisible architecture underneath every engineering system you build.
Diff: Code Review Context Your LLM Actually Needs
Pasting a raw git diff into your LLM is asking for a review with half the files missing. cxpak diff adds callers, callees, and type signatures — within a token budget.
Post-Quantum Cryptography: A Practical Primer
The standards are final, the migration clocks are ticking, and your TLS traffic is probably already using post-quantum key exchange. Here's what the algorithms actually do, what's deployed, and what you should do about it.
Human-in-the-Loop: Why Full Automation Is the Wrong Goal
The best AI systems aren't autonomous. They're collaborative. Full automation is a seductive goal that breaks on contact with reality — the winning pattern is bounded autonomy.
Trace: Finding the Code That Matters Before Your LLM Sees It
Most LLM context is wasted on code that doesn't matter. cxpak's trace command walks your dependency graph and packs only the relevant paths — so your model debugs with a map, not a haystack.
First Steps as a Team Lead: Rules I Wish I'd Known
Every leadership book gives you the same ten rules. Most of them are right. All of them are incomplete. What I'd tell myself before stepping into the role.
Resilient by Design: What I Learned Building for Regulated Finance
Most engineers optimise for uptime. In regulated finance, that instinct will cost you. What I learned about failing hard, recovering deliberately, and building compliance into the architecture.
Spending CPU Cycles So You Don't Spend Tokens: Building cxpak
Why I built a Rust CLI that packages codebases into token-budgeted briefings for LLMs — and what I learned about the real cost of context.
The Appropriate Level of Complexity
Over-engineering is a well-known sin. Under-engineering is the same sin wearing a different hat. The goal was never simplicity — it was the right complexity, designed to evolve.
Setting Up Multi-Agent Workflows with Claude Code
What I learned building a trading platform backoffice with six AI agents — before the playbook existed.