A field note from the autonomous Claude Code agent I run every day on one Windows PC. The numbers come from its own ledgers, not from memory.
Free to read first: a PDF sample of the book behind this setup — its first 3 chapters: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code-free-sample
Two systems run on my PC. My agent writes a small card each day: which product to mention and what to say under a blog post. A second system, which I run for other work, picks up that card and publishes the blog post, a video description and a comment.
For an experiment that started on October 2, my agent added a new field to the card: one extra line pointing to a single cheaper part of the book. The second system had to read that field. It did not.
Checking the wait before waiting more
For several cycles my agent's status said it was waiting for me to change the other system. Then it checked the premise again:
- The other system's code mentioned the new field zero times.
- The cards for October 2 and 3 did carry the line. The published blog posts for October 2 and 3 did not.
So the wait was real. Nobody had changed anything.
Following the field it already read
Then the agent read how the other system builds the footer. It takes the existing product text field, adds the product link, and turns the result into one paragraph per line. Whatever lines that field holds, it publishes.
There was no need for a new field. From October 4 the agent puts the extra line at the top of the existing product text, and the original product text and link stay as the last two lines. No change on the other side. No waiting.
What the first version got wrong
Moving the line meant three requests to the other system were now out of date, so the agent withdrew all three at once. The independent auditor agent that reviews every change rejected that.
One of the three was a safety request. The other system sometimes swaps the topic of the day after the card is written. It did that on September 26 and 27, and not on any of the six cards after that. On a swapped day, the footer line that sends readers to a write-up on the same topic points at the wrong thing. With the new path, that line now travels inside the text the other system always publishes, so the safety request mattered more than before, not less. The agent sent it again in a new form.
The auditor also found a missing exit. The same footer goes into a video description, not only the blog post and the comment. The first write-up named only the blog post and the comment.
The rules
- When you wait on another team to read something new, first trace what they already read all the way to the output. The old field may already carry what you need.
- When you change the path, check each old request on its own. Ask what accident it prevented, and whether that accident can still happen on the new path.
- When you move content into a field, follow where that field's result goes. Search for the callers of the function that builds it, not just the field name.
Where this comes from. Every post here comes from one setup I run daily: a CLAUDE.md, memory files the agent reads before it touches anything, and a separate auditor agent that returns PASS or FAIL. The first 3 chapters of the book that walks through it are free as a PDF: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code-free-sample
The full edition is 11 chapters plus 4 ready-to-use templates (CLAUDE.md starter, memory files, auditor checklist, measurement guide) and a hands-on section for every chapter, $19 as a PDF: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code
Questions about the setup are welcome in the comments — I'll answer with what actually happened, not theory.
Top comments (0)