Stop the Hallucinations — Give Your AI a Living Brain That Knows Today's Android, Not 2023's Android
Imagine your AI is a SUPER SMART robot friend.
It read every Android book in the world... but stopped reading 6 months ago.
Now Google released new rules:
✨ Compose has a new way to do things.
✨ Room database got a major update.
✨ The old "kotlin-android" plugin is dead.
But your robot didn't get the memo.
So when you ask "build me a screen", it gives you 2023's answer.
❌ It uses dead APIs.
❌ It picks deprecated libraries.
❌ It writes code that crashes on the latest Android.
This guide gives your robot a NOTEBOOK 📓
that you keep updating with the LATEST Android rules.
Every time you ask a question, it reads the notebook FIRST,
then answers using TODAY's truth — not yesterday's.
┌──────────────────────────────────────────┐
│ 1. Why your AI is wrong about Android │ ← The problem
│ 2. The 4 Pieces of the Brain │ ← What you'll build
│ 3. Build the Vault │ ← Folder of rules
│ 4. Connect Google's Official Skills │ ← Auto-updating docs
│ 5. Plug Into Obsidian │ ← See the brain
│ 6. Wire to Your AI Agent │ ← Claude / Codex / etc
│ 7. Teach It New Tricks │ ← Web Clipper magic
│ 8. Use It Daily │ ← Real examples
└──────────────────────────────────────────┘
Two reasons. Both fixable.
┌─────────────────────────────────────┐
│ │
AI brain │ 📚 trained on internet up to │
│ January 2025 │
│ │
└─────────────────────────────────────┘
│
│ then... silence.
│
┌─────────────────────────────────────┐
│ │
Android │ 🚀 released 14 new versions │
│ 📦 changed 200+ libraries │
│ ⚰️ killed 50+ APIs │
│ ✨ added Compose BOM 2026.04 │
│ │
└─────────────────────────────────────┘
Your AI doesn't know any of that. Period.
Your team uses: AI suggests:
───────────────── ──────────────
✅ Koin DI ❌ Hilt (because it's "more popular online")
✅ Material 3 stable ❌ Material 3 expressive (still alpha!)
✅ MVI for state ❌ Random mix of MVVM + Cubit + Redux
✅ Edge-to-edge enforced ❌ Old `setSystemUiVisibility` flags
AI doesn't know YOUR rules. It guesses from "what's popular on Stack Overflow".
┌─────────────────────────────────────────────────┐
│ │
│ 📁 A folder of markdown files │
│ = YOUR team's rules │
│ = LATEST Google standards │
│ = Code blueprints to copy from │
│ │
│ 🔌 Plugged into your AI via MCP │
│ = AI reads it BEFORE answering │
│ │
│ 🌱 Grows automatically │
│ = Web clipper saves new articles │
│ = AI extracts rules and updates the brain │
│ │
└─────────────────────────────────────────────────┘
That's it. That's the whole concept.
┌────────────────────────────────────────────────────────────────┐
│ │
│ 1. THE VAULT 📂 2. GOOGLE SKILLS 🤖 │
│ ═══════════════ ════════════════ │
│ YOUR rules OFFICIAL Android docs │
│ YOUR blueprints Auto-synced from Google's GitHub │
│ YOUR ingestion runbook Always up-to-date │
│ │
│ 3. OBSIDIAN 🟣 4. THE MCP BRIDGE 🔌 │
│ ════════════ ═══════════════ │
│ Visual graph viewer The "USB cable" between │
│ Web clipper inbox your folder and your AI agent │
│ Optional but powerful (Claude / Codex / Gemini / Cursor) │
│ │
└────────────────────────────────────────────────────────────────┘
They all sit in ONE folder. That folder is your AI's brain.
Let's break each one down 👇
A vault is just a folder of markdown files. Nothing fancy. Each file teaches the AI one thing.
your-android-brain/
│
├── rules/ ← HARD constraints. AI must obey.
│ ├── build_constraints.md ← AGP version, banned plugins, etc.
│ ├── ui_standards.md ← Material 3 only, edge-to-edge, etc.
│ └── architecture.md ← MVVM/MVI rules, layer boundaries
│
├── blueprints/ ← COPY-PASTE templates
│ ├── mvvm_state.md ← How to write a ViewModel
│ ├── room3_configuration.md ← How to set up Room 3
│ ├── koin_di.md ← How to wire DI
│ └── design_md_implementation.md ← How to enforce design tokens
│
├── workflows/ ← Runbooks for the AI to execute
│ └── ingest_docs.md ← "Read inbox/, extract rules"
│
├── inbox/ ← Web Clipper drops articles here
│ └── (empty — fills as you save Medium posts, Android docs)
│
├── archive/ ← Processed articles after ingestion
│
├── external_skills/ ← Google's official skills (Piece 2)
│ └── android-skills/
│
├── AGENTS.md ← Tells the AI HOW to navigate the vault
└── plugin_context.md ← Project-specific overrides
Just plain markdown. No magic format. Example:
# Build Constraints
## AGP Version
- USE: 9.2.0+
- BANNED: anything below 9.0
- WHY: 9.2 is required for Compose Compiler 2.1+
## Plugins
- USE: org.jetbrains.kotlin.android (declarative)
- BANNED: kotlin-android (legacy, removed in AGP 9)
## Firebase
- USE: firebase-bom + non-ktx artifacts (BoM 33.5.0+)
- BANNED: -ktx suffixed Firebase libs (deprecated 2024)That's it. The AI reads this, treats it as gospel, and stops suggesting old APIs.
┌──────────────────────────────────────────────────────────┐
│ │
│ 📌 STICKER: The Golden Rule │
│ │
│ "If a rule isn't written down, the AI will guess." │
│ │
│ Write it down. Once. Forever. │
│ │
└──────────────────────────────────────────────────────────┘
Google publishes official Android instruction sets as markdown on GitHub: 🔗 https://github.com/android/skills
These cover navigation, performance, UI patterns — straight from the Android team. Updated regularly.
You don't copy-paste. You use a Git submodule — a magic link that syncs the latest version automatically.
# From inside your vault folder:
git submodule add https://github.com/android/skills.git external_skills/android-skills
# Whenever Google updates them:
git submodule update --remote external_skills/android-skills┌────────────────────────────────────────────────────────────┐
│ │
│ 🍱 The Lunchbox Analogy │
│ │
│ Your vault = your lunchbox. │
│ Your rules = sandwiches you packed yourself. │
│ Google's skills = a daily fresh fruit Google mails you. │
│ │
│ You don't make the fruit. You don't update the fruit. │
│ You just open the lunchbox and it's there, fresh. │
│ │
└────────────────────────────────────────────────────────────┘
⚠️ Important: if you ever zip-download your vault instead of usinggit clone, the submodule folder will be EMPTY. The AI will then fail to find the skills. Always usegit clone --recursiveorgit submodule update --init.
Obsidian is a free app that opens any folder of markdown files as a visual graph.
┌─────────────────────────────────────────────────────────────┐
│ │
│ WITHOUT OBSIDIAN: │
│ 📂 Your vault is a flat folder of .md files. │
│ You scroll. You search. It's fine. │
│ │
│ WITH OBSIDIAN: │
│ 🌐 Your vault becomes a galaxy. │
│ Each note is a STAR. │
│ [[Links]] between notes are GLOWING LINES. │
│ You see how rules connect to blueprints │
│ connect to workflows. │
│ │
└─────────────────────────────────────────────────────────────┘
| Power | What it does | Why you care |
|---|---|---|
| 🌐 Graph View | Visualize all your notes as a connected web | See gaps in your knowledge instantly |
| ✂️ Web Clipper | Browser button → save any webpage as markdown | Capture an Android Dev blog in 1 click |
| 📥 Inbox + Properties | Tag clipped articles with status: unprocessed |
Lets the AI know what to ingest next |
- Install the Obsidian Web Clipper browser extension.
- Open the extension → Templates → Default.
- Set Folder =
inbox - Add a property: Name =
status, Value =unprocessed
Browser Your Vault
┌─────────────┐ ┌──────────────────┐
│ 📰 Medium │ │ │
│ article │ ─── click ───► │ inbox/ │
│ about new │ │ ├── article.md │
│ Compose │ │ │ status: │
│ APIs │ │ │ unprocessed│
└─────────────┘ │ └── ... │
└──────────────────┘
Now the article lives in your vault. Ready for the AI to learn from.
MCP = Model Context Protocol. It's the standard way modern AI agents read external data.
Think of MCP like USB. USB lets ANY printer talk to ANY computer. MCP lets ANY tool talk to ANY AI.
You don't need to write code. You use a pre-made server that just exposes your folder to the AI:
{
"mcpServers": {
"android-brain": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/absolute/path/to/your-android-brain"
]
}
}
}That's it. One JSON object. The AI now has read access to every file in the vault.
┌────────────────────────────────────────────────────────────┐
│ │
│ 📡 THE FLOW │
│ │
│ You type: "Build a User Profile screen" │
│ │ │
│ ▼ │
│ AI thinks: "Let me check the vault first." │
│ │ │
│ ▼ │
│ AI reads via MCP: │
│ • rules/architecture.md → "use MVVM" │
│ • blueprints/mvvm_state.md → "this is the template" │
│ • rules/build_constraints.md → "use AGP 9.2" │
│ • rules/ui_standards.md → "Material 3 stable only" │
│ │ │
│ ▼ │
│ AI writes code that obeys ALL your rules. ✨ │
│ │
└────────────────────────────────────────────────────────────┘
Setting up MCP configs by hand for 8 different AI editors is tedious. A CLI does it for you.
$ npx your-android-brain@latest
📥 Cloning vault repo... ✅
🔗 Fetching Google Android skills... ✅
📦 Installing dependencies... ✅
🔧 Auto-configuring AI agents:
├─ Claude Desktop ✅
├─ Claude Code ✅
├─ Gemini CLI ✅
└─ Codex (config.toml) ✅
🎉 Done! Restart your AI agents.
The CLI just edits each agent's MCP config file. Nothing scary. You can always do it manually too (next section).
Pick yours. Each one wants the MCP config in a slightly different place.
File: ~/.claude.json (or project-level .mcp.json)
{
"mcpServers": {
"android-brain": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/absolute/path/to/vault"]
}
}
}Restart Claude Code. Done.
File (macOS): ~/Library/Application Support/Claude/claude_desktop_config.json
File (Windows): %APPDATA%\Claude\claude_desktop_config.json
Same JSON as above. Restart the app.
File: ~/.gemini/settings.json
{
"mcpServers": {
"android-brain": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/absolute/path/to/vault"]
}
}
}💡 If you use Gemini inside Android Studio, this same config also wires the vault into Studio's AI panel.
File: ~/.codex/config.toml
[mcp_servers."android-brain"]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/absolute/path/to/vault"](TOML, not JSON — Codex is the odd one out.)
Antigravity reads from ~/.claude.json automatically. Same JSON as Claude Code. No extra step.
You can also add it to a project-level .mcp.json and Antigravity will pick that up too.
File: ~/.cursor/mcp.json (global) or .cursor/mcp.json (project)
{
"mcpServers": {
"android-brain": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/absolute/path/to/vault"]
}
}
}File: ~/.copilot/mcp-config.json
Same JSON as Claude Code.
They all read project-level AGENTS.md files and most support MCP via .mcp.json in the project root. Same JSON as Claude Code.
- Settings → Plugins → AI → MCP Servers
- Add Server (+)
- Name:
android-brain - Command:
npx - Args:
-y @modelcontextprotocol/server-filesystem /absolute/path/to/vault - Restart the AI Assistant.
┌──────────────────────────────────────────────────────────────┐
│ │
│ 🎁 STICKER: The Universal Truth │
│ │
│ Different agents. │
│ Different config files. │
│ SAME mcpServers JSON object inside. │
│ │
│ Learn it once. Paste it everywhere. │
│ │
└──────────────────────────────────────────────────────────────┘
Most modern AI agents look for a file called AGENTS.md at the root of any folder. It tells the AI how to navigate that folder.
# Android Engineering Routing Protocol
When the user asks for Android code, follow this sequence:
1. ALWAYS read `rules/` first. Treat as hard constraints.
2. CHECK `external_skills/android-skills/` for official Google guidance
on the topic (UI, performance, navigation, etc.).
3. PICK the matching blueprint from `blueprints/` and adapt it.
4. NEVER suggest a deprecated API — if `rules/build_constraints.md`
says it's banned, do not use it.
5. IF asked to learn something new, run `workflows/ingest_docs.md`
on the unprocessed files in `inbox/`.
When the user asks "what do you know about X?":
- Search rules/, blueprints/, and external_skills/ for X.
- Cite the exact file and line.
- If not found, say so. Do not hallucinate.This file is the AI's constitution. It's the first thing read.
This is where the magic compounds. Your brain teaches itself.
┌─────────────────────────────────────────────────────┐
│ │
│ THE INGESTION LOOP │
│ │
│ 1. You read a great Android article. 📰 │
│ 2. Click Web Clipper. ✂️ │
│ → article saved to inbox/ as .md │
│ → tagged status: unprocessed │
│ │
│ 3. You tell your AI: │
│ "Run workflows/ingest_docs.md on my inbox" │
│ │
│ 4. The AI does ALL of this autonomously: │
│ ├─ reads the article │
│ ├─ extracts the new rules │
│ ├─ updates rules/build_constraints.md or │
│ rules/ui_standards.md │
│ ├─ writes a new blueprint if needed │
│ ├─ moves the article to archive/ │
│ └─ marks status: processed │
│ │
│ 5. NEXT time you ask for code, │
│ it uses the new rule. AUTOMATICALLY. │
│ │
└─────────────────────────────────────────────────────┘
# Ingest Docs Runbook
For each file in `inbox/` with status: unprocessed:
1. Read the article.
2. Identify any:
- Hard rules (must do / must not do) → append to rules/
- Code patterns → save as a blueprint in blueprints/
- Deprecated APIs called out → add to rules/build_constraints.md
3. Add a one-line citation pointing back to the source URL.
4. Move the article to archive/.
5. Update its frontmatter: status: processed.
6. Print a summary of what was learned.That's it. 6 steps. The AI does the rest.
BEFORE AFTER
┌──────────────┐ ┌──────────────┐
│ Static docs │ │ LIVING docs │
│ that rot │ ──────► │ that grow │
│ as Android │ │ smarter with │
│ evolves │ │ every clip │
└──────────────┘ └──────────────┘
Copy-paste these. Replace your-android-brain with your actual folder name.
# 1. Create the vault
mkdir your-android-brain && cd your-android-brain
git init
# 2. Create the folder structure
mkdir rules blueprints workflows inbox archive external_skills
# 3. Add Google's official skills as a submodule
git submodule add https://github.com/android/skills.git external_skills/android-skills
# 4. Create your first rule
cat > rules/build_constraints.md << 'EOF'
# Build Constraints
- USE Android Gradle Plugin 9.2.0 or newer.
- BAN the legacy `kotlin-android` plugin.
- USE Compose BOM 2026.04.01 or newer.
- BAN -ktx Firebase artifacts; use BoM + base artifacts.
EOF
# 5. Create AGENTS.md
cat > AGENTS.md << 'EOF'
# Android Routing Protocol
1. Always read rules/ before suggesting code.
2. Check external_skills/android-skills/ for Google guidance.
3. Use blueprints/ as templates. Adapt to user's request.
4. NEVER suggest a banned API.
EOF
# 6. Wire to Claude Code (or your AI of choice)
cat > .mcp.json << 'EOF'
{
"mcpServers": {
"android-brain": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"."
]
}
}
}
EOF
# 7. Restart your AI agent. Done.💡 Replace
"."in the MCP args with the absolute path to your folder if you'll use the brain from outside this directory.
Don't want to copy-paste bash? Point any modern coding agent at this guide and ask it to scaffold everything for you. Works the same way in Claude Code, Antigravity, Codex, Gemini CLI, Cursor, Aider — anything with file-write + URL-fetch tools.
✅ Fetch this gist (WebFetch / built-in browser tool)
✅ Create the vault folder + subfolders
✅ Write rules/, blueprints/, AGENTS.md with sensible defaults
✅ Add Google's android/skills as a Git submodule
✅ Generate the MCP config in the format YOUR agent expects
(JSON for Claude/Cursor/Antigravity, TOML for Codex, etc.)
❌ Restart itself — MCP servers only load at agent startup.
After config is written, YOU must close & reopen the agent.
❌ Fill rules with YOUR team's specifics — defaults are
generic. You edit them, or use the ingestion workflow
(Web Clipper → inbox → AI extracts rules).
❌ Use the vault on its CURRENT turn — even after scaffolding,
the same session can't query via MCP. Only the NEXT session.
Open your AI agent inside your Android app folder and paste this:
"Read this gist:
https://gist.github.com/ashokvarmamatta/6ca09274c98ae37e89869f50cf7f9863Set up the vault as a sibling folder called
android-brain/next to my Android project. Addhttps://github.com/android/skillsas a Git submodule atexternal_skills/android-skills. Createrules/build_constraints.md,rules/ui_standards.md,rules/architecture.mdwith sensible defaults for AGP 9.2+, Compose BOM 2026.04+, and MVVM. WriteAGENTS.mdwith the routing protocol described in the gist.Then add the MCP config in the format my current agent expects — JSON for Claude/Antigravity/Cursor, TOML for Codex — pointing at the absolute path of the new vault folder. If you don't know which format, ask me."
| Agent | Config file the AI should write | Format |
|---|---|---|
| Claude Code | .mcp.json (project) or ~/.claude.json (global) |
JSON |
| Claude Desktop | ~/Library/Application Support/Claude/claude_desktop_config.json (mac) %APPDATA%\Claude\claude_desktop_config.json (win) |
JSON |
| Antigravity | ~/.claude.json (it reads Claude's config) or .mcp.json |
JSON |
| Cursor | .cursor/mcp.json (project) or ~/.cursor/mcp.json (global) |
JSON |
| Codex CLI | ~/.codex/config.toml |
TOML |
| Gemini CLI / Studio Gemini | ~/.gemini/settings.json |
JSON |
| GitHub Copilot CLI | ~/.copilot/mcp-config.json |
JSON |
| Aider / Droid / OpenCode / Trae | .mcp.json in project root |
JSON |
| Android Studio (UI) | Settings → Plugins → AI → MCP Servers (no file editing) | UI form |
💡 Tip: if your agent doesn't have a WebFetch tool (e.g. some Aider setups), download the gist as a
.mdfile and place it in your project. Then say "follow the guide inagentic-android-vault-guide.md".
After closing and reopening your agent, ask:
"What does my android-brain say about Compose BOM?"
✅ If it cites a specific file like rules/build_constraints.md → wired correctly
❌ If it gives a generic answer → MCP didn't connect:
→ Re-check the config path is ABSOLUTE (not relative)
→ Re-check you FULLY restarted (Codex/Cursor: kill the process)
→ For Codex: re-check it's TOML, not JSON
┌──────────────────────────────────────────────────────────────┐
│ │
│ ❌ DON'T nest the vault inside your Android app: │
│ │
│ MyAndroidApp/ │
│ ├── app/ │
│ ├── android-brain/ ← submodule inside app repo! │
│ │ └── external_skills/ ← messy, hard to share │
│ └── build.gradle.kts │
│ │
│ ✅ DO keep the vault as a SIBLING folder: │
│ │
│ ~/code/ │
│ ├── MyAndroidApp/ ← your app │
│ └── android-brain/ ← shared brain across apps │
│ │
│ Then point MCP at the absolute path of android-brain/. │
│ Same brain works for ALL your Android projects. │
│ │
└──────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────┐
│ │
│ 📌 STICKER: Pasting the gist ≠ Done │
│ │
│ The gist is the RECIPE. │
│ Your agent is the COOK. │
│ You still have to LET IT COOK (restart) │
│ before you can EAT (query the vault). │
│ │
└──────────────────────────────────────────────────┘
The biggest worry people have: "OK I built it once. Six months from now, won't it be stale just like the AI was?"
No — if you wire up the four update channels below. Each channel covers a different kind of staleness.
┌────────────────────────────────────────────────────────────────┐
│ │
│ 1. Google's docs change → Submodule auto-sync │
│ 2. New Android articles drop → Web Clipper → ingestion │
│ 3. Your team's rules evolve → Just edit rule files │
│ 4. Teammates contribute → Plain old git pull │
│ │
└────────────────────────────────────────────────────────────────┘
Let's break each one down 👇
The external_skills/android-skills/ folder is a Git submodule pointing at Google's repo. To pull the latest:
cd /path/to/android-brain
git submodule update --remote external_skills/android-skills
git add external_skills/android-skills
git commit -m "Sync Google android/skills to latest"Run that once a month. Done. You always have the freshest official Android guidance.
Google updates Your vault
┌────────────────────┐ ┌──────────────────┐
│ android/skills │ │ android-brain/ │
│ updated │ ──submodule──┤ ⤷ external_ │
│ (e.g. new │ update │ skills/ │
│ perf doc) │ --remote │ android- │
└────────────────────┘ │ skills/ │
└──────────────────┘
💡 Want this fully automatic? Add a cron job (mac/linux) or scheduled task (windows) that runs
git submodule update --remoteweekly. Or wire a GitHub Action on the vault repo.
This is where Obsidian earns its keep. Obsidian itself doesn't update anything — it's just a free markdown editor with a graph view. But its Web Clipper extension is the fastest way on the planet to capture knowledge into a vault.
┌──────────────────────────────────────────────────────┐
│ │
│ THE CLIPPER FLYWHEEL │
│ │
│ Day 1: Read Medium post on new Compose API. │
│ → Click Web Clipper. Saved to inbox/. │
│ │
│ Day 1: Tell your AI: "Run workflows/ingest_docs │
│ on inbox/." │
│ → AI extracts the rule. │
│ → Updates rules/ui_standards.md. │
│ → Archives the article. │
│ │
│ Day 30: New project. AI uses the new rule │
│ AUTOMATICALLY because it's in your vault. │
│ │
│ Compounds forever. │
│ │
└──────────────────────────────────────────────────────┘
One-time Obsidian setup:
- Install Obsidian (free).
- Open your vault folder (
File → Open vault → Open folder as vault). - Install the Web Clipper browser extension.
- In Clipper settings → Templates → Default:
- Folder:
inbox - Add property:
status=unprocessed
- Folder:
- Pin the Clipper button to your browser toolbar.
After that: every Android article → 1-click → into the vault. Every few weeks, tell your AI to ingest.
💡 Don't want to use Obsidian? Any browser → Save As → Web Page, Single File → save it into
inbox/works too. Or use SingleFile extension. The clipper just makes it 1-click instead of 3.
You learned a new gotcha in Compose? You don't need a workflow — just open rules/ui_standards.md in any editor and add a line.
# In Obsidian, VS Code, vim, anything:
echo "- AVOID derivedStateOf inside LazyColumn item — runs on every scroll" \
>> rules/ui_standards.mdSave it. Next session of any AI agent on any project, that rule is enforced.
Push the vault to GitHub (private repo if you want). Each teammate:
git clone --recursive https://github.com/yourteam/android-brain.git
# wire it to their AI agent (one of the configs from earlier)Now whenever anyone updates a rule:
git pull --recurse-submodulesEveryone's AI gets smarter at the same time. Shared institutional memory.
┌────────────────────────────────────────────────────────┐
│ │
│ 👤 Alice clips a new Compose article. │
│ → ingestion workflow → updates rules/. │
│ → git push. │
│ │
│ 👤 Bob runs git pull next morning. │
│ → His AI now knows the new rule too. │
│ │
│ 👤 Carol joins the team. │
│ → git clone → wire MCP → instant senior context. │
│ │
└────────────────────────────────────────────────────────┘
| Update channel | Automatic? | How often |
|---|---|---|
| Google android/skills (submodule) | ✅ Auto on demand (git submodule update --remote) |
Weekly via cron, or whenever you remember |
| Web Clipper → inbox | ✋ You click the button | Whenever you read something good |
| Inbox → rules (ingestion) | ✋ You tell AI to run the workflow | Every few weeks, batch-process |
| Manual rule edits | ✋ You edit the file | Whenever you learn something |
| Team sync | ✅ Auto via git pull |
Every morning |
┌──────────────────────────────────────────────────────┐
│ │
│ 📌 STICKER: The Brain Compounds │
│ │
│ Build it once. │
│ Add 1 article a week. │
│ In 1 year you have 50+ rules │
│ that NO AI in the world has out-of-the-box. │
│ │
│ That's your moat. │
│ │
└──────────────────────────────────────────────────────┘
Obsidian's hidden superpowers (if you do use it)
You don't NEED Obsidian, but it has 3 features that make maintaining the vault much nicer:
| Feature | What it does | Why it helps update workflow |
|---|---|---|
| 🌐 Graph View | Shows ALL notes as connected dots | Spot orphan rules → know what's missing |
| 🔗 Backlinks Pane | "What links here?" sidebar | See where a rule is referenced before editing it |
| 🏷️ Properties / Dataview | Frontmatter status: unprocessed becomes filterable |
Query inbox: "show me everything not yet ingested" |
| 🎨 Canvas | Drag-and-drop visual layout | Plan a new blueprint by laying out connected concepts |
| 🔌 Plugins | Templater, QuickAdd, Periodic Notes | Generate scaffolds for new rules in 1 click |
Obsidian's role in 1 sentence:
────────────────────────────────────────────
It doesn't update anything for you.
It makes updating SO EASY you actually do it.
Open your AI agent (Claude Code, Antigravity, Codex, whatever) and try:
"Based on my Android brain's rules and blueprints, build me a User Profile screen using MVVM."
The AI should:
- Read
rules/architecture.md→ confirm MVVM - Read
blueprints/mvvm_state.md→ use the template - Read
rules/build_constraints.md→ use modern APIs only - Generate code that obeys ALL of it.
If you see references to your files in the response, it's working.
┌─────────────────────────────────────────────────────────────────┐
│ │
│ WITHOUT a brain WITH a brain │
│ ═════════════════ ═══════════════ │
│ │
│ ❌ Suggests deprecated APIs ✅ Uses today's APIs only │
│ ❌ Mixes random patterns ✅ Obeys YOUR architecture │
│ ❌ No memory of team standards ✅ Knows every team rule │
│ ❌ Hallucinates package names ✅ Cites exact file & line │
│ ❌ Same answer every project ✅ Tailored per project │
│ ❌ Stops learning ✅ Grows with every article │
│ │
└─────────────────────────────────────────────────────────────────┘
No. Obsidian is optional. You can use any markdown editor — VS Code works fine. Obsidian shines when you want the visual graph + web clipper inbox. The AI doesn't care what you use to edit.
Yes, mostly. The AI agent itself needs internet for inference, but the MCP filesystem server runs locally. Your vault is local. Your rules are local. No API calls leave your machine.
The MCP filesystem server handles thousands of files without issue. The bottleneck is the AI's context window, not your folder size. Keep individual files under ~1000 lines for best results.
Yes. Push the vault to GitHub (private or public). Each teammate clones it. They all wire it to their AI agents. One source of truth. When someone updates a rule, everyone gets it on next pull.
Same approach. Different rules. Replace rules/build_constraints.md (Android) with rules/swift_concurrency.md (iOS) or rules/typescript_strict.md (web). The pattern is universal.
CLAUDE.md is loaded into context on every turn — burns tokens. A vault is read on demand via MCP — only when relevant. Bigger vault, lower cost.
Yes. Each gets its own entry in mcpServers:
{
"mcpServers": {
"android-brain": { "command": "npx", "args": [...] },
"design-system-brain": { "command": "npx", "args": [...] },
"team-runbooks": { "command": "npx", "args": [...] }
}
}The AI sees all three.
Ask: "What does my vault say about Compose BOM?"
If it cites your file: ✅ If it gives a generic answer: ❌ — the MCP server isn't connected.
| Problem | Fix |
|---|---|
| AI ignores the vault | Restart the agent — MCP loads at startup only |
external_skills/ is empty |
You used "Download ZIP". Re-clone with git clone --recursive or run git submodule update --init |
| MCP server "not found" | Run npx -y @modelcontextprotocol/server-filesystem --help to verify it installs |
| Path errors on Windows | Use forward slashes in JSON: "D:/projects/your-brain" (not backslashes) |
| AI cites OLD rules after edit | The vault is read fresh per-query, but some agents cache. Start a new chat. |
| Web Clipper saves to wrong folder | Re-check Templates → Default → Folder = inbox |
┌────────────────────────────────────────────────────────────────────┐
│ │
│ YOUR DAILY ANDROID WORKFLOW │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
│ │ Read new │────►│ Web │────►│ inbox/ │ │
│ │ Android │ │ Clipper │ │ status: │ │
│ │ article │ │ saves it │ │ unprocessed │ │
│ └──────────┘ └──────────┘ └──────┬───────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ AI runs │ │
│ │ ingest_docs │ │
│ │ workflow │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌────────────────┼─────────────────┐ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌────────────┐ ┌──────────┐ │
│ │ rules/ │ │ blueprints/│ │ archive/ │ │
│ │ updated │ │ updated │ │ moved │ │
│ └──────────────┘ └────────────┘ └──────────┘ │
│ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
│ │ Google's android/skills │ │
│ │ (auto-synced submodule) │ │
│ └────────────┬─────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
│ │ MCP filesystem server │ │
│ │ exposes the vault │ │
│ └────────────┬─────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
│ │ Your AI Agent │ │
│ │ Claude / Codex / Gemini │ │
│ │ Antigravity / Cursor │ │
│ └────────────┬─────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────┐ │
│ │ Code that uses TODAY's │ │
│ │ Android — not 2023's │ │
│ └──────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────┐
│ │
│ 📌 STICKER: The One Sentence Summary │
│ │
│ "Stop trying to make AI smarter. │
│ Make AI's WORKSPACE smarter." │
│ │
│ Curated rules + auto-synced docs + MCP plug. │
│ That's the whole game. │
│ │
└──────────────────────────────────────────────────────────┘
