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.
View Resource →Context Tools
Project Context Builder
Every new chat, you re-explain the same project — what it is, the stack, the conventions, the terms the AI keeps getting wrong. Capture it once. This builds a Project Context Profile you paste into your AI's persistent instructions so it permanently knows the project: stack-inferred conventions, a glossary, architecture principles, and the never-assume rules that stop it guessing. Knowledge, not behavior. Runs entirely in your browser.
One to three sentences: what the project is and who it's for. Nothing leaves the browser.
List languages, frameworks, and databases — free text or comma-separated. Detected technologies get AI-ready conventions automatically.
Output Target
Sets where the profile is installed — and tailors the install note for that tool.
Context Preview (live — completeness & detected signals, not the profile)
Project Context Profile
Set AI Team Conventions Everyone Shares
When every teammate explains the project differently, AI gets a different story each time. Shared team conventions give it one consistent account.
View 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.
View Resource →Coding Conventions for AI
Tell AI your code style once. List the stack and the engine returns the naming rules and conventions it implies — plus your own house rules carried verbatim.
View Resource →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.
View 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.
View Resource →Create a Project Glossary for AI
Your domain words mean specific things. A project glossary teaches AI the difference between a basket and a cart, an SKU and a product — so it stops using them loosely.
View Resource →How to Write Cursor Rules
Give Cursor a project context profile to load on every request — stack conventions, glossary, and never-assume rules — saved as your .cursorrules file.
View Resource →Establish Domain Knowledge for AI
AI knows general programming but not your domain. Establish how your specific world works — its rules, its vocabulary, its non-negotiables — so it reasons inside it.
View Resource →Persistent Project Context That Survives Every Chat
A handoff carries one conversation forward. Persistent context is different: facts that are true in every chat, written once and rarely touched.
View Resource →Standardize Project Terminology for AI
When half the team says "route" and the other half says "trail", AI picks one at random. Standardize the terms so its output uses your words, the same way every time.
View Resource →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.
View Playbook →AI Codebase Onboarding Workflow
Get up to speed on an unfamiliar codebase in an afternoon — ground the AI in the project, have it explain the hard parts, and keep what you learn.
View Playbook →AI Project Handoff Workflow
Carry a project into a new chat, model, or teammate without the context evaporating — capture the state, distill what's worth keeping, and rebuild it as durable context on the other side.
View Playbook →How it works
Name the project, pick its mode (Software, SaaS, Internal Tool, API Platform, Content, or Custom), and write a one-line overview. Then list the tech stack as free text — the Tech-Stack engine detects the languages, frameworks, and databases and emits the naming rules, conventions, and never-assume lines each one implies. Add your team conventions, a Term: definition glossary, the project truths to always remember, and the things AI must never assume — all carried verbatim. Click Build Project Context for a structured profile: Project Overview, Core Facts, Tech Stack, Team Conventions, Naming Rules, Architecture Principles, Glossary, Always Remember, Never Assume, and AI Usage Notes. The mode contributes safe, editable architecture principles; undefined glossary terms become honest [define] placeholders rather than guesses; a Profile Completeness score (0-100) shows how much project memory you've captured. Pick an Output Target — Generic, Claude Project, ChatGPT, Cursor, or Copilot — to tailor the install note. Paste the profile once into your tool's persistent instructions and the AI knows the project in every new chat. Nothing leaves your browser.
Use cases
- Giving AI a permanent memory of a project so you stop re-explaining it
- Turning a messy tech-stack list into AI-ready conventions and naming rules
- Teaching AI a domain glossary so it stops using your terms loosely
- Configuring Cursor, Copilot, or a Claude Project for an existing codebase
Pro tips
- List the stack generously — the engine derives conventions and never-assume rules from each technology it recognizes, so 'React, TypeScript, PostgreSQL' becomes far more than three lines.
- The Never Assume section is where this tool earns its place. It's the anti-hallucination layer: the things the model guesses wrong about your project, written down so it asks instead of inventing.
- Watch the completeness score. Below 80 means sections are still empty — the profile will carry bracketed gaps that mark missing info, never invented facts. Fill them before relying on it.
- Keep one fact per glossary line as 'Term: definition'. Abbreviations are detected automatically; any term you leave without a definition is flagged for you to fill, not guessed.
FAQ
How is this different from the System Prompt Generator?
They answer different questions. The System Prompt Generator defines BEHAVIOR — who the AI acts as, its tone, its escalation rules, its output format: a persona for a task. This tool defines KNOWLEDGE — what the AI should permanently know about your project: the stack, the conventions, the glossary, the things never to assume. Behavior versus knowledge. You often want both: a system prompt for the worker, a project profile for the facts that worker should already know.
How is this different from the Context Handoff Builder?
State versus identity. The Handoff Builder captures what's happening right now — the open task, the last decision, the next step — and carries it into one new session; it's regenerated every handoff. This tool captures what's always true about the project — the stack, the architecture, the vocabulary — written once and edited rarely. A handoff is a shift change; a project profile is the project's identity. The persistent-project-context resource is written as the mirror image of the handoff's continue-in-new-chat resource on purpose.
Does it actually generate conventions, or just reformat what I type?
It generates. The Tech-Stack engine recognizes around forty technologies and emits the naming rules, conventions, and never-assume lines each implies — type 'TypeScript' and you get 'no any, prefer unknown with narrowing, keep strict mode on' without writing it. The mode contributes architecture principles true for that project type. Your own conventions and glossary are carried verbatim on top. The output changes meaningfully with the stack and mode, not just with the field values.
Where do I paste the profile so AI remembers it?
Wherever your tool keeps persistent instructions, and the Output Target tailors the note for you: a Claude Project's instructions, ChatGPT's Custom Instructions or a Project, a .cursorrules file at your repo root, or .github/copilot-instructions.md for Copilot. Pasted there, it loads in every new chat automatically — that's the whole point. The Generic target gives you plain markdown to drop anywhere.
What does the Never Assume section do?
It's the anti-hallucination layer and the clearest sign this is knowledge, not behavior. It lists what the model must not guess about your project — don't assume the schema, don't trust client-supplied prices, don't assume a Unix shell — drawn from your own rules plus the ones the stack and mode imply. A model told what not to assume asks instead of inventing, which is where most wrong-but-confident output comes from.
Will it invent facts about my project to fill gaps?
No. Anything you don't provide becomes an explicit bracketed placeholder — [Describe what this project is], [define this term] — never a fabricated fact. The mode's architecture principles are general and true-for-type (an API platform's public interface is a contract), clearly editable, not invented specifics about your code. The completeness score and the bracketed gaps tell you exactly what's still missing so you can fill it yourself.
Is my project data sent anywhere?
No. The entire tool runs in your browser with deterministic pattern matching — no AI API, no server round-trip, no upload. Your overview, stack, conventions, and glossary never leave the page. Copy or download the profile and paste it into your AI tool yourself.