What is the Brain Graph
Obsidian popularised the idea that knowledge is not a flat list of notes — it is a web of connections. When you can see those connections as a graph, patterns emerge that you would never notice by scrolling through a list. You spot clusters of related ideas, isolated nodes that need linking, and paths between concepts that seemed unrelated.
AICODESIT's Brain Graph brings the same idea to your codebase and your AI's working memory. It is an interactive, force-directed graph panel inside the IDE that shows two things: how the project's files relate to each other, and how the AI's memory notes are connected. Click a node to explore its neighbourhood. Drag nodes to rearrange. Scroll to zoom. Write a new memory note without leaving the graph.
The graph is not decorative. It is a direct window into what the AI knows about your project — and a fast way to give it more context when it needs it.
Three views: Memory graph, Notes list, Files graph
The Brain panel has three tabs, each showing a different slice of the project's knowledge. You switch between them with the tab bar at the top of the panel.
| Tab | What it shows |
|---|---|
| Graph | Memory notes as an interactive graph. Nodes are notes; edges show semantic connections between them. Click a node to open and edit it. |
| Notes | A flat, chronological list of all memory notes — title, description, filename, and last-updated time. Good for finding a specific note quickly. |
| Files | Your project's source files as a graph. Each node is a file; edges show imports and references. Color-coded by file type. |
All three views share the same controls: scroll to zoom, click-drag on the background to pan, click-drag on a node to move it, and the refresh button in the top-right corner to reload data.
The Memory graph — your AI's knowledge map
Memory notes are short markdown files that the AI uses to remember persistent facts about your project: decisions made, conventions adopted, modules documented, warnings to keep in mind. When the AI generates code, it reads these notes so it does not forget what was agreed on in a session three days ago.
The Memory graph makes this knowledge visible. Each note is a node. The size of the node reflects how many connections it has — a note that is referenced by many other notes appears larger. The edges are drawn as dashed lines to distinguish them from the solid lines in the Files graph.
Clicking a node
Clicking any node in the Memory graph opens a full editor popup directly in the panel. The popup shows three fields:
- Title — the display name of the memory note (editable inline)
- Description — a one-line summary used as the node's hover tooltip
- Content — the full markdown body of the note, in a monospace editor
You can edit any field and click Save, or click Delete to remove the note entirely. Changes take effect immediately — the graph refreshes automatically after a save or delete.
Selecting a node highlights its connections
When you click a node, its directly connected neighbours are highlighted and everything else dims. This is the same interaction Obsidian uses — it lets you focus on one cluster of related notes without losing the overall graph context. Click the same node again to deselect and restore the full view.
Hover tooltip
Hovering over any node (without clicking) shows a tooltip at the bottom of the panel containing the node's title and description. Useful for scanning a large graph to find a specific note without opening each one.
Creating a new memory note
Click the + button in the top-right corner of the panel. A form appears with three fields — title, description, and content. Fill them in and click Create. The new note is saved and the graph refreshes with the new node in place.
Memory notes support plain markdown. The AI reads them verbatim, so writing clearly matters. A good memory note starts with the most important fact in the first sentence, not buried halfway through a paragraph.
The Notes list — CRUD for memory files
The Notes tab shows the same memory files in a flat, time-ordered list rather than a graph. Each row shows the note's title, description, filename, and how long ago it was last updated (e.g. "3h ago", "Jun 14").
Click any row to open the same editor popup used in the graph view. The list is the faster path when you know what you are looking for and do not need to see the connections. The graph is better for exploration and discovery.
Both views stay in sync. A note created in the Notes tab appears immediately in the Graph tab, and vice versa.
The Files graph — visualise your codebase structure
The Files tab shows your project's source files as an interactive graph. Each file is a node. Edges represent imports and references — if Button.tsx imports from utils.ts, there is an edge between them. Node size reflects how many other files reference that file, so your core modules and shared utilities appear as the largest nodes in the graph.
Color coding by file type
Files are colored by extension so you can immediately identify what is what:
| Color | File types |
|---|---|
| Blue | .tsx, .ts — TypeScript and React components |
| Yellow | .js, .jsx — JavaScript files |
| Pink | .css, .scss — Stylesheets |
| Orange | .html — HTML files |
| Grey | Everything else — JSON, config, markdown, etc. |
The legend appears at the bottom of the panel when the Files tab is active. The same scroll/pan/drag controls apply. Clicking a file node highlights its imports and dependants — everything unrelated dims.
What the Files graph is good for
The Files graph is not a code navigation tool — use the file tree for that. It is a structural overview. Use it to spot:
- Highly connected files that might be over-coupled (large nodes with many edges)
- Isolated files that nothing imports (possible dead code)
- Clusters of tightly related components that could be extracted into their own module
- The overall architecture shape — whether the project is a hub-and-spoke, a flat mesh, or a layered hierarchy
When you are handing a project to the AI for a large refactor, looking at the Files graph first gives you a clear picture of what is likely to break — the high-connectivity nodes.
How to use Brain Graph effectively
Write memory notes for decisions, not implementations
The AI already knows what is in your files by reading them. Memory notes are for things that are not in the files: why a decision was made, what approach was rejected and why, what naming convention applies to a specific domain, what a third-party API returns that the docs do not mention. These are the facts that get lost between sessions.
A good rule: if you find yourself re-explaining the same thing to the AI in every new session, write a memory note about it once.
Use the graph to audit what the AI knows
Before starting a complex task, open the Brain Graph and switch to the Memory view. Check how many notes exist, whether they are connected sensibly, and whether any are out of date. Stale notes with wrong information are worse than no notes — the AI will follow them. If a note is no longer accurate, open it and update or delete it.
Use the Files graph before big refactors
Before asking the AI to refactor a large chunk of the codebase, open the Files tab and find the highest-connectivity nodes (the largest circles). These are the files most likely to require updates across multiple other files when changed. Tell the AI explicitly which high-connectivity files it will be touching — this reduces the chance of it missing a downstream dependency.
Keep memory notes short
The AI reads every memory note at the start of each session. Long, unfocused notes waste context window space and dilute the signal. Aim for notes under 200 words. If a note is growing long, split it into two notes and connect them — the graph will show the relationship.
Conclusion
The Brain Graph is a small panel with a surprisingly large effect on how well the AI understands your project. The Memory graph makes the AI's knowledge visible and editable. The Files graph makes your codebase's structure visible at a glance. Together they give you — and the AI — a shared mental model of the project that survives across sessions.
If you have used Obsidian for personal notes, the interaction will feel immediately familiar. If you have not, the core idea is simple: some things are understood better as a map than as a list. The Brain Graph is that map for your code.
Open Brain Graph in AICODESIT →
Related: How to automate your dev workflow with AICODESIT's Pipeline Builder · Claude Fable 5 on AICODESIT — the most capable model for complex tasks