After about a year of building a large software platform with CC, one of the biggest lessons I learned was that a good coding agent harness is only half the equation. The codebase architecture matters just as much.
I had spent a lot of time improving agent instructions, workflows, reviews, and testing. The agents were productive, features worked, and progress looked great.
But when I started investigating the codebase as a whole, I found a different story. (And not once did even Fable ever even hint at this being a solution while brainstorming how to make things better)
There were dozens of implementations of things that should have been shared components. Multiple ways to accomplish the same operation. Duplicated systems, inconsistent naming, unclear ownership, and features scattered across whatever files or modules had been convenient at the time.
Individually, the agents had done their jobs. Collectively, they had created a maintenance nightmare.
Local optimization at the expense of global coherence.
The problem compounded. As the architecture became less consistent, agents had a harder time finding the right patterns to follow. They created new implementations, worked around existing systems, and added more complexity.
Better instructions alone didn't solve it. You could give agents all the rules and standards in the world, but if the repository contradicted those rules, the agents often followed the code in front of them or found whatever path made the task work.
What actually needed fixing?
The solution wasn't just improving the agents. It was cleaning up the environment they worked in.
Establish clear domains, boundaries, and ownership so everything had an obvious place to belong.
Consolidate duplicate functionality into shared, canonical implementations.
Standardize how systems communicated instead of allowing every feature to integrate differently.
Untangle dependencies and remove conflicting patterns and obsolete code.
Enforce those boundaries with automated checks, tests, and architectural reviews.
The architecture and the agent harness needed to reinforce each other.
The architecture provided the structure, contracts, and predictable patterns. The harness guided agents to follow them and prevented changes that violated them.
Neither could compensate indefinitely for the absence of the other.
This wasn't a problem unique to AI. Software teams had always accumulated technical debt. But AI agents made it possible to accumulate architectural entropy at unprecedented speed.
The biggest realization for me was that architecture wasn't just a blueprint for building software. It was a control system for maintaining and evolving it.
AI made writing code faster and cheaper. But without architectural discipline, that speed eventually became the very thing that slowed development down.
Has anyone else found that improving their AI coding workflow eventually meant spending more time fixing the structure of the codebase than improving the agents themselves?