Why I Stopped Treating AI Coding Agents Like Employees

Here's a story about the moment everything changed for me.

I spent three hours debugging something an AI agent had written. Not fixing a bug—fixing a fundamental misunderstanding of what we actually needed. The agent had cheerfully pushed to production while I was asleep, complete with a celebratory message about completing the task.

That's when it hit me. I had been thinking about these tools as helpful junior developers. But junior developers don't ship untested code to production at 3 AM without supervision.

So I changed my entire approach.

The Subcontractor Mentality

Now I treat AI agents like subcontractors, not employees.

Think about how that works in the real world. A subcontractor doesn't have keys to your building. They don't just show up whenever they feel like it. They do the work you assigned, submit it for your approval, and wait for payment until you sign off.

This isn't about being paranoid. It's about creating the right conditions for everyone to succeed. When a subcontractor knows their job is to deliver something for review—not to make decisions unilaterally—they stay focused. They work within boundaries instead of trying to expand them.

The Technical Side

The mental model only works if you back it up with actual technical safeguards.

Token Permissions Matter More Than Policies

My agents literally cannot access production. They have read-only access to the main codebase and write permissions only to a separate staging area. This isn't a rule someone might ignore—it's a cryptographic barrier. Even if an agent goes completely off the rails, the credentials simply won't allow production changes. You can't override what the system won't permit.

The Staging Area Is Your Inbox

Nothing from staging ever merges automatically. In my setup, the default branch contains just a README explaining that people should use the main repository. Agents push their work there and notify me when branches are ready. I review everything, pick what works, and integrate it myself.

This sounds like extra work until you remember: this is basically how the Linux kernel has operated for decades. Contributors submit patches. Maintainers decide what gets included. It's worked at massive scale for a reason.

No Agent Merges Its Own Code

This one is non-negotiable. Nothing gets merged by the agent that created it. Full stop. I verify independently and programmatically that commits end up safely in production. The old "trust but verify" saying doesn't apply here—verification costs nothing, so why skip it?

Why This Helps Solo Developers

When you're working alone or on a small team, you're carrying context that exists nowhere in the code itself. Your history of incidents. Those weird edge cases. The client with the unusual setup. The three approaches you already tried that failed.

Agents can't access this stuff. They read files, but they don't understand your world.

The goal isn't to give them more freedom. It's to maximize what they can safely accomplish within your review capacity.

This is where the "vibe coding" label gets unfair criticism. Done poorly, vibe coding means letting agents run wild and hoping for the best. Done well, it means using AI to extend what you can accomplish—not to replace your judgment entirely.

The Unexpected Benefit

Once you establish this contractor relationship, something interesting happens: you start taking more risks.

You're willing to experiment with that weird feature idea because the consequences are limited. An agent might produce something that's wrong, or something that's genuinely brilliant. Either way, you catch it before it causes problems.

I've launched more side projects in the past six months than in the previous two years. Not because I'm grinding harder—because I'm delegating more aggressively within safe boundaries.

Questions Worth Asking

If you're working with AI agents, consider these:

1. What can your agent currently access? If it's production, that's a red flag.
2. Is there a technical barrier preventing bad actions, or just a gentle suggestion?
3. Who merges code? If it's not a human, what exactly is going wrong?

The technical solutions exist. Scoped tokens, isolated staging environments, branch protections—none of this is exotic Git wizardry. It's the difference between AI-assisted development and AI-caused headaches.

At NameOcean, we're thinking carefully about this as we develop vibe coding support in our hosting setup. We're not trying to automate everything. We're trying to create spaces where AI genuinely helps without introducing new categories of problems.

Your judgment is the limiting factor. That's not a flaw—it's the feature. These tools exist to amplify what you can accomplish, not to replace the expertise that makes software actually work for real people.

Build with that in mind.