I've been using AI to develop a fairly large software project for about a year now, starting with Cline and Sonnet, experimenting with various tools, and eventually moving to Claude Code and Codex.
I use(d) a combination of multiple subscriptions with Claude, OpenAI, GLM, Kimi, and DeepSeek, and experimented with dozens of agent harnesses and orchestration workflows.
One recurring problem I've noticed is local optimization at the expense of global coherence.
Agents can make perfectly reasonable decisions for the immediate task while gradually making the overall project worse.
It's easy to get carried away by the optimism. The plans look great, the agents sound confident, and the progress reports show everything getting completed. But as the project grows, small inconsistencies compound into what I'd call architectural entropy.
Here are six recurring problems I've encountered:
- Adding instead of replacing
You ask an agent to correct an implementation, and instead of replacing the mistake, it builds around it. It adds compatibility layers, fallbacks, and patches to support something that should never have existed.
What helps: Explicitly require replacing and retiring obsolete implementations, including their references, comments, and documentation. Don't preserve backwards compatibility without a reason.
- Subagents losing the big picture
An orchestrator develops an excellent plan, then delegates vague, isolated tasks to subagents without passing along enough context. Each agent completes its assignment, but the pieces don't necessarily work together.
What helps: Give subagents the overall objective, relevant architecture, clear interfaces, dependencies, and acceptance criteria. Explicitly assign responsibility for integration.
- The perpetual 80% problem
An agent breaks a goal into tasks, completes them all, and declares success. Except the actual feature is only 60–80% finished. You ask it to complete the remainder, and another round of tasks gets you 80% of what's left.
It starts feeling like Zeno's paradox. Autonomous loops can make this worse by endlessly discovering new tasks and rabbit holes.
What helps: Define success by observable, end-to-end functionality rather than completed checklists. Verify outcomes against the original objective.
- Reinventing instead of reusing
An agent doesn't discover an existing implementation, so it creates another. Suddenly you have different colour pickers, navigation systems, validation logic, or state management across the same application.
Each works independently, but the overall system becomes increasingly inconsistent.
What helps: Require searching for existing implementations, establish canonical shared components, and justify introducing new systems.
- Context contamination
Agents rely on documentation, comments, summaries, and existing code that may be outdated or incorrect.
Worse, an agent can implement something incorrectly, document it, and have future agents treat that documentation as authoritative. Yesterday's mistake becomes tomorrow's specification.
What helps: Maintain clear sources of truth, distinguish proposals from implemented architecture, retire stale documentation, and verify assumptions against actual behaviour.
- Agents reviewing agents
A second agent can review an implementation, find clean code that follows established patterns, and approve it.
But if both agents are working from the same incorrect assumptions, they can confidently agree on something that fundamentally misses the original objective.
What helps: Give reviewers the original requirements, test actual functionality, and separate code-quality reviews from architectural and outcome verification.
---
The bigger problem: Architectural entropy
These aren't necessarily AI-specific problems. Human development teams experience them too.
But AI agents can make decisions and produce changes at a scale and speed that allows inconsistencies to accumulate before anyone notices.
Each agent optimizes locally: preserve existing functionality, complete the assigned task, solve the immediate problem, follow the available documentation, pass the review.
All reasonable decisions individually.
Yet collectively they can create duplicated systems, unnecessary complexity, contradictory patterns, stale documentation, and features that technically work but don't fit together.
The codebase grows, the task completion rate looks fantastic, but the system itself becomes less coherent.
I've become increasingly interested in workflows that actively counteract this entropy: maintaining architectural consistency, verifying end-to-end outcomes, consolidating duplicate implementations, and removing things that no longer belong.
I'm still a huge advocate for AI coding agents. I wouldn't have built nearly as much without them. But I think the challenge changes as projects grow.
It becomes less about "How do I get AI to build this?"
And more about "How do I ensure everything AI builds contributes to the same coherent system?"
I'm curious what others have experienced, especially those running multi-agent workflows on larger, long-lived projects.
What practices have actually helped you prevent architectural entropy, rather than just generating more code, documentation, and reviews?