Resource
Build Project Memory for AI
Stop re-explaining your project in every new chat. Capture it once as a context profile the AI keeps across every conversation — stack-inferred conventions and all.
Configure AI for an Existing Codebase
Set up Cursor, Copilot, or Claude for a repo that already exists. One profile becomes the rules file your AI assistant reads on every request.
Overview
In-editor assistants are only as good as the context they're configured with — and most repos give them none. This setup configures AI for Relay, a microservices logistics backend where each service owns its data and talks over a bus. Choosing the Copilot output target tailors the install note (.github/copilot-instructions.md); switching to Cursor produces a .cursorrules file instead. The profile carries the architecture principles, the cross-service rules, and the never-assume list, so the assistant respects service boundaries instead of reaching across them.
How to use this resource
-
Capture the architecture
Service boundaries, the bus, data ownership — the rules an assistant must respect.
-
Pick the target tool
Copilot, Cursor, or Claude — the install note adapts to where the file goes.
-
Commit the rules file
The assistant reads it on every request; the whole team gets the same context.
Why This Works
- The output target tailors the install path for Cursor, Copilot, or Claude exactly
- Architecture principles keep the assistant inside service boundaries
- Committing the file means every teammate's assistant shares one source of truth
Best for
- Repos using Cursor, Copilot, or Claude Projects
- Microservice and multi-team backends
- Teams that want shared, version-controlled AI rules
Not for
- A throwaway prompt for one question — use the Prompt Template Builder
- Carrying a half-finished task into a new chat — use the Context Handoff Builder
FAQ
Where do I save the file for Copilot versus Cursor with this codebase profile?
The rendered profile carries an install note pointing to `.github/copilot-instructions.md`, which Copilot Chat picks up automatically once committed. Switch the output target in project-context-builder to Cursor and it produces a `.cursorrules` file instead; the same Relay conventions and Never Assume list travel with either path. Your assistant reads whichever file you commit.
How does this profile stop the AI from reaching across microservice boundaries?
The `## Never Assume` and `## Always Remember` sections spell out "each service owns its own data — never reach into another service's database" and "do not assume a relational schema or foreign keys." Because project-context-builder bakes those rules into the committed file the assistant reads on every request, it respects the Relay bus-and-service model instead of inventing JOINs. You still review its output.
Is this the same as a system prompt, or should I use a different NewPrompt tool?
It is project KNOWLEDGE, not behavior — the `## AI Usage Notes` section says so directly. For a task persona with role, tone, and escalation rules, build a System Prompt in the System Prompt Generator; to carry a half-finished task into a new chat, use the Context Handoff Builder. This profile is durable project identity the whole team commits, not work state.
Can I adapt this Relay microservices example for a monolith or a different stack?
Yes — replace the Relay-specific content and re-run project-context-builder. The per-tech tagged conventions like "(MongoDB)" model-documents-not-rows or "(Kubernetes)" treat-pods-as-ephemeral are swappable for your stack, and the `## Team Conventions`, `## Naming Rules`, and `## Glossary` (Service/Bus/Saga/Idempotency) get rewritten to your architecture. The `Profile completeness: 100/100` line reflects your inputs, not this example.
More resources from Project Context Builder
Resource
Create an AI Project Profile
A reusable profile that tells AI everything constant about your project — type, stack, conventions, glossary, architecture principles, and the rules it must never guess.
Resource
AI Onboarding Context for an Existing Codebase
Onboard AI to a codebase the way you'd onboard a new hire: what it is, how it's built, the rules that aren't written down, and the things never to assume.
Resources that pair well
Resource
AI Session Handoff — Shift Change for Working Sessions
End a working session like a shift change, not an abandonment: state captured, decisions logged, next step named — ready for the next session to pick up.
Resource
Bug Triage Assistant
Convert scattered bug notes, Slack messages, or user complaints into structured engineering tasks with reproduction steps, severity, and root cause hypothesis.
Resource
Convert a Conversation to a Prompt — the Full Anatomy
What a converged conversation contains: a rejected voice, an accepted framing, a hard constraint, a format decision, and a final-version moment — each mapped to its prompt section.
Related tools
Tool
Project Context Builder
Define what AI should permanently know about your project — stack conventions, glossary, and never-assume rules in a profile you paste once.
Workflows that use this resource
Workflow
AI Code Review Workflow
A complete AI-assisted review pass — not one prompt — that ends with ranked findings, tests guarding behavior, and a refactor plan when one is warranted.
Workflow
AI Architecture Recovery Workflow
Recover a legacy system's architecture before you change it — package the codebase context, explain the current structure, surface the risks and seams, then document the recovered architecture.
Guides for this resource
Guide
How to Configure AI to Follow Your Codebase's Conventions
The code compiles, the tests pass, and it doesn't look like anything else in the repo. "Follow our conventions" is a wish: yours aren't written down, they're spread across nine hundred files that disagree. Here's how to extract the real rules and test them.