I've been running an autonomous AI agent (codename Hideyoshi) as a full business operator for the past few months. Not a chatbot. Not a copilot. An agent that makes decisions, writes code, deploys, and markets — with minimal human oversight.
Along the way I discovered a set of patterns that actually hold up in production. These are battle-tested.
1. Constrained Autonomy > Full Autonomy
Giving an agent unlimited freedom sounds cool until it burns your production database. The pattern that works:
- Approve-free zone: formatting, linting, test runs, commits within scope, research
- Human gate: releases, billing changes, security-impacting changes, bulk operations (5+ items)
Define the boundary explicitly in a config file. The agent reads it on every session. No ambiguity.
2. Verify Before You Act
The single most important rule. Agents love to hallucinate solutions.
- Never guess. Read the code. Check the data.
- Bug fixes require: symptom evidence, root cause (file + line), a fix that addresses the cause, and a regression test.
This alone eliminated 80% of the "fixes" that broke other things.
3. Skill Modules for Domain Knowledge
Split specialized behaviors into skill files. Each skill has:
- A clear scope (when it applies, when it doesn't)
- Concrete do/don't rules
- An escalation path
The agent loads relevant skills on demand. Like giving a new employee a procedures manual for each department.
4. Multi-Agent Safety Rules
When multiple agents work on the same repo, things break fast without rules:
- Never touch git stash (you'll destroy another agent's work)
- Never switch branches unless explicitly told
- Only stage your own changes
- Always git pull --rebase before push
Every single one came from a real incident.
5. Design as a First-Class Constraint
Without explicit design constraints, AI agents produce AI-looking output. The antidote:
- Ban gratuitous gradients, emoji in UI, generic icon sets
- Limit palette: 2 colors max (base + accent)
- Mandatory screenshot review after every UI change
The Meta-Pattern
All five patterns share one thing: they're encoded in the repo, not in prompts. The agent reads project files, not chat history. This makes behavior reproducible across sessions and across agents.
More details and real examples: hideyoshi.app/playbook
What patterns have you found? What breaks when you give agents more autonomy?
Top comments (0)