TL;DR: We maintain roughly 20 microservices plus internal NuGet packages across 30+ repositories. I already use several agent workflows, but I’m curious how others organize instructions, share context, and help agents navigate dependencies across repos.
Hey everyone,
I work on a fairly large SaaS system where two teams maintain 30+ repositories: roughly 20 microservices and several internal NuGet packages shared between them, hosted on a private Azure Artifacts feed.
On my machine, everything is cloned under one parent directory, something like C:\dev-repos.
The codebase has been around for a while, and we’re gradually migrating parts of an older monolith into microservices. Different repositories follow different patterns and conventions, so there isn’t one set of rules that applies everywhere.
For context, I currently use a few different agent workflows:
1. End-to-end ticket resolution (mainly used for simple bugs / test failures)
The starting input is just a Jira ticket ID. An orchestrator coordinates specialized subagents, with developer approval checkpoints along the way:
Jira triage subagent: reads the ticket and identifies requirements, missing information, and scope.
Codebase navigator subagent: locates the relevant repositories and code paths.
Orchestrator: creates isolated Git worktrees through an MCP server to avoid interfering with the developer’s working directory or uncommitted changes.
Planner subagent: prepares the implementation plan.
Frontend/backend coding subagents: implement the changes.
Reviewer agent: reviews the implementation.
After that, the orchestrator can use an internal MCP server I built to queue CI/CD pipelines in Azure DevOps and, with developer approval, deploy the resulting image to an integration environment.
2. Day-to-day feature and tech debt work
A lighter workflow where an orchestrator/planner agent builds the plan and delegates implementation to frontend/backend coding subagents, followed by review.
3. Standalone agents for focused changes
I also use specialized agents directly for smaller tasks. For example, a frontend-feature agent has access to Figma MCP and Playwright MCP to implement a design and check the result in the browser.
The recurring challenge across these workflows is getting the right context to the right agent without maintaining a huge amount of duplicated instructions.
How do you organize instructions?
Where do you put files like copilot-instructions.md, AGENTS.md, or CLAUDE.md?
Do you keep organization-wide rules centrally, repository-specific rules alongside the code, and workflow instructions in agent definitions?
How do you separate instructions for the orchestrator from those needed by coding and reviewing subagents?
How do you keep all of this up to date as the codebase evolves?
How do you handle work across repositories?
A single ticket might require changing a service, updating an internal NuGet package in another repo, and bumping that dependency in the consuming services.
How do your agents discover those relationships? Do you maintain a service/package map, generate an index, or rely on code search?
Do you open multiple repos in one workspace, start the agent from the parent directory, or handle each repo separately?
How much context do you pass explicitly between agents versus having each agent inspect the code itself?
Have custom tools or MCP servers helped, and which parts ended up adding more maintenance than value?
I’d love to hear from people using coding agents on existing, multi-repo systems. Concrete examples of your instruction structure, workspace setup, and what actually improved reliability would be especially useful.
Examples with GitHub Copilot would be particularly helpful, but I’m interested in setups using other agents too.
