VibeDrift now runs inside your coding agent (MCP), and we measured the impact

Your AI coding agent does not remember what it built yesterday. Every new session starts fresh, with no memory of the conventions your codebase already settled on, so it makes reasonable choices that just are not your choices. One handler throws a typed error and the next returns a plain object. Eight services use a repository layer and the ninth reaches for raw SQL because it was simpler in that moment. Everything compiles, everything passes review, and the codebase slowly stops agreeing with itself. That gap is what we call drift.

Now your agent can check the codebase before it writes

VibeDrift started as a scanner that measures drift after the code ships. The bigger move is that it now runs as an MCP server, which puts the check inside the loop, before a single line is written. Once you add it, your agent can stop in the middle of a task and ask the codebase about itself. It can look up the dominant pattern in that part of the repo, check whether a similar function already exists, and confirm that a change matches the rest of the project, all while it is still deciding what to write.

It plugs into Claude Code, Cursor, or any MCP-compatible agent with one config block:

{
  "mcpServers": {
    "vibedrift": {
      "command": "npx",
      "args": ["-y", "@vibedrift/cli", "mcp"]
    }
  }
}

There is no marketplace to go through and no lock-in. Because it rides an open protocol that any agent already speaks, the convention travels with the repo rather than with a vendor, and the same setup works wherever your agent works.

We measured whether it actually changes the code

It is easy to bolt a tool onto an agent and simply assume it helps, so we tested it honestly. We had the same model write the same new file twice, once on its own and once after VibeDrift handed it the conventions the codebase already follows, and we graded both versions with a separate drift check so the tool could not mark its own homework. Every result carries a 95% confidence interval.

The headline is clear. When the codebase follows a convention the agent would not reach for on its own, and could not see in the files in front of it, giving it VibeDrift's signal cut the drift it introduced by a wide and repeatable margin. The 95% interval was [0.57, 1.11], comfortably clear of zero, so it is a real effect and not noise. In plain terms, it reliably stopped the AI from contradicting the codebase's own house style.

You can watch the mechanism flip on a repo whose house style is .then() chains, the opposite of what a modern model writes by default:

// agent alone: its own default, which is drift in THIS repo
async function getUser(id) {
  const row = await db.query(...)
  return row
}

// agent + VibeDrift's signal ("this repo uses .then() chains")
function getUser(id) {
  return db.query(...).then((rows) => ...)
}

The signal pulled the agent off its own habit and onto the repo's convention, which is the one thing a stateless model cannot do for itself.

Where it helps, and where it does nothing

The other half of the result is what makes the first half trustworthy. When the convention was already the model's default, or was sitting right there in the files it could see, the effect was a clean zero. No inflated wins, and no taking credit for code the model would have gotten right on its own.

One condition lights up, and it is exactly the one that matters: the convention the agent could not have guessed and could not see. The value lands where the pain actually is. On a small or familiar codebase you do not need this. On a large, established one whose conventions do not fit in the agent's context window, it is the difference between matching the house style and quietly drifting from it.

The honest small print: this is a handful of tasks per condition and the convention here is a deliberately clean stand-in, so treat the exact number as directional. The direction is solid and the nulls are tight, which is the part that counts.

Why this matters as AI writes more of the code

As more of the world's code gets written by agents, the limit is no longer how fast we can generate it. The limit is whether all of it stays coherent. A codebase that disagrees with itself is the new form of technical debt, and it piles up faster than any human review process can pay it down. Giving every agent a portable, in-loop way to ask a codebase how it already does things, over an open standard, is a small but real step toward keeping AI-built software coherent at that scale.

Try it in your agent

{
  "mcpServers": {
    "vibedrift": {
      "command": "npx",
      "args": ["-y", "@vibedrift/cli", "mcp"]
    }
  }
}

It works in Claude Code, Cursor, or any MCP client, and the full setup is in the guide. The broader story on moving from detection to prevention is in this companion post. And if you would rather keep using it as a plain scanner, nothing changed there:

npx @vibedrift/cli .

Website · npm

The MCP server is a Pro feature. The local scanner is free, with 3 deep scans a month on the free tier.