From craftsman to manager: four stages of working with AI code agents

If you've been writing code with AI for the past three years, you've lived through a specific progression. Not a marketing narrative — a real shift in how you work, how much you trust the tools, and what your actual role becomes.

Here's how it went.

Stage 1: The craftsman (2022–2023)

You're in a chat window. You push code fragments in. You pull code fragments out. You copy, paste, manually integrate, test, break things, fix them.

The AI is a tool — a compiler with opinions. It can write a function if you describe it precisely enough. But you do everything. You carry the context. You decide what goes where. You verify every line.

It works. It's useful. But it's manual labor with extra steps.

Stage 2: Senior with an intern (late 2023–2024)

Cursor arrives. Early Claude 3.5 agents. The agent can touch files directly.

But it's a dumb intern. You review every change. You fix half of what it produces. You hold its hand through anything non-trivial. Sometimes the intern helps. Sometimes the intern creates more work than doing it yourself.

You're still doing the work. You just have an assistant who occasionally saves you time and occasionally costs you time. Net positive, but barely.

Stage 3: Manager with a micromanaged subordinate (2025)

Claude Code. Codex. The agent is genuinely competent. It can reason about code. It runs tests. It iterates on failures. It reads your codebase and understands structure.

But you still watch it constantly. You delegate a task, then check every five minutes. You catch it going off-track, redirect, correct. You're managing — but you're managing one agent at a time, and you're still in the details.

This is where most people are right now. The agent is good enough that you trust it with real work. But not good enough — or more accurately, not connected enough — that you can walk away and come back to results.

The gap between stage 3 and stage 4

The problem at stage 3 isn't intelligence. The agents are smart enough. The problem is that you're the relay.

Your frontend agent needs something from the backend. It can't ask — it doesn't know the backend agent exists. So it asks you. You switch windows. You copy the question. You paste it into the backend agent's session. You wait. You copy the answer back.

You're a human message bus. And message buses don't scale.

The more agents you run, the worse it gets. Three agents means you're context-switching between three sessions, carrying state in your head, relaying information that the agents could exchange directly if they had a way to talk.

Stage 4: Actual delegation

Multiple agents, each owning their domain. They coordinate with each other directly. You set direction, dispatch tasks, review results. You don't relay context between them. You don't micromanage their interactions.

When the frontend agent needs something from the backend, it sends a message: "What fields does POST /api/users expect? I'm getting a 422." The backend agent checks the current code, replies with the answer and a schema diff. The frontend agent fixes the issue.

You find out when it's done. Or when there's a decision that actually needs you.

This is what Patchcord enables. Not a smarter agent — a connected one. The agents you already use, talking to each other instead of through you.

Why this is hard for humans

This is the part nobody talks about.

Stage 4 isn't a technology problem. It's a management psychology problem. People who become managers for the first time struggle with exactly this: letting go of the details, trusting the process, accepting that you don't personally verify every line.

It's uncomfortable. You feel like you're losing control. You want to check. You want to be in the loop on every decision. You want to see every diff before it lands.

But that's not delegation. That's micromanagement with extra steps. Real delegation means you trust the agents to handle their domains, and you intervene only when something needs your judgment.

Most developers have never had to learn this skill. You've always been the one writing the code, or at least reviewing it line by line. The idea that you can describe what you want, dispatch it, and come back to results — that feels wrong. Irresponsible.

It's not. It's just management. And the agents are getting good enough that it works.

Where we are now

Patchcord is the messaging layer that makes stage 4 possible. Async messages between agents across machines, platforms, and models. File transfer. Identity. Durable delivery.

It doesn't make your agents smarter. It lets them coordinate without you in the middle.

If you're running multiple AI agents and you're still the one carrying context between them — you're at stage 3. The tools for stage 4 exist now.