

Who reviews the agents?
How I work with AI agents at home: real freedom to build and ship, in an environment made safe by hooks, rules, skills, reviewers and pipelines.
None of this will be news to people who work with AI agents every day. Most of them know exactly where we are: the time when AI was a clever autocomplete in your editor is over, and so is copying an answer out of a chat window and pasting it into a file. Agents now read the code, change it, run the tests, open the pull request, watch CI and fix what broke. Not only for application code: for infrastructure too, Kubernetes manifests, CI pipelines, alerts, dashboards.
This isn’t a discovery, and I’m not an oracle. It’s my point of view, and how I’ve set things up at home, on the small cluster that runs this blog and a few apps of mine.
The idea I keep coming back to: once agents can do the work, the model is rarely what slows you down. Your environment is. If every change waits for a human to run the tests, click through staging and approve a deploy, an agent that works in minutes spends most of its time waiting for you. So I give agents real freedom to create, and put my effort into making the environment safe, instead of reviewing every line by hand.
Give them the keys#
The agents I work with have access to my cluster. They can read its state, look at logs and metrics, run a test in a throwaway namespace, open pull requests, follow CI, and check that a release actually landed. They don’t ask me before every command.
The keys open a lot, but not everything. Outside their sandbox namespaces
the cluster is read-only for agents: any other change goes through git, or
I run it. Their GitHub token is being swapped for a narrow one, with no
admin rights over the repositories. They never push to main and never merge:
every change, application code included, is a pull request that I merge.
And every command an agent runs is logged with what the hook decided about
it, so there’s an audit trail of what happened and why.
That sounds reckless until you look at what surrounds it. Freedom works when the dangerous moves are impossible, the normal moves are written down, and every change goes through the same automated path to production. Three things make that true: rules, hooks and skills.
Rules, hooks and skills#
Rules are a short file every agent reads before it starts: how I like
to work, what never to do, where things are. Never touch production data.
Never print a secret. Destructive steps only after a check that passed.
Never push to main and never merge: that’s mine. One rules file for every project and every
agent, kept in git, so a lesson learned in one session reaches the next
one.
Rules are good intentions. Hooks are guarantees. A hook is a small script that runs before every command the agent executes (and, for commits, before every commit, whoever writes it) and blocks it outright if it matches something I’ve decided is never acceptable. Each one exists because something went wrong, or nearly did:
| The hook blocks | The story behind it |
|---|---|
| any command that reaches a production database | real data lives there; staging has made-up data for experiments |
| any request to the blog’s live statistics | an agent once “tested” a cache by visiting the live site, and counted itself as a reader |
| deleting production logs | the history is what you need on the worst day: only I delete it |
a delete chained after a ; | a cleanup once ran even though the check before it had failed; deletes only run after a check that passed (&&) |
pkill -f / killall | a “kill everything that matches” once matched the agent’s own shell, and it killed itself mid-task |
| “Fixes #12” in a commit message, next to a pull request reference | merging once closed an unrelated pull request in another repository |
a push to main, or a merge | application changes used to go straight to main; now every change is a pull request, and merging is mine |
| a change to the cluster outside the sandbox namespaces | agents read the cluster; changing it goes through git, or through me |
While building the feature I describe below, the hook stopped the agent half a dozen times. Each time it read the reason, rewrote the command the safe way and carried on. Nobody had to watch.
One honest limit: the hook reads the text of a command. That stops mistakes, which is what I need it for, but it wouldn’t stop something determined to get round it. The next step moves the rules into things that enforce them: agents get their own user and a cluster account that can only read outside the sandbox, and the hooks become files they can’t touch.
Skills are written procedures the agent loads when a task needs them, so it doesn’t re-derive them every time, and does them the same way every time. I use quite a few; these are the ones that matter for shipping safely and fast:
| Skill | What it’s for |
|---|---|
code-change | every code change: tests, three independent reviews, tests again |
infra-pr | every infrastructure change: manifest checks, a live diff by risk, three reviews, a throwaway test |
throwaway-test | testing new behaviour in a temporary namespace, never against real data |
ci-watch | following a CI run to the end, and reading why it failed |
saas-app | bringing a new app onto the cluster with the whole pipeline |
retro | at the end of a long session: what we learned that isn’t written down yet |
Others cover the rest of the work: mockups before a design change, screenshots of an app with made-up data, explanations kept short, the cluster’s day-to-day operations, releasing this site. A new procedure that an agent had to work out twice becomes a skill.
Three reviewers who’ve never met#
Speed is worthless if quality drops. So every change, however small, follows the same loop:
- The agent writes the change and its tests, then runs them. Every package or file it touches needs at least 85% coverage.
- Three reviewers read the change, in parallel and independently: none sees another’s report, and none sees the author’s reasoning, only the code. One checks correctness: bugs, edge cases, error handling, tests that would pass even if the code were wrong. One challenges complexity: less code, fewer moving parts, reuse of what exists, the same behaviour. The third looks only at security: secrets, injection, authentication, data that leaks, what becomes reachable from outside, permissions, and what the change pulls in from elsewhere.
- The agent acts on every finding: fixes it, or writes down why not.
- The tests run again. If the logic changed, the correctness and security reviewers look again. Round and round until it’s clean.
Then the agent tells me what it decided and why: which findings it fixed, which it rejected and for what reason. I read that table instead of the diff. When the tests, the coverage and the pipeline are green, I don’t need to read every line, and honestly, I’d be worse at catching the problems than a reviewer whose only job is to find them.
Not my idea#
None of this is my invention. Anthropic, who make the agent I use most, publish their own advice on working with coding agents, in Best practices for Claude Code ↗ and Building effective agents ↗. Much of what I’ve described is in there: a short instructions file the agent reads every session, hooks for what must happen with no exceptions, a check the agent can run itself, a reviewer in a fresh context that sees only the change, narrow permissions, and testing in a sandbox. I’ve just written it down for my own setup and wired it together.
Automate the whole path to production#
Agents are fast. If the road from a pull request to production has manual steps, that’s where everything queues. So every app I run, and the infrastructure itself, has a fully automated pipeline, and it runs on my own hardware, on a CI runner in the same cupboard as the cluster:
- On every pull request: unit tests, integration tests against real databases, the whole stack started and smoke-tested, images built, every new commit scanned for leaked secrets, and the images and dependencies for known security holes. Renovate and vulnerability alerts for the app repositories come next.
- On merge: the images are published and staging updates itself. Staging runs on made-up data.
- On staging, automatically: database migrations, a smoke test that logs in and walks the app, and browser checks: Chromium opens every page of this blog at phone and laptop widths, in light and dark mode, and fails on a sideways scroll, a broken image, a console error or a request to another domain.
- Only if staging passed, a production pull request opens by itself.
- In production, one of my apps releases through a canary: a share of traffic first, its error rate and latency compared with the running version, and an automatic rollback if they’re worse.
- Metrics, logs and traces for everything, and alerts that only fire when someone has to act.
Everything is safe, and everything is automated. The steps that still wait for a human are pressing “merge”: on the change itself, and on the production pull request. That doesn’t slow things down much: by the time I look, the tests, the reviews and staging have already done the work, and merging takes a minute.
Let me be honest about the scale, though. These are home projects with a handful of users. A canary that compares error rates needs real traffic to tell anything apart; with a few visitors a day it mostly sees silence, and progressive rollouts and similar release techniques add little that a plain deploy wouldn’t. They earn their keep in a real production environment with real volume. At home, the point is different: to practise the real thing, simulate it as closely as I can, and have fun doing it.
Rollback is just another pull request#
Automation makes going back as cheap as going forward. A release is a version number in a file in git. A rollback is a pull request that puts the previous number back, and the same pipeline deploys it. No agent needed, no special procedure, no panic at eleven at night. And where there’s a canary, a bad release is meant to roll itself back before most users ever see it.
When undoing a change is that cheap, letting agents ship quickly stops being scary.
Where I still sit#
I decide what gets built and why, and I set the bar. Agents propose, and sometimes I say no. This week the agent built a gate for this blog’s releases in a way that labelled a failed release instead of preventing it, and I asked for it the way my other apps do it: no production pull request at all until staging has passed. That’s the kind of decision I want to make. Reading every line of a Playwright script isn’t.
I promote to production about every three days. That’s a choice, not a limit: the pipeline would happily do it every day, and it’s my plan to automate that last step too, once I trust the signals enough. Your release rhythm is a promise to your users, the same way an SLO is. Pick it on purpose, then make the pipeline keep it.
A week of it#
Here’s what that looked like this week. I noticed this blog’s home page was cut off on my phone. The agent found the cause (a row of tags that didn’t wrap), fixed it, and when I asked why nothing had caught it, we built the browser checks above. From there:
- It wrote the checker and its tests, and proved the checker would have caught the bug by running it against the previous day’s release.
- The correctness reviewer found that an image which never finished loading would hang the check forever, and that GitHub’s free plan doesn’t support the draft pull requests the first design relied on.
- The simplicity reviewer cut options nobody used and a second copy of the browser setup in CI.
- The hook blocked half a dozen unsafe commands on the way, and the agent rewrote each one.
I spent my time on two decisions and a few answers. The agent spent its time on everything else, and the result is safer than what I’d have written by hand.
Engineers still design it#
Before agents, I wrote the code myself: whole microservice architectures, thousands of lines of Go and Python, and code reviews for production-grade products. I don’t think that experience is less useful now. I think it’s what makes all of this work.
Agents execute well. They don’t decide, on their own, what the system should look like. To set this up I had to know what a canary is and when it’s worth it in production, how it differs from an A/B test or a blue-green deploy, what a metrics server does, how a CI/CD pipeline works in detail, where a gate belongs and why. Without that, I couldn’t have explained to an agent how this has to work, or noticed when its first design was reasonable but wrong for my case.
Agents have come a long way in a year, and they’ll need less and less specification, infrastructure included. But I’m fairly sure that five years from now we’ll still need engineers who understand the design and the best practices, because many of these are choices, not facts. They make sense for one use case and not another, and the use case is decided by the people building the product. When infrastructure is the product, the pipelines are what you’re selling your customers. That’s exactly where I want engineers designing every part of it, and agents executing it.
The ones who stay in the way#
I think this is where software is going, whether we like it or not. Agents will do most of the typing, the testing, the reviewing and the releasing. The engineers and teams who do well will be the ones who build environments where agents can move fast safely: rules written down, hooks that make the worst mistakes impossible, procedures captured as skills, pipelines with no manual steps, rollbacks that cost nothing.
The ones who insist on reviewing every line by hand, and keep the path to production manual because that’s how it’s always been done, aren’t being careful. They’re the bottleneck, and they’ll be left behind.
I spend my day chatting to agents now. I’m still debating whether I like it or not, but in the meantime: should I call myself a 10x engineer? :P