For two weeks I handed as much of my daily solo-dev work as I could to Antigravity agents. It turned out not to be the simple story of "delegate everything and life gets easier." The tasks that lifted a weight off my shoulders and the ones I quietly pulled back separated more sharply than I expected. This is a record of where that line fell, with the operational log alongside it.
What set it off was the v2.2.1 change. Refreshed OAuth tokens now save to the OS keyring automatically, and the number of times work stalled on an auth prompt dropped noticeably. Long automated runs used to break mid-way to ask me to re-authenticate; over these two weeks, that interruption almost never happened. With "runs to completion without stalling" finally in place, I could think calmly about what to delegate in the first place.
What I was glad to delegate
Here are the tasks that worked out. What they shared was two things: failures were reversible, and results could be verified mechanically.
| Task | Result of delegating |
|---|---|
| Routine refactors | Renaming and function extraction produced readable diffs I could accept with confidence |
| Adding tests | Good for mass-producing regression tests against existing code and filling gaps |
| Extracting localized strings | The plain work of moving hardcoded text into resources was safe to hand off |
Every one of these turns a test red when it is wrong, or shows the problem at a glance in the diff. The time I saved was plainly larger than the time I spent reviewing, and by the second week I had let go of this category almost entirely. Because auth no longer interrupted, I settled into a rhythm of queuing regression-test work before bed and checking only the diff in the morning. Work that would once have stalled at midnight was simply a result waiting for me at dawn — more comfortable than I had imagined.
What I should have kept by hand
On the other side were tasks I delegated and then pulled back. The boundary was whether the cost of undoing was high.
Billing configuration is the clearest case. As an indie developer at Dolice, I ship apps on both the App Store and Google Play, and pricing or subscription structure hits real revenue and existing users directly when it goes wrong. Even when the agent's proposal was reasonable, I decided the final application should happen by my own hand. Store submission is the same: the last push to review belongs to a person. Operations like breaking schema changes, where reversal costs dearly, I also kept to myself.
The moment an agent is confidently wrong
The other lesson was that an agent's confidence and its correctness are separate things. One day I delegated a dependency update, and it raised a package to a version with breaking changes without hesitation — explaining itself with complete poise. My tests caught it, so no harm done, but in a thinly tested area I might have merged it as-is. Since then I decide the scope of delegation by whether something can be verified, not by how confident the agent sounds.
Designing how you delegate
How I delegated mattered as much as whether I delegated. I now state the scope narrowly at the top of an instruction and name the areas I do not want touched. Narrowing the scope cuts down accidents where the agent reaches too far and produces unexpected diffs. Reviewing in small, feature-sized chunks rather than all at once also left fewer things slipping past me. Precisely because it can now run unattended for long stretches, the small effort of fencing the work before it starts is what turns into peace of mind.
Where I draw the line
The rule I settled on after two weeks was almost anticlimactically simple. If the cost of undoing is low and the result can be verified mechanically, delegate it. If the cost of undoing is high, or verification leans on human eyes, keep it by hand. Drawing that single line removed nearly all the hesitation over whether to hand something off.
Keyring auto-save, by keeping unattended runs from breaking, genuinely widened what I could delegate. But precisely because the range widened, the need to decide for myself how far to hand things over grew too. If you are also experimenting with delegating to agents, start by re-sorting the tasks in front of you along one axis: the cost of undoing. Thank you for reading to the end.