Taming Your Monorepo with GitHub Copilot 🚀

[casanova-21]

Managing a massive, complex monorepo can feel like herding cats—there are countless moving parts, intricate dependencies, and team members working across different domains who need to understand how their changes impact the broader ecosystem. But what if your AI coding assistant could become an instant expert on any part of your codebase? What if it could understand your team's specific conventions, architectural patterns, and development workflows without you having to explain them every single time?

Enter the new era of monorepo development with GitHub Copilot's advanced features. These aren't just incremental improvements—they're transformative capabilities that fundamentally reshape how teams work with large-scale codebases.

---

The Monorepo Challenge

Before diving into solutions, let's acknowledge the reality: monorepos are powerful but complex. They offer benefits like shared tooling, atomic commits across services, and simplified dependency management. However, they also present unique challenges:

• Context switching overhead: Developers need to understand multiple domains, services, and architectural patterns
• Inconsistent development practices: Different teams may have evolved different coding standards and practices
• Knowledge silos: Critical institutional knowledge often lives in the heads of senior developers
• Onboarding complexity: New team members face a steep learning curve

GitHub Copilot's latest features directly address these pain points, turning your AI assistant into a knowledgeable teammate who understands your specific codebase, conventions, and workflows.

---

Feature 1: Copilot Spaces - Creating Instant Domain Experts

What Are Copilot Spaces?

Copilot Spaces let you organize the context that Copilot uses to answer your questions. Think of them as curated knowledge bases for specific areas of your monorepo—whether that's your frontend service, API layer, shared utilities, or any other domain within your complex codebase.

In a monorepo environment, Spaces become particularly powerful because they allow you to create focused, task-specific contexts from different parts of your massive repository without overwhelming Copilot with irrelevant information.

What Can You Include in a Space?

Spaces can include diverse types of content relevant to your monorepo:

• Entire repositories or specific directories: Focus on /packages/frontend or /services/api
• Specific files: Include critical configuration files, architectural documents, or key implementation files
• Pull requests and issues: Reference past decisions, discussions, and solutions
• Uploaded files: Add design documents, spreadsheets, images, or transcripts from architecture meetings
• Free-text content: Document tribal knowledge, onboarding guides, or deployment procedures

This flexibility means you can create comprehensive domain-specific contexts that stay synchronized as your monorepo evolves—GitHub-based sources automatically update as files change.

Why Use Spaces for Monorepos?

In a monorepo, context scoping is critical. Because Spaces are optimized for specific tasks and grounded conversations, Copilot's responses become more accurate and relevant than if it were trying to navigate your entire monorepo at once.

Key Benefits:

• Domain-Specific Expertise: Create separate Spaces for your frontend service, backend service, API service, infrastructure code, or shared libraries—each becoming an instant expert in its domain
• Onboarding Acceleration: New team members can access self-service context that explains how different parts of the monorepo work
• Knowledge Preservation: Capture architectural decisions, design rationales, and best practices that would otherwise live only in senior developers' heads
• Team Collaboration: Share Spaces with your organization to reduce repeated questions and maintain consistency across teams
• Stay in Flow: Collect everything you need for a specific task without context-switching between different parts of your monorepo

Using Spaces in Your IDE

Here's where it gets really powerful for day-to-day development: you can access Copilot Spaces directly in your IDE using the GitHub MCP server. This allows you to leverage your curated monorepo context while coding without switching between your IDE and the web interface.

Prerequisites:

To use Spaces in your IDE, you need to install the GitHub MCP server. This functionality is available in any IDE that supports the GitHub Copilot extension and the GitHub MCP server, including VS Code.

How to Access Space Context:

1. Open Agent Mode: In your IDE, open Copilot Chat and select Agent from the mode dropdown (or select the Agent tab). Spaces can only be used in Agent mode since they're accessed via the GitHub MCP server.

2. Verify Spaces Tools: Click the tools icon in the Copilot Chat box. Expand the list of available tools for MCP Server: github and confirm that the get_copilot_space and list_copilot_spaces tools are enabled.

3. Reference Your Space: Enter a prompt that references the space you want to use. You can either:

   • Be specific: "Using the Copilot space 'Frontend Architecture' owned by myorg, explain the component structure"
   • Let Copilot find it: "Using the frontend architecture space, explain the component structure"

4. Continue Your Conversation: Follow-up prompts in the same chat conversation will have access to the same spaces without you having to reference them explicitly.

Important Note: When using Spaces in your IDE, repository context is not supported—you'll have access to all other sources and instructions from the space (files, issues, PRs, uploaded documents, free-text content).

What This Means for Your Workflow:

• The space's context informs Copilot's responses while you code
• You can reference the space's content when generating code, getting explanations, or working on development tasks
• Your spaces stay in sync as your project evolves—GitHub files automatically update as they change, making Copilot an evergreen expert in your monorepo

This integration brings external knowledge directly into your development context, making every coding session feel like you have a domain expert sitting right beside you—one who understands the nuances of your specific service within the larger monorepo.

Ready to get started? Visit github.com/copilot/spaces to create your first Copilot Space, or learn more in the official Spaces documentation. For detailed instructions on using Spaces in your IDE, see Using GitHub Copilot Spaces.

---

Feature 2: Custom Instructions - Your Monorepo's DNA

Repository-Wide Instructions

The foundation of effective Copilot assistance starts with .github/copilot-instructions.md—your monorepo's DNA expressed as AI instructions. This file is automatically used by Copilot Chat, Copilot coding agent, and Copilot code review whenever they work in your repository context.

Creating this file should be a collaborative effort involving all domain experts and application leads. Each team brings unique insights about their service areas, integration patterns, and requirements. Consider organizing cross-functional workshops where:

• Frontend teams contribute UI/UX standards, component libraries, and build processes
• Backend teams share data modeling patterns, API design principles, and performance requirements
• DevOps leads provide deployment strategies, environment configurations, and monitoring practices
• Security experts outline compliance requirements and security patterns
• Development teams define testing strategies and quality gates

Key Elements to Include:

• Architectural Overview: Describe your services, shared libraries, and how they interact
• Package Boundaries: Define where different services begin and end
• Shared Library Locations: Help Copilot avoid reinventing wheels you've already built
• CI/CD Workflows: Where your automation lives and how it works
• Test Practices: Your testing philosophy and conventions
• Documentation Standards: How your team documents code and decisions
• Commit Message Structure: References to GitHub Issues or Jira Stories
• Naming Conventions: Consistent patterns for packages, variables, and classes
• Secret Management: How you handle sensitive configuration

For a complete guide on creating effective custom instructions, see the official documentation.

Path-Specific Instructions

For targeted guidance, create path-specific instruction files like .github/instructions/api.instructions.md. These can be delegated to individual service teams, allowing each team to maintain their own domain-specific guidance while ensuring consistency with the overall monorepo standards.

Path-specific instructions are supported by Copilot coding agent and Copilot code review, and use frontmatter to specify exactly which files they apply to.

Delegation Strategy:

• Frontend team owns .github/instructions/frontend.instructions.md
• Backend team maintains .github/instructions/backend.instructions.md
• API team manages .github/instructions/api.instructions.md
• Infrastructure team handles .github/instructions/infra.instructions.md

The power of path-specific instructions is that when Copilot is working on files that match the specified patterns, it automatically combines both repository-wide and path-specific instructions, giving you precisely targeted guidance while maintaining overall consistency.

---

Feature 3: Coding Agent - Your Monorepo Development Companion

GitHub Copilot Coding Agent works autonomously in the background to complete development tasks—just like a human developer. Unlike traditional AI assistants in IDEs that require synchronous pairing sessions, Coding Agent operates independently in its own GitHub Actions-powered development environment where it can explore code, make changes, run tests, and create pull requests. You can assign it issues for bug fixes, incremental features, test coverage improvements, or technical debt—then review and iterate on its work through the familiar pull request workflow. Learn more about how Coding Agent works.

Environment Configuration

One of the biggest challenges with monorepos is environment setup complexity. Coding Agent addresses this with configurable setup workflows that run on GitHub Actions runners.

File: .github/workflows/copilot-setup-steps.yaml

This workflow file eliminates environment setup uncertainty and helps reduce Actions usage minutes by:

• Installing required tools, compilers, and dependencies (including private registries!)
• Leveraging GitHub's Larger Runners for complex build processes
• Setting custom environment variables specific to your monorepo
• Immediately equipping Coding Agent with everything it needs to work efficiently

Pro tip: By properly configuring your setup steps, you ensure Coding Agent spends less time figuring out how to build and test your code, which directly reduces your GitHub Actions minutes consumption. A well-tailored environment configuration means faster iterations and more efficient use of compute resources.

MCP Server Configuration

Coding Agent supports repository-level MCP (Model Context Protocol) server configuration, allowing you to extend its capabilities with custom tools and integrations. Repository administrators can configure MCP servers directly in the repository settings on GitHub.com using a JSON configuration format.

Built-in MCP Servers:

By default, Coding Agent automatically starts:

• github-remote-mcp: Connects to your GitHub data and Copilot Spaces with read-only access to the current repository
• blackbird: Leverages GitHub's semantic search capabilities to better navigate your monorepo, helping Copilot understand code relationships and find relevant components across your complex codebase

Extending with Custom MCP Servers:

You can configure additional MCP servers to bring specialized knowledge and capabilities into your development workflow. Common use cases for monorepos include:

• Service Integration Servers: Connect to Sentry, Azure DevOps, or other services to access error logs, work items, and documentation
• Cloud Platform Servers: Integrate with Azure, Cloudflare, or other cloud providers to manage resources and configurations
• Knowledge Base Servers: Connect to Notion or Confluence to access team documentation and architectural decisions
• Custom Internal Tools: Build your own MCP servers to expose internal APIs, databases, or proprietary tooling

Important Security Considerations:

• Once configured, Copilot will use MCP server tools autonomously without asking for approval
• Strongly recommend allowlisting specific read-only tools rather than enabling all tools with *
• Secrets must be prefixed with COPILOT_MCP_ and stored in a Copilot environment
• The GitHub MCP server has read-only access to your repository by default

For detailed configuration instructions and more examples, see the official MCP extension guide.

Agent-Specific Guidance

Create an AGENTS.md file—think of it as a README specifically for AI agents working in your repository. This file should include:

• High-level project architecture and goals
• How to build, test, and validate changes
• Preferred coding styles and approaches
• Integration testing strategies
• Deployment considerations

Agent instructions are supported by both Copilot coding agent and Copilot CLI, with the nearest AGENTS.md file in the directory tree taking precedence.

---

Feature 4: Enhanced Code Review - Intelligent, Scalable Quality Assurance

The Economics of AI Code Review

Copilot Code Review represents incredible value for monorepo teams. Each code review consumes just one Premium Request (PRU), charged to the PR author when Copilot posts comments to the pull request.

Understanding Premium Request Allowances:

Different Copilot plans include monthly premium request allowances:

• GitHub Copilot Business ($19 per user/month): 300 premium requests per user per month
• GitHub Copilot Enterprise ($39 per user/month): 1,000 premium requests per user per month

This means with Copilot Business, each team member can request up to 300 code reviews per month (or use those premium requests for other features like Copilot Chat with premium models, coding agent sessions, or Copilot Spaces). With Enterprise, that allowance increases to 1,000 premium requests per user per month.

Beyond the Allowance:

If you exceed your monthly premium request allowance, additional PRUs cost just $0.04 each. This means even beyond the included quota, each code review costs only four cents—a fraction of the cost of a developer's time to manually review a pull request. When you consider that a typical developer code review might take 15-30 minutes, the $0.04 cost of an automated Copilot review becomes remarkably cost-effective.

For detailed information about premium request pricing and allowances, see the Copilot plans comparison.

Why This Matters for Monorepos:

At these rates, automated code review becomes economically feasible for every pull request in your monorepo—even for organizations with high PR volumes. The combination of generous monthly allowances and minimal overage costs means you can establish Copilot as a consistent first-line reviewer without worrying about budget constraints.

How It Works

Using Copilot code review is straightforward:

1. Create or navigate to a pull request on GitHub
2. Select "Copilot" from the Reviewers menu
3. Wait less than 30 seconds for the review
4. Read through Copilot's contextual comments and suggested changes

Copilot always leaves "Comment" reviews that don't block merging but provide valuable feedback. Where possible, comments include suggested changes you can apply with just a couple of clicks.

Learn more about using Copilot code review and how to configure automatic reviews.

Architectural Evolution

The July 2025 architectural improvements transformed code review from simple LLM calls to an intelligent agent system:

• Agent-Based Architecture: Self-navigates codebases for deeper analysis
• Integrated Static Analysis: Automatic CodeQL integration with plans for additional linters
• Enhanced Bug Detection: Catches functional runtime errors by tracing method calls
• Contextual Navigation: Understands component relationships and provides specific guidance

Repository Rules Integration

Code review can be enforced at the organization or repository level using GitHub Repository Rules, ensuring every PR automatically invokes Copilot as a reviewer. This creates a consistent quality gate across your entire monorepo.

Custom Instructions Integration

Copilot code review automatically leverages both repository-wide and path-specific custom instructions, ensuring reviews are consistent with your team's standards and practices. The custom instructions help Copilot understand your specific requirements, coding conventions, and architectural patterns.

---

Feature 5: Custom Chat Modes - Specialized AI Assistants

Understanding Chat Modes

Chat modes in VS Code create specialist AI agents tailored for specific tasks or roles. While VS Code comes with built-in modes (Ask, Edit, and Agent), you can create custom modes stored in .github/chatmodes/ for your entire team to use.

For a comprehensive guide on creating and using custom chat modes, check out the VS Code documentation.

Custom Chat Mode Structure

Each custom chat mode is defined in a .chatmode.md file with:

• Frontmatter: Description, available tools, and optionally a specific AI model
• Body: Detailed instructions and guidelines in Markdown format

Tailored Workflows for Monorepo Challenges

Custom Chat Modes allow you to create specialized AI assistants for common monorepo scenarios:

Feature Planning Mode

Helps scope new features across multiple services, identifying integration points and potential conflicts.

Dependency Change Impact Analysis

Analyzes how changes to shared libraries or core services might affect dependent packages.

Shared Library Extraction Mode

Identifies common code patterns that could be extracted into reusable libraries.

Test Coverage Explorer

Understands your testing strategy and helps identify gaps or redundant coverage.

Monorepo Standards Enforcer

Ensures new code follows established conventions and architectural patterns.

Changelog Generator

Creates release notes that make sense across multiple services and domains.

Seamless Context Switching

Custom Chat Modes eliminate the friction of explaining context repeatedly. Switch between specialized assistant roles instantly using the chat mode dropdown in VS Code, each equipped with the right knowledge and tools for specific scenarios.

---

Putting It All Together: A Day in the Life

Imagine starting work on a complex feature that spans multiple services in your monorepo:

1. Morning Planning: Use Feature Planning Mode to scope the work, automatically understanding dependencies between your frontend service, backend service, and API service.

2. Development: Code with Agent Mode that understands your specific architectural patterns, coding standards, and can access specialized knowledge from relevant Copilot Spaces. The blackbird MCP server helps navigate your monorepo using semantic search to find related components and understand code relationships.

3. Testing: Leverage Test Coverage Explorer to ensure your changes are properly tested across all affected services.

4. Review: Submit your PR knowing that Copilot will provide intelligent, contextual review feedback that understands your monorepo's specific patterns and conventions.

5. Documentation: Use Changelog Generator to create release notes that clearly communicate changes across all affected services.

---

Getting Started: Implementation Strategy

Phase 1: Foundation

1. Create your repository-wide copilot-instructions.md through collaborative workshops with all domain experts
2. Delegate path-specific instruction files to individual service teams for their areas of expertise
3. Configure Coding Agent environment setup workflows

Phase 2: Specialization

1. Create Copilot Spaces for your most complex or frequently modified service areas
2. Implement Custom Chat Modes for your most common workflows
3. Enable automatic code review through Repository Rules

Phase 3: Optimization

1. Refine instructions based on team feedback and usage patterns
2. Add specialized MCP servers for domain-specific tooling
3. Create additional Chat Modes for emerging workflow needs

---

The Future of Monorepo Development

These GitHub Copilot features represent more than just productivity improvements—they're fundamentally changing how teams work with complex codebases. By encoding institutional knowledge into AI-accessible formats and creating specialized AI assistants for common tasks, teams can:

• Reduce onboarding time from weeks to days
• Maintain consistency across large, distributed teams
• Scale expertise without scaling headcount
• Focus on innovation instead of context switching

The monorepo no longer needs to be a source of complexity and friction. With the right Copilot configuration, it becomes a well-organized, AI-navigable workspace where every team member has access to the collective knowledge and best practices of the entire organization.

---

Next Steps

Ready to tame your monorepo? Start with the foundational custom instructions and gradually layer on the more advanced features. Remember: the goal isn't to replace human expertise, but to augment it, making your team's collective knowledge accessible to everyone, all the time.

Your monorepo's complexity doesn't have to be your team's burden. Make it GitHub Copilot's specialty instead.

---

Have you implemented any of these features in your monorepo? Share your experiences and lessons learned in the comments below. For more insights on monorepo management and AI-assisted development, follow our blog and check out the GitHub Copilot documentation.

Further Reading

• Get Started with Copilot Spaces
• About GitHub Copilot Spaces
• Using GitHub Copilot Spaces
• About GitHub Copilot Coding Agent
• Custom Chat Modes in VS Code
• Repository Custom Instructions Guide
• Using GitHub Copilot Code Review
• Configure Automatic Code Review
• Extending Coding Agent with MCP
• Understanding Premium Requests
• Comparing Copilot Plans

[henriquetourinho]

Hi casanova-21,

This is a fantastic and incredibly thorough breakdown! You’ve perfectly articulated the pain points of monorepos and how these advanced Copilot features transform them from a burden into a scalable asset.

I agree that the combination of features is powerful, but I think Copilot Spaces is the single most transformative capability here, especially for mitigating Context Switching Overhead.

Why Spaces Are Game-Changing for Monorepos
For us, the biggest drain on productivity in a monorepo is the cognitive load required to jump from service A (Python API) to service B (TypeScript Frontend). Before Spaces, even with custom instructions, you had to hope Copilot's context window included the right READMEs and architectural docs.

Spaces solve this by allowing us to:

Create Ephemeral, Task-Specific Experts: A developer working on a frontend bug doesn't need context on the entire deployment pipeline. They only need the 'Frontend Architecture' Space, which includes the relevant component library docs, design system files, and recent UI pull requests.

Decentralize Knowledge: We can delegate the maintenance of the 'Infrastructure Space' to our DevOps lead. They update it once, and every developer instantly gains specialized, up-to-date infra expertise without disturbing the lead developer. This instantly solves the Knowledge Silos problem you mentioned.

Optimize the MCP Server Integration: The fact that Spaces can be accessed directly in the IDE via the MCP server makes the context seamless. It's the difference between asking an expert next to you vs. opening a new browser tab and re-explaining your environment.

The ability to essentially pre-package and share domain-specific institutional knowledge is the true unlock here. It accelerates onboarding and turns every developer into a specialist when they need to be one.

Great post! We are definitely prioritizing the rollout of Spaces and path-specific instructions this quarter. Have you found any particular challenges with synchronizing the Custom Instructions with the knowledge captured in the Spaces yet?

[casanova-21]

@henriquetourinho Hi there! I really appreciate the feedback on the post and am glad it's helped you out. ❤️ I also want to clarify one thing on this post which is the section on custom chat modes. I wrote this prior to our announcement that we are moving away from the VS Code custom chat modes in favor of custom agents. They essentially work the same way except for the fact that the custom agents can also be leveraged by Copilot Coding Agent as opposed to the chat modes which are just a function of VS Code.