How do you keep a whole team's AI coding agents aligned?

alongkorn charoenpruksachat — Thu, 09 Jul 2026 11:41:30 +0000

When one developer uses a coding agent, drift is annoying. When a whole team does, it's chaos: three people's agents each reconstruct "the plan" differently, build in parallel, and collide. The usual fix — more meetings, a frozen design doc — kills the speed that made agents worth using. The durable fix is a shared design source-of-truth that every agent reads and writes back to, so the plan is one living thing instead of N private guesses.

What "one living plan" actually needs

One structured spec. Systems (Goal / Boundary / Acceptance) + milestones that any agent, on any team member's machine, reads the same way over MCP.
Non-destructive proposals. Agents don't edit the shared design directly; they propose changes into an Inbox the owner adopts. No silent overwrites, no merge wars.
Loop-back from real code. Each system maps to the files that implement it, so the team sees what was actually built vs designed — the doc can't rot.
Ask over the real design. "What's the blast radius if I change the economy system?" answered from your actual systems, so parallel work doesn't blindside anyone.

Waterfall made agile

Classic waterfall failed because the plan was dead on arrival — written once, never updated, ignored by the people building. A living plan keeps the one thing waterfall got right (shared, explicit intent) while staying editable by everyone and every agent, continuously. That's the difference between a team reacting to whatever the agent shipped and a team steering it.

I'm building Forge for exactly this: an agent-readable design layer for AI-native teams. Agents connect over MCP, read the shared design, and propose changes back — so the team stays aligned and parallel instead of colliding. Open free beta — feedback very welcome.

Why does my AI coding agent keep building the wrong thing?

alongkorn charoenpruksachat — Thu, 09 Jul 2026 11:39:50 +0000

Short answer: your agent isn't guessing badly — it's guessing at all. The plan it needs lives in your head and in scattered notes no agent ever reads, so on every task it reconstructs your intent from the code plus your last prompt. Small misreads compound into confidently-built wrong things. This is agent drift, and it gets worse as the codebase and the team grow.

Three things that cause agent drift

The spec isn't machine-readable. A Notion page or a README is prose; an agent can't reliably extract "this system must not touch billing" from a paragraph. It needs boundaries and acceptance criteria as structure, not vibes.
The plan goes stale the moment code starts. You designed it, the agent built something slightly different, nobody updated the doc — so the next session builds on a fiction.
Nothing flows back. When the agent discovers a needed change mid-build, it just does it. Your design and your code silently diverge, and you find out later.

The fix: a design source-of-truth the agent reads before it builds

Give the agent structured intent it can build against. Describe each part of your project as a System with a Goal, a Boundary (what it must not do), and Acceptance criteria — plus ordered milestones — and expose that to the agent over MCP. Now the agent builds against intent, not a guess.

Two properties matter as much as the structure itself:

Propose, don't overwrite. When the agent discovers a change, it proposes it back for you to approve — your design is never silently rewritten.
Loop back to real code. Each system maps to the files that implement it, so you can see what was actually built vs what was designed. The doc can't quietly rot.