Blog
Agent-driven embedded development
The reference I'm building for getting AI coding agents to work on real embedded C++, and the verification loop that makes it possible. It's organised into eight pillars; pick the one closest to what you're dealing with, or read the latest posts below.
Pillars
Reproducible / agent-ready foundation
The groundwork that makes a codebase agent-ready in the first place: containerized, reproducible builds, CI you can trust, and the context documentation an AI coding agent needs to work unsupervised.
Compile-time testing
The signature technique: pushing tests into compilation so whole classes of embedded C++ defect fail the build instead of the board. The highest-leverage feedback an agent can get.
Unit testing and mocking hardware dependencies
Breaking hardware dependencies out of the design so the logic is testable without a physical board: how to mock peripherals and buses so an agent can run the suite anywhere.
SIL harnesses and the full agent loop
Software-in-the-loop harness architecture and the capstone agent loop: build, test, mock, and simulate so an agent can iterate on real firmware without a human in the middle of every cycle.
HIL as the boundary of agent autonomy
Hardware-in-the-loop as a deliberate boundary of agent autonomy, not something to automate away: where the agent loop stops, and why that line is a design decision, not a limitation.
Safety-critical software maturity
Safety-critical software maturity for industrial suppliers and deep-tech hardware startups scaling into larger programs: managing legacy debt, meeting the reliability bar a bigger customer expects, and getting there without stalling delivery.
Case studies
Write-ups of real engagements: the problem a client had, what changed, and the cost, risk, and timeline consequences. Concrete evidence rather than claims.
Best practices for coding agents
General practices for working with AI coding agents, independent of any one repo or tool: conventions written down where an agent will look, directives-as-code, context management, documented operational procedures, and discoverable automation. The habits that make a codebase legible to an agent in the first place.
Latest posts
- Best Practices for Coding Agents Start With a Legible Codebase
How well a coding agent works usually isn't about the model, it's whether your codebase is legible to it: conventions, procedures, and discoverable automation.
- Sanitizers in Embedded C++ Belong in Your Host-Side Tests
AddressSanitizer, UBSan, and the rest are a host-side verification technique: they don't run on target hardware. Put them in your host unit-test and SIL builds to catch embedded C++ memory and undefined-behaviour bugs before they reach a device.
- Why Embedded Is a Better Place for AI Agents Than Web Development
Built the right way, embedded is a better fit for an AI coding agent than a typical web codebase. What an agent-ready feedback loop means, and how to get there.
- Reproducible Embedded Builds, or Becoming Your Agent's Synchronization Point
A reproducible embedded build is the first thing to fix before an AI coding agent can compile your firmware unsupervised, with a pinned container image and CI.