14 - Copilot Spaces and Memory

Copilot Spaces, Agentic Memory and Repository Indexing

One of the most critical factors that determines the quality of an AI assistant's responses is context. The more a language model understands your project, your conventions and your goals, the better the suggestions it produces. Until recently, providing context to Copilot required manual effort: opening relevant files, writing detailed prompts, repeating information already provided in previous sessions.

With the introduction of Copilot Spaces, Agentic Memory and improvements to Repository Indexing, GitHub has addressed this problem structurally. These three tools work in synergy to ensure that Copilot always has the right context at the right time, drastically reducing the need to repeat information and improving response consistency over time.

In this fourteenth article of the series, we will explore each of these tools in detail: how they work, how to configure them and how to use them to maximize productivity in daily work.

Copilot Spaces: Organizing Context for Focused Conversations

Copilot Spaces is a feature that allows you to create organized collections of context for conversations with Copilot. A Space is essentially a container where you can include different types of information relevant to a specific task, project or work area. Instead of having to explain to Copilot every time what you are working on, you create a Space once and reuse it for all conversations related to that context.

What You Can Include in a Space

The strength of Spaces lies in the flexibility of the supported content types. You are not limited to code alone: you can include any information useful to give Copilot the necessary context.

Smart Loading: Intelligent Context

A fundamental aspect of Spaces is the Smart Loading mechanism. When you include a repository in a Space, Copilot does not load the entire repository contents into the conversation context. This would be impossible for large repositories and inefficient even for small ones.

Instead, Smart Loading works similarly to a semantic search engine: when you ask a question, Copilot dynamically searches and retrieves only the files and code sections relevant to your specific request. This approach offers the best of both worlds: you have access to the entire repository as a context source, but only the relevant parts occupy the model's context window.

Creating and Managing Spaces

Creating a Space is done through GitHub's web interface or directly from the IDE. The process is simple and intuitive.

Creating a Space for a Project

SPACE: "E-commerce Backend"

INCLUDED REPOSITORIES:
- org/ecommerce-api (main repository)
- org/shared-libs (shared libraries)
- org/ecommerce-docs (documentation)

SPECIFIC FILES:
- ecommerce-api/src/models/*.ts (all data models)
- ecommerce-api/prisma/schema.prisma (database schema)
- ecommerce-api/.copilot-instructions.md (project conventions)
- ecommerce-api/docs/architecture.md (architectural decisions)

INCLUDED ISSUES:
- #234: "Migrate to Event-Driven Architecture" (under discussion)
- #267: "Performance degradation on product search" (critical bug)

FREE TEXT:
"This project uses NestJS with Prisma ORM. The database is PostgreSQL.
Authentication is based on JWT with refresh token.
APIs follow the CQRS pattern with event sourcing for orders.
We use the Repository pattern for data access.
Tests follow the pyramid: 70% unit, 20% integration, 10% E2E.
Deployment happens via GitHub Actions on AWS ECS."

Use Cases for Spaces

Spaces is particularly useful in scenarios where the context is complex, distributed across multiple repositories, or where different team members work on different aspects of the same project.

Best Practices for Spaces

Agentic Memory: Persistent Memory for Copilot

Agentic Memory is one of the most revolutionary features introduced in Copilot, currently available in Early Access for users on Pro and Pro+ plans. It is a persistent memory system that allows Copilot to remember information learned during previous interactions, eliminating the need to repeat the same explanations in every new chat session.

How Memory Works

Agentic Memory works through a process of automatic deduction. During conversations with Copilot, the system identifies information that could be useful in the future and saves it as "memories". These memories are not exact copies of conversations, but structured summaries of key information deduced from the interaction.

Types of Memories

The system does not memorize everything indiscriminately. Memories are categorized and filtered by relevance, focusing on information that has high reuse value.

Persistence and Expiration

Memories have a well-defined lifecycle, designed to balance usefulness and relevance over time.

Repository-Specific Scope

A fundamental aspect of Agentic Memory is that memories are repository-specific. Information learned while working on repository A is not used when working on repository B. This design ensures that context is always pertinent and prevents contamination between different projects.

This design choice has important implications: project A's conventions will not influence suggestions for project B, even if you use the same Copilot account. Each repository has its own independent "brain" that grows and enriches itself only through interactions specific to that repository.

Auto-Compaction

When the volume of memories reaches 95% of the maximum token limit allocated, the system activates an auto-compaction process. Memories are evaluated based on usage frequency, recency and relevance. The least used memories are condensed or removed to make room for new information.

This mechanism ensures that Copilot's "brain" for each repository stays focused on the most useful information, without accumulating information debris that could degrade response quality. It is an automatic process that does not require user intervention, although it is possible to manage memories manually if needed.

Practical Benefits of Agentic Memory

Manual Memory Management

Although the system is designed to be automatic, users have full control over stored memories. You can:

• View: Access the complete list of memories for each repository
• Edit: Correct inaccurate memories or add details
• Delete: Remove obsolete or incorrect memories
• Force creation: You can explicitly ask Copilot to remember something

// In the Copilot chat, you can say:

"Remember that in this project we always use
the Result<T, E> pattern for error handling
instead of throwing exceptions. Every service must
return Result<SuccessType, ErrorType>."

"Remember that database migrations should always
be created with the command: npx prisma migrate dev --name <descriptive-name>"

"Remember that our branch naming convention is:
feature/JIRA-XXX-brief-description
fix/JIRA-XXX-brief-description
chore/JIRA-XXX-brief-description"

"Remember that integration tests must use
the test database (TEST_DATABASE_URL) and not the
development database."

Repository Indexing: Instant Semantic Search

Repository Indexing is the engine that powers Copilot's deep understanding of code. When a repository is indexed, Copilot creates a semantic representation of the code that allows it to understand not only the file structure, but also the logical relationships between components, the dependencies between modules and the data flow through the system.

Automatic Indexing

Indexing happens automatically the first time a user starts a Copilot Chat conversation in a repository. No configuration or manual action is required. Once indexing is complete, all Copilot users accessing that repository benefit from the shared index.

What Gets Indexed

Indexing goes well beyond a simple text search index. The system creates a semantic understanding of the code that includes:

Indexing Speed

One of the most significant innovations is the reduction of indexing time to under 60 seconds. In previous versions, indexing could take minutes or even hours for large repositories. Today, thanks to optimizations in the embedding algorithm and indexing infrastructure, semantic search is available almost instantly.

After the initial indexing, updates are incremental: when you push new commits, only the modified files are re-indexed, keeping the index always up to date without requiring a complete re-indexing.

Impact on Response Quality

Repository Indexing has a direct and measurable impact on the quality of Copilot's responses. Without indexing, Copilot can only see the files currently open in the editor. With indexing, it has access to the entire codebase.

Enterprise Controls

For organizations, Repository Indexing offers granular controls to manage which content gets indexed and which is excluded. This is particularly important for repositories containing sensitive code or proprietary information.

# Files and folders to exclude from Copilot indexing
# Similar to .gitignore but specific to Copilot

# Secrets and credentials
.env
.env.*
**/secrets/
**/credentials/
**/*.pem
**/*.key

# Sensitive data
**/fixtures/customers.json
**/seed/production-data.sql

# Proprietary code
src/core/proprietary-algorithm/
src/core/patent-pending/

# Generated files (noise in indexing)
dist/
build/
node_modules/
coverage/
*.min.js
*.bundle.js

# Vendor code
vendor/
third-party/

# Large files (not useful for context)
**/*.csv
**/*.sql.gz
**/*.dump

Synergy Between Spaces, Memory and Indexing

The true power of these three tools emerges when they work together. Each one covers a different aspect of the context problem, and together they provide Copilot with a complete and persistent understanding of the project.

In practice, when you ask Copilot a question:

1. Repository Indexing retrieves the relevant files and code structures
2. Spaces adds additional context (issues, PRs, documentation, notes)
3. Agentic Memory applies conventions and preferences learned in previous sessions
4. All these contexts are combined and sent to the model to generate the response

Practical Examples

Let's see how these tools apply in daily work scenarios.

Example 1: Space Setup for Multi-Repo Project

PROJECT: E-commerce platform with 5 microservices

REPOSITORIES:
1. ecommerce-gateway (API Gateway - Node.js)
2. ecommerce-products (Product catalog - Python/FastAPI)
3. ecommerce-orders (Order management - Java/Spring Boot)
4. ecommerce-payments (Payments - Go)
5. ecommerce-notifications (Notifications - Node.js)

RECOMMENDED SPACE: "E-commerce Platform"

CONTENTS:
- All 5 repositories
- proto/ files with shared gRPC definitions
- OpenAPI files for each service
- Architecture document (C4 model)
- ADR (Architecture Decision Records)
- Team notes: "The payments team is external,
  communication via Slack #payments-integration"

RESULT:
When you ask "How does the checkout flow work?",
Copilot can trace the flow across all services:
Gateway -> Products (check availability)
        -> Orders (create order)
        -> Payments (process payment)
        -> Notifications (send confirmation)

Example 2: Using Memory for Conventions

SESSION 1 (Day 1):
Developer: "Create a new service for invoice management"
Copilot generates the service following generic patterns.
Developer: "No, in our project services always follow
this pattern: InvoiceService extends BaseService<Invoice>
with methods findById, findAll, create, update, delete.
We also use the @Injectable() decorator and the
Result<T, E> pattern for errors."
Copilot generates the correct version.
>> MEMORY CREATED: "Services follow the
BaseService<T> pattern with @Injectable() decorator and Result<T,E>"

SESSION 2 (Day 5):
Developer: "Create a service to manage customers"
Copilot automatically generates:
- CustomerService extends BaseService<Customer>
- @Injectable() decorator
- All CRUD methods with Result<T, E>
- Error handling consistent with InvoiceService
>> NO ADDITIONAL INSTRUCTIONS NEEDED

Example 3: Repository Indexing for Code Exploration

CONTEXT: New developer on the project (50K lines of code)

QUESTIONS AND ANSWERS (with Repository Indexing):

Q: "How is the project structured?"
A: The project follows a Clean Architecture with 4 layers:
   - src/domain/ (entities and business rules)
   - src/application/ (use cases)
   - src/infrastructure/ (database, external APIs)
   - src/presentation/ (controllers, DTOs, middleware)
   [cites specific files and folders]

Q: "How does authentication work?"
A: Authentication uses JWT with refresh token:
   - src/infrastructure/auth/jwt.strategy.ts (validation)
   - src/infrastructure/auth/auth.guard.ts (route protection)
   - src/application/auth/auth.service.ts (login logic)
   [shows the flow with references to actual code]

Q: "Where should I put a new endpoint for reports?"
A: Based on the project structure:
   - Controller: src/presentation/controllers/report.controller.ts
   - Service: src/application/services/report.service.ts
   - Repository: src/infrastructure/repositories/report.repository.ts
   - DTO: src/presentation/dto/report.dto.ts
   - Test: test/unit/report.service.spec.ts
   [follows exactly the pattern of other endpoints]

Advanced Configuration

To get the most out of these tools, it is important to configure them correctly based on the needs of the project and team.

.copilot-instructions.md File

The .copilot-instructions.md file in the repository root is automatically included in the context of every Copilot conversation. It is the most direct way to provide persistent instructions to Copilot for a specific repository.

# Instructions for Copilot

## Technology Stack
- Backend: NestJS 10 with TypeScript 5.3
- Database: PostgreSQL 16 with Prisma 5
- Cache: Redis 7
- Queue: BullMQ
- Testing: Jest + Supertest
- Linting: ESLint + Prettier

## Coding Conventions

### Naming
- Files: kebab-case (user.service.ts)
- Classes: PascalCase (UserService)
- Methods: camelCase (findById)
- Constants: UPPER_SNAKE_CASE (MAX_RETRY_COUNT)
- Interfaces: PascalCase with I prefix (IUserRepository) -- NO, without prefix

### Patterns
- Services: extend BaseService<T>
- Repositories: implement IRepository<T>
- Controllers: use @Controller() decorator with plural path (/users, /orders)
- DTOs: use class-validator for validation
- Errors: Result<T, AppError> pattern (never throw exceptions)

### Testing
- Unit tests: file.spec.ts in the same folder as the source
- Integration tests: test/integration/ with test database
- E2E tests: test/e2e/ with supertest
- Coverage target: 80% for services, 60% for controllers

### Git
- Branch: feature/PROJ-XXX-description, fix/PROJ-XXX-description
- Commit: conventional commits (feat:, fix:, chore:, docs:)
- PR: template in .github/PULL_REQUEST_TEMPLATE.md

## Business Rules
- Prices are always in cents (integer, never float)
- Dates are always in UTC
- IDs are UUID v4
- Soft delete for all entities (deletedAt field)
- Audit trail for every CRUD operation (createdBy, updatedBy fields)

Optimizing Indexing

To improve indexing quality and semantic search performance, follow these guidelines:

Comparison with Alternative Approaches

To contextualize Spaces, Memory and Indexing, it is useful to compare them with alternative approaches to providing context to AI.

Limitations and Considerations

Despite the obvious advantages, it is important to know the current limitations of these tools in order to use them with realistic expectations.

Data Privacy and Security

An important aspect to consider, especially for enterprise teams, concerns the privacy and security of data used by these tools.

Conclusion

Copilot Spaces, Agentic Memory and Repository Indexing represent a qualitative leap in how we provide context to AI development tools. Instead of repeating the same information in every session, we can build a persistent context ecosystem that grows and enriches itself over time.

The combination of these three tools covers all aspects of context: the code (Repository Indexing), external information (Spaces) and implicit knowledge (Memory). Together, they transform Copilot from a generic assistant to a partner that knows your project, your conventions and your preferences.

The practical advice is: start with Repository Indexing (automatic), add a .copilot-instructions.md file with project conventions, and then create Spaces for the most complex contexts. Memory will build naturally over time through your daily interactions.