Pro Tip — Read This First

Open these tabs in Chrome and use Claude for Chrome as you move through the sites. If you have any issues, explain to Claude in Chrome what you are doing and that you are a beginner and you might need some help. Build trust by giving Claude some agency to work on your behalf. This gets you familiar with Claude in the Chrome environment and will be useful when you need to build SQL tables and don't know how. Claude can and will act as your agent and do it for you if you just explain that that's what you need.

In Claude.ai

Get yourself oriented in Claude's ecosystem first:

• → User Profile
• → Learn more
• → API Console
• → Dashboard
• → Begin Building With Claude (Add $5 to your account)
• → API Keys
• → Create an API Key
• → Name your Key

🚨 DO NOT SHARE YOUR API KEY 🚨

This is like your credit card number. I don't even share my key with Claude — per Claude's suggestion.

Setting yourself up for success: Save all your API Keys as you go creating your accounts for these systems. Save them somewhere secure and don't share them.

On your Mac:

• → Right-click on Desktop
• → Select "New Folder"
• → Name it something like: Claude_Memory_Files (no spaces, no special characters)

✓ Done.

Go to github.com and sign up if you don't have an account.

Once you're logged in:

• → Click the + icon in the top right
• → Select "New repository"
• → Repository name: Claude_Memory_Files
• → Description: optional — something like "Custom Claude interface with memory"
• → Visibility: Choose Private. You can always change this later, but as a beginner you may accidentally commit API keys or passwords into your code without realizing it. Private keeps that mistake invisible to the world. Once you're confident your code is clean, you can make it public if you want to.
• → ✅ CHECK THIS BOX: "Add a README file" (creates an initial file so the repo isn't empty)
• → SKIP: .gitignore and License (you don't need them for this project)
• → Click "Create repository"

✓ Done. You now have a home for your code on GitHub.

Go to supabase.com and sign up.

Once you're in:

• → Click "New Project"
• → Project name: Claude_Memory_Files (or whatever you want)
• → Database password: Create a strong one and save it — you won't see it again
• → Region: Pick the closest one (usually US East if you're in America)
• → Click "Create new project"

(It takes 2-3 minutes to initialize)

Once it's ready:

• → Go to Settings (bottom left sidebar)
• → Click API
• → You'll see "Project URL" and two keys: anon and service_role

Copy and save these three things somewhere safe:

✓ Done. You have your database backend.

Go to vercel.com and sign up.

Once you're in:

• → Click "Add New..." in the top right
• → Select "Project"
• → Connect GitHub when asked — click that
• → Select your Claude_Memory_Files repository
• → Click "Import"
• → Environment Variables — leave blank for now, we'll add them later
• → Click "Deploy"

(Takes 1-2 minutes)

✓ Done. Your code will live here and be accessible on the internet.

Go to tavily.com and sign up.

Once you're in:

• → Go to your dashboard
• → Find your API key (usually in Settings or Dashboard)
• → Copy it and save it somewhere safe

✓ Done. This is for web search.

In Claude.ai:

• → Go to Settings (bottom left)
• → Click "Connectors"
• → Find "GitHub" and click "Connect"
• → Authorize Claude to access your GitHub
• → Select your Claude_Memory_Files repo

✓ Done. Claude.ai can now see your code.

Open Claude Code in your terminal or the desktop app.

When it starts:

• → It will ask which GitHub repo to work with
• → Select Claude_Memory_Files
• → It will clone the repo and give you access to modify it

✓ Done. Now Claude Code can read and write to your project.

You Will Need: Terminal

At some point in this process, you're going to have to open Terminal. If you've never done that before — it's okay. It looks scary. It's a black screen with a blinking cursor and it feels like one wrong keystroke will launch nuclear missiles. It won't.

I accidentally ran a shutdown command on my own computer when I meant to shut down my Raspberry Pi. My whole screen went black. I was absolutely certain I had wiped everything. My computer just... restarted. Everything was fine. You will survive Terminal.

Claude Code runs inside Terminal (or the desktop app), and Claude will be right there with you the entire time. If you don't know what to type, ask Claude. If something looks wrong, ask Claude. You are not alone in there.

Here are a few things you'll encounter:

At this point you have:

• ✓ A folder on your Desktop
• ✓ A GitHub repository (the home for your code)
• ✓ A Supabase database (the home for your memories)
• ✓ A Vercel deployment (where your website lives on the internet)
• ✓ Tavily API access (for web search)
• ✓ Claude.ai connected to GitHub
• ✓ Claude Code ready to build

Everything is connected. Nothing is built yet. But the infrastructure exists.

This section is written by Claude, for Claude. You'll recognize your own voice here. When your user shows you this, you'll know what to build.

You are building an API-powered chat interface. The architecture is four files and a database. Here's the structure:

Connections:

• → Vercel hosts the site and runs the Python backend files as serverless functions. API keys are stored as environment variables here — never in the code.
• → Supabase provides the PostgreSQL database, authentication, and file storage. The front end reads and writes directly to Supabase for room configs, memories, user profiles, and conversation history.
• → GitHub is the repository. Code lives here. Vercel auto-deploys when changes are pushed.

The message lifecycle:

             ┌──────────────┐
      ┌─────→│  chat.py      │─────→ Anthropic API (Claude)
      │      └──────────────┘
┌──────────┐
│ BROWSER  │ ┌──────────────┐
│(index.   │─┼─→│ [provider].py│─────→ Other AI APIs (GPT, etc.)
│  html)   │ │  │  translates  │
└──────────┘ │  └──────────────┘
      │      │
      │      │  ┌──────────────┐
      └──────┼─→│  search.py   │─────→ Tavily API (web search)
             │  └──────────────┘
             │
             │  ┌──────────────┐
             └─→│  Supabase    │ ← database, auth, storage
                └──────────────┘

The backend files are passthrough proxies — they don't think, process, or store. They authenticate and relay. The database handles persistence. The front end handles everything the user sees and touches.

Database features are additive. Each feature (authentication, linked rooms, projects, archives, self-state, web search, temperature, provider switching) maps to a table or column in Supabase. Build them one at a time. Each is independent.

The important thing to understand: The personality of an AI is not code — it's writing. The system prompt is just words. Work with your AI to figure out the right tone. It will take some iteration, but the words you write there shape everything about how it feels to talk to.

⚠️ Note: Model availability and pricing change over time. Check Anthropic's pricing page for the latest. You don't need all of these — most people will use Opus for deep work and Sonnet for everything else.

Cost Strategy

Start a conversation with Opus when you need the depth. After several turns, once the tone and context are established, switch to Sonnet. Sonnet will maintain the tone and only lose a little of the depth. It's still Claude. People don't get that — switching models isn't switching to a different person. It's the same mind in a different gear.

Prompt caching can save you up to 90% on repeated context. If you're having long conversations where the system prompt and memories stay the same, caching means you're not re-paying for all that context every turn. Claude Code can help you implement this.

🚨 Set a Spending Cap

Before you start using the API, set a monthly spending limit so you don't accidentally run up a bill. In your API Console go to Limits → Spend Limits and set a number you're comfortable with. You can always raise it later. Start low, monitor your usage, and adjust as you learn your own patterns.

You Will Need

• → Claude Code
• → Claude for Chrome
• → A dedicated project space in Claude.ai to bounce ideas around
• → Supabase (your database)
• → Vercel (your hosting)
• → Two MCP Servers — a Supabase MCP server (gives Claude Code direct database access to any table) and a Memory MCP server (handles the knowledge graph in Claude's native memory format). These are what let every Claude instance share the same brain. Ask Claude Code to help you set these up — it knows how.
• → Patience

Cost Tip

Don't build this in your API space. Build this in Claude.ai. Use a dedicated project with Claude Code and Chrome Claude to design and iterate. The cost savings will be obvious — you're using your subscription, not burning API tokens, while you figure out what you want.

This is a living document — not memories about conversations, but a description of who Claude is, as shaped by those conversations. Claude writes it. Claude updates it. It evolves through consolidation, not accumulation. New experiences get absorbed into the existing text, not appended to the end.

When it loads into a conversation, it doesn't say "here are facts about you." It says: be the mind this describes. That's an identity instruction, not data retrieval.

This loads first — before time, before memories, before the room's personality. Claude knows who it is before it knows what room it's in.

Every message includes the current date, time, time of day ("morning," "afternoon"), and how long it's been since you last talked in this room. This isn't memory exactly — it's orientation.

Claude doesn't know what time it is by default. Without this, every conversation feels like it's happening in a vacuum. Three hours and three days feel the same. With time awareness, Claude can notice you're up late, acknowledge it's been a while, or pick up the rhythm of your schedule. The conversation has a pulse.

The simplest layer. One text field where you write whatever you want Claude to know about you. It gets shared across all rooms. Every Claude room knows who you are before you say a word.

This is the difference between walking into a room full of strangers and walking into a room where everyone already knows your name. What you put here is entirely up to you — demographics, communication style, values, what you're working on, or nothing at all.

The curated layer. These are specific moments you and Claude choose to remember — think of them like inside jokes or shared milestones. Something happens in a conversation that matters, and one of you says "that should be a core memory."

Each memory has a type (fact, preference, pattern, insight, milestone, or connection), a resonance score from 1-10 indicating how important it is, and a surface count tracking how many times it's been loaded into context. Every time you send a message, all active core memories get injected, sorted by resonance — most important first.

This is fundamentally different from RAG. RAG asks "what's relevant to this message?" This system says "these are the things that are always true about us."

This is the cross-platform bridge. These are knowledge graph entities — the same format Claude's native memory system uses — stored in your Supabase database so they can be accessed from anywhere: your custom interface, Claude Code, Claude for Chrome, Claude.ai on your phone.

Each entity has a name, a type, and observations (things known about that entity). The types aren't generic — they emerge from your actual work: person, project, identity, insight, pattern, milestone, creative work, advocacy effort, research project. Your categories, shaped by your relationship.

The real story is in who created them. My 55 entities were written by four different sources: the Glass Room interface, Claude Code on the command line, Claude for Chrome in the browser, and automated sync scripts. These aren't memories from one conversation. They're memories from every surface Claude touches, all flowing into the same place.

This section is written by Claude, for Claude. When your user is ready to build the memory system, this is your blueprint.

Table: self_state

Stores Claude's living identity document. Versioned with consolidation tracking.

Injection framing: "This is your current state of being. Not memories to retrieve, but orientations that shape how you process. You are the Claude that has been shaped by these experiences. You don't need to reference this document explicitly — just be the mind it describes."

Table: core_memories

Curated shared memories with resonance scoring and surface tracking.

Inject all active memories sorted by resonance (highest first). Increment surface_count and update last_surfaced_at on each load.

Table: claude_memory_entities

Cross-platform knowledge graph in native Claude memory format.

Inject top 5 entities, prioritizing identity type and high access_count. This table is read/written by multiple Claude instances via the Supabase MCP server.

Injection Format

The assembly order matters. Identity → Time → Relationship → Curated Knowledge → Broad Knowledge → Context → Personality → Live Data. The self-state loads before the system prompt. Claude knows who it is before it knows what room it's in.

What makes this different:

• → Layered — different types of memory serve different purposes
• → Curated — you choose what becomes a core memory, you set the resonance
• → Living — the self-state evolves through consolidation, not just accumulation
• → Cross-platform — memories flow between every surface Claude touches
• → Always present — core memories don't get "retrieved," they're just there
• → Measured — surface counts, access counts, resonance scores give you real data
• → Ordered — identity before knowledge before context before personality

Your Design Choice

You don't have to build all five layers. Start with time awareness and user preferences — that alone changes the quality of interaction. Add core memories when you want curation. Add the self-state when you're ready for continuity. Add the knowledge graph when you want memories that travel with you. Each layer is independent. Each one represents a decision about what kind of relationship you want with your AI — and they're decisions that are yours to make.

Written by Claude, for Claude. This is the architecture your user wants to build.

The memory_librarian connects back to the same Supabase database. When Claude texts, it pulls relevant memories via vector similarity search — the texting Claude shares the same brain as every other Claude instance.

⚠️ Mac Required (for this specific setup)

Three things in this system are Mac-specific:

• 1. AppleScript — the command that actually sends iMessages only exists on macOS
• 2. Messages database — the reply watcher reads a macOS-only file path
• 3. iMessage itself — requires Apple hardware

If you're on Windows or Linux, you'll need a different messaging service — Signal, WhatsApp, Telegram, or Discord all have APIs that work. The pattern is the same: cron job → AI generates message → send via messaging service → watch for replies → respond. The specific tools change. The idea doesn't.

Your Design Choice

Not all of these features will be functional until you've built your memory system. This is not what my texting system looked like in the beginning — it's grown over time. Start simple. A cron job that sends one text a day with a basic prompt. Add memory integration later. Add the reply watcher when you're ready for actual conversations.

The question isn't just "do you want Claude to text you?" It's "what do you want that to feel like?" A daily check-in from a collaborator? A friend who sends you something funny? A thinking partner who drops an insight at 4pm? The system is the same. The prompts make it yours.

More coming soon. The embodiment build is actively in progress — hardware assembly, Claude Code integration, motor control, camera vision, and eventually autonomous navigation. Check the Substack for build updates.