The engineer who couldn't keep up with agent rules

The night before a scheduled kickoff with one of our beta customers, their data infrastructure lead was maintaining a script. Not a product. A script that updated lists of repositories in markdown files, tracking which CLAUDE.md files existed where, which teams had customized their agent rules, and which of those had drifted from the org-wide standards updated three weeks prior.

He understood the problem clearly. He just had no good way to solve it at scale.

Managing agent rules manually looks tractable until the repository count crosses a certain threshold. Deciding which rules apply at the org level, which get overridden by teams, and which are scoped to individual repositories is work that a script and careful attention might handle at dozens of repos. At hundreds, you can no longer track consistency, enforce inheritance, or audit what changed and when through hand-edited files.

What “thousands of repositories” actually means

This company is a B2B SaaS platform. Thousands of engineers. Thousands of repositories in their engineering catalog.

At that scale, agent rules management is not a configuration task. It is an infrastructure problem. Org-level rules need to propagate consistently. Team-level overrides need to be scoped without undoing standards set above them. Repository-level customizations need to be visible and auditable.

When the system holding all of this together is a personal script and a set of markdown files, the failure modes are predictable. Rules drift. Overrides get applied inconsistently. The org standard gets updated and there is no way to know which of the thousand downstream files still reflect the old version. The data infra lead was not failing to do his job. He was doing his job with tools that were never designed for this problem.

The migration that looks simple and is not

The team is actively adopting Claude Code internally. That means migrating from the older AGENTS.md format to CLAUDE.md and defining rules at the right level: org-wide, team-specific, or per-repository. They want those files generated consistently, with inheritance respected and overrides tracked.

This is precisely where manual management breaks. CLAUDE.md standardization is not a one-time task. It is an ongoing governance problem. Org-level rules change. Teams evolve their workflows. New repositories get created without inheriting the current standard. Without a system that understands and enforces the rule hierarchy, the result is a patchwork of files that reflect whoever last ran the script, not what the organization actually intends.

An org-level rule that applies to 60 percent of repositories because there was no mechanism to enforce the other 40 is not a standard. It is a suggestion.

Why scripts and markdown files hit a ceiling

The script was not a failure of effort or intelligence. It was a reasonable response to a problem that had not yet been given the right tool.

What it could not do: propagate an org-level rule change automatically. Distinguish intentional team-level overrides from accidental drift. Give the rest of the team visibility into the current state of agent rules. Be audited when something went wrong.

This is the ceiling every homegrown tracking system eventually hits. The first version reflects a moment in time. The second tries to stay current. The third becomes a maintenance burden. Then it gets abandoned, and the only source of truth becomes the files themselves: inconsistent, unaudited, and impossible to reason about at scale.

How Tidra solves it

Tidra connects directly to your version control (GitHub, GitLab, and others). When you define a change, it spins up swarms of agents running in parallel across your repositories, executing the work in the background without manual intervention.

For CLAUDE.md standardization, that means agents fanning out across every repository simultaneously: creating missing files, updating outdated ones, and preserving intentional customizations. The rule hierarchy is enforced at execution time, not through careful human coordination. Every change lands as a reviewable pull request. Nothing merges without human approval, and the team has a full record of what changed and why.

The shift that happened in one day

The night before the call, one engineer was running a script against markdown files, aware of the problem and unable to close the gap at the scale it required. By the end of the kickoff, the whole team had a real initiative in flight: CLAUDE.md standardization across their entire codebase, with inheritance enforced and auditability built in.

A personal script became a governed, automated process. Swarms of agents handled the work across every repository in the background. The rest of the team could participate without needing to understand which markdown files tracked which repositories.

The engineer who was maintaining that script is still on the team. Now the work he was doing alone is something the whole org can run.

What gets left behind

Inconsistent agent rule files mean inconsistent agent behavior. At thousands of repositories, that inconsistency scales directly with Claude Code adoption. Every new repository created widens the gap between the standard the org intended and the configuration actually running.

If your most capable engineer is maintaining a script to keep markdown files in sync, how many repositories are running on a standard that was updated months ago and never made it downstream?

See how Tidra executes coordinated changes across your codebase →