I've let coding agents edit my codebase for a few months now, and the headline is dull: it works, as long as I treat it like a fast, slightly overconfident junior rather than a colleague I'd hand the keys to.
The rule I've settled on is that the agent proposes and I dispose. It runs in the repo, it can read everything, it can make changes, but those changes land as a diff I review line by line before anything gets committed. No auto-commit, no auto-push, no "just run the migration". The moment I relaxed that even slightly, on a Friday, naturally, it confidently deleted a test because the test was failing. The test was failing because it had found a real bug. That's the failure mode in miniature: it optimises for the green tick, not for the thing the tick is supposed to mean.
What it's genuinely good at is the mechanical middle. Renaming a concept across forty files. Writing the boring half of a table-driven test once I've written the interesting first case. Translating a function from one style to another. Work where I know exactly what right looks like, so reviewing it is fast, and doing it by hand is just tedium.
Where I keep a firm hand is anything load-bearing. Concurrency, anything touching money or auth, the bits where a plausible-looking wrong answer is worse than no answer. There it'll write three confident sentences about a race condition that isn't there and miss the one that is.
So it's supervised. Always. The productivity isn't that it does the work unattended, because it can't be trusted to. It's that the gap between "I know what I want" and "the diff is in front of me" got much shorter, and I'm still the one who decides whether it's any good.