You ran three Claude Code agents in parallel. Each one finished. Each branch compiled. Git says there are no conflicts.
You merge. Something breaks in prod. No error during the merge. No CI failure. Just a mismatch that compiles fine and explodes at runtime.
That's agentic drift and it's becoming one of the most common failure modes in AI-assisted development.
What agentic drift actually is
Agentic drift isn't a git conflict. It's what happens when two agents independently solve the same problem in incompatible ways — without either of them knowing the other exists. Here's the exact scenario I hit that made me build Switchman:
I had three Claude Code sessions running in parallel worktrees:
Agent 1 was building JWT middleware. It wrote req.user.id to identify the current user.
Agent 2 was building the user schema. It exported a userId field — not id.
Agent 3 was writing auth tests. It passed both.
No merge conflict. Both branches touched different files. Git was happy. The tests were mocking things in ways that made both implementations look correct in isolation.
The middleware expected req.user.id. The schema had userId. They never met until they hit prod.
That's the core of agentic drift: correctness in isolation, incompatibility in combination.
Why it's getting worse
A year ago most developers ran one AI agent at a time, mostly as a suggestion engine in a sidebar. You reviewed everything manually before it touched your codebase. Now the workflow has changed. You spin up three Claude Code sessions, give each one a task, let them run, and come back when they're done. You're the manager, not the implementer. The speed gain is real. But the review process hasn't kept up. When you ran one agent, you reviewed one branch. When you run three agents in parallel, you need to understand how all three relate to each other — not just whether each one is individually correct. Git diff can tell you what changed. It can't tell you whether the changes are coherent.
The four types of drift
Not all agentic drift looks the same. Here's what to watch for:
Interface drift — Two agents implement the same interface differently. One writes a function that returns { id, email }. Another writes a function that expects { userId, emailAddress }. Both compile. They collide at runtime.
Semantic drift — Two agents solve the same problem with different logic. One writes an auth check using JWT expiry. Another writes one using session tokens. Both work in isolation. Together they create two conflicting auth paths that confuse downstream code.
Ownership drift — Two agents edit the same file without knowing about each other. Git might not even flag it as a conflict if they touched different lines. But the combined result is incoherent.
Scope drift — One agent makes changes that silently invalidate work another agent already did. No error. No warning. Just stale assumptions baked into committed code.
Why git can't catch it
Git is a line-by-line change tracker. It knows nothing about semantics, interfaces, or intent. A merge conflict happens when two branches touch the same line. Agentic drift happens when two branches touch different files that need to agree with each other. src/middleware/auth.ts and src/db/schema.ts are different files. They'll merge cleanly. Git has no way to know that req.user.id in one depends on userId in the other. This is the gap. And it's a gap that's grown significantly as parallel agent workflows become mainstream.
How to catch it before you merge
The fix is a semantic review across all your worktrees before you merge — not a git diff, but a check that understands what each agent actually built and whether those things fit together.
That's what I built Switchman to do.
After your agents finish, run:
bashswitchman review --pr-ready --all-worktrees
It scans every worktree, produces a plain-English summary of what each agent built, flags semantic conflicts and interface mismatches, and gives you a single confidence verdict:
🟢 GREEN - Safe to merge.
🟡 AMBER - Review before merging. Interface mismatch on auth middleware.
🔴 RED - Do not merge.
If you use Claude Code specifically, you can install a Stop hook that runs this automatically every time a session ends:
bashswitchman claude hooks install
After that, every Claude Code session ends with a silent confidence check. You only hear about it when something's wrong.
The bigger picture
Agentic drift is a symptom of a broader transition in how software gets built. We've moved from AI as a suggestion engine to AI as an autonomous implementer. That's genuinely powerful — but it requires different safety practices.
When a human developer works in isolation on a feature branch, they carry context about the rest of the codebase in their head. They know that userId is the field name because they wrote it last week.
An AI agent has no such context unless you give it one explicitly. It will build something coherent in isolation and have no idea it conflicts with what another agent built an hour ago.
The tools and practices around parallel agent development are still catching up to the workflows. Agentic drift is one of the first failure modes we need to solve — because it's invisible, it's common, and it's only going to get more frequent as parallel agent sessions become the default way to ship software.
Switchman is an open source CLI tool that gives you merge confidence after parallel AI coding sessions. MIT licensed, no setup required.
npm install -g switchman-dev
Top comments (0)