Written by the people who sign it off
New models, new agent frameworks, new risks: we write about what moves in AI and engineering, and what it means for the software you run. Practical takes in plain English, from the people who sign it off.
Is AI-generated code safe to ship? A senior engineer's guide
AI-built code is usually safe to run and often not safe to ship. A senior engineer's guide to the difference, the evidence, and how a review gate makes AI-generated software safe to put in front of customers.
Why AI agents fail in production: the failure modes and how to prevent them
Most AI agents that fail in production do not fail because the model is weak. They fail because per-step errors compound, behaviour is non-deterministic, and the system ships without evaluation, observability, or a human checkpoint. Here is what we find when we audit them, and how to prevent it.
GPT-5.6: what it means for the software you run
OpenAI released GPT-5.6 today in three tiers: Sol, Terra and Luna. Cheaper code, four agents in parallel, and a coding benchmark nobody outside the vendors has verified. What an independent evaluator found when it tested the flagship, and what the release changes for the software you run.
AI technical debt: what AI coding tools leave behind, and how to pay it down
AI coding tools do not invent technical debt, they accelerate it, generating code faster than any team can review, understand and refactor. This guide covers what AI-built code leaves behind, from duplicated logic and shallow tests to hallucinated dependencies and security debt, why it accrues by default, and how a senior review gate pays it back before the interest compounds.
Non-human identity: how to govern the machine actors on the systems you run
Machine identities outnumber people many times over, they are broadly permissioned, and they are barely watched. A non-human identity is any credential software uses to act: a service account, an API key, a token, or an AI agent. A senior guide to governing them with the same discipline you already give your people.
AI agent audit trails: how to prove what an agent did on a system you manage
You can grant an AI agent access carefully and still be unable to say what it did. On a system you do not own, that record is the deliverable. How to give an agent its own identity and build an attributable, tamper-evident audit trail you could hand to a client or an auditor.
Should you let an AI agent onto your servers? How to grant access you can take back
The next wave of AI agents does not suggest, it acts: it restarts services, runs migrations, changes live settings. The moment an agent needs real access, the question is not whether the model is capable but whether you can scope, record and revoke what it touches. Handing it a person's standing credential is the mistake.
We audited one of our own internal tools. Here is what we found
We used to keep a small internal tool for passwordless access to the open-source applications we run for ourselves. It was built with outside help and never put through our own senior review. When we finally reviewed it, it failed: a hard-coded key, weak credential storage, a disabled authorisation check, an end-of-life stack. None of it needed AI, which is the point.
The Claude Fable 5 export ban: what it means for the software you run
Anthropic's Claude Fable 5 and Mythos 5 were suspended by a US export control directive days after launch, then restored. What actually happened, what Anthropic disputes, and what a vendor-tested model missing a jailbreak means for the AI-built software your team ships.
Claude Sonnet 5: what it means for the software you run
Anthropic released Claude Sonnet 5 today, with coding and agentic performance close to Opus 4.8 at Sonnet-tier prices. What the release actually changes, and what it means for the AI-generated code your team is already shipping, in our continuing industry-news coverage.
Securing software you built, inherited, or self-host: a senior guide
Software you built, inherited, or self-host all need the same thing: a security review against recognised standards. A senior, sourced guide to what the review covers, the vulnerability classes that matter, and how to run it.
Bespoke software, done to a senior standard
What a senior engineering standard means for bespoke (custom) software, how serious teams measure delivery, why the AI era raises the stakes, and what to expect from a serious build partner.
AI agent evaluation: how to measure whether your agent works
How to evaluate an AI agent properly: task success against known-good outcomes, end-to-end scoring, safety and refusal testing, regression on every change, and the limits of using an LLM as a judge.
From AI MVP to production: what it actually takes
An AI-built MVP becomes production-ready when its security, tests, observability, performance and architecture meet a standard a senior engineer will sign off. What that work involves, and how to decide what to keep, harden or rebuild.
Self-hosting AI agents: a practical guide for UK businesses
When and how a UK business should self-host an AI agent: the real risks, when it beats a managed service, the hardening essentials, UK data residency, and why the real cost is ongoing operations.
Pre-acquisition code due diligence for AI-built products
Technical due diligence on an AI-built product: what a reviewer finds in an afternoon, how findings map to deal risk, and what a decisive diligence report contains.
OWASP Top 10 for LLM applications, in plain English
The OWASP Top 10 for LLM Applications 2025, explained in plain English: all ten risks from prompt injection to unbounded consumption, each with an example and what to do.
How to build a reliable AI agent: guardrails, evaluation, observability
A reliable AI agent does the right thing, refuses the wrong thing, and leaves a trace. Reliability comes from three disciplines around the model: guardrails, evaluation and observability.
Prompt injection explained: the risk in any LLM feature
Prompt injection is when content a model reads is treated as an instruction. Why it is the top LLM risk, why it is worse than SQL injection, the EchoLeak case, and what actually contains it.
How to review AI-generated code: a practical checklist
The structured review a senior engineer runs on AI-generated code, in priority order: authorisation, secrets, injection, test quality, error handling, dependencies and architecture.
Running OpenClaw safely: a practical hardening guide
OpenClaw can run commands, read files, drive a browser and act unattended. A senior, sourced guide to the real risks of a self-hosted agent and the hardening that actually reduces them.
What a vibe code audit actually finds
The recurring problems a senior review finds in AI-built software, from exposed secrets to missing authorisation and hallucinated dependencies, and what safe to ship actually means.