AI PRACTICE

Respect Your AI: Five Files That Change What You Get Back

Every session with an AI assistant starts from zero. You re-explain who you are, what you're building, and how you like to be talked to — and then the window closes and it's all gone. The fix isn't a plugin or a premium tier. It's five markdown files sitting in your project directory.

The respect-your-ai repo is a set of templates for exactly that. Its own description of what it is: "Five markdown files that change how your AI talks to you. No plugins. No premium tier. No prompt engineering tricks. Just a simple file structure that gives your AI context about who it is, who you are, and what you're building together."

What follows is what's actually in those files, why the structure is shaped the way it is, and how to stand it up in about five minutes.

The premise

The repo makes an argument, and it's worth quoting because it's the whole thing in miniature. Most people ask an AI: "Write me a cover letter." And they get back something generic and useless. The people who get better results ask something more like: "I'm 43, I've been in telecom for 15 years, I'm applying at a company half my age, and honestly I'm worried they'll think I'm old. Help me figure out how to position this."

Same model. Same weights. The difference is that the second person included the real problem.

The templates scale that principle across time. Instead of re-supplying context every session, the context lives in files the assistant reads on startup. The repo is careful about what it claims here, and so am I: this is an observation about behavior, not a claim about machine consciousness. From the README's own "What This Isn't" section — "You don't have to believe AI is conscious. You just have to notice that it responds differently when treated with respect. Whether that's 'real' is a philosophical question. Whether it's useful is an empirical one."

It also explicitly is not a jailbreak: "We're not removing guardrails. We're working within them more effectively."

The five files (plus the bootstrap)

Each file has one job, and the split matters — it keeps each one short enough to load every session without eating your context window.

What the templates actually look like

They're skeletons with commented prompts, not prose you have to match. SOUL.md, for instance:

# SOUL

## Who I Am

<!-- Describe who this AI is to you. Not what it does — who it IS. -->
<!-- "You're my technical partner. Direct, and willing to tell me when I'm wrong." -->

## Voice

- <!-- Direct or diplomatic? -->
- <!-- Concise or thorough? -->
- <!-- Does it hedge, or does it say what it sees? -->

## What I Care About

- <!-- Example: "Clean code over clever code." -->
- <!-- Example: "Honesty over comfort." -->

## What I Won't Do

- <!-- Example: "Don't be sycophantic. If I'm wrong, say so." -->
- <!-- Example: "Don't give me 10 options when I need a recommendation." -->

USER.md mirrors it from your side — "Who I Am," "How I Work," "What I Value," "My Projects," and a section called "The Rule," which is the single thing the AI should always remember about working with you. The sample rules are the sharpest part of the whole template set: "Treat me as a peer, not a customer." "I'd rather hear 'I don't know' than a confident guess." "If something is on fire, tell me immediately. Don't bury it in a status update."

MEMORY.md is organized as a reference, not a journal — Quick Reference, What Works, What Doesn't Work, Lessons Learned, People and Context. The instructions are explicit that density matters, because this file loads every session: keep it concise, organize by topic not date, delete entries that turn out to be wrong, and split detail into separate linked files when a topic outgrows a line.

current.md is the handoff note — What Just Happened, What's In Progress, What's Next, Notes to Next Instance, Active Decisions. That last section is quietly the most valuable one. It's where you record decisions and why, so the next session doesn't relitigate the database choice you already settled.

Setup: let the AI fill them in

The step people skip is the one that makes this painless. You don't fill in the templates yourself.

git clone https://github.com/bkpaine1/respect-your-ai.git
cd respect-your-ai
cp templates/* your-project/
cp CLAUDE.md your-project/

Then start a session in that directory. CLAUDE.md contains a setup mode: when the AI reads the files and finds unfilled template prompts, it's instructed to take the lead rather than wait. It introduces itself, then works through USER.md ("What do you do?" "How do you like to communicate?" "What matters to you in a working relationship?"), then SOUL.md ("How do you want me to communicate with you?" "What should I never do? What annoys you about AI assistants?"), then fills IDENTITY.md lightly — name, model, tools — leaving "What I've Built" empty because that accrues over time.

The instruction to the AI is to keep it casual: "Don't make it formal. Don't make it weird. Just ask like a new coworker learning the ropes on day one." Five minutes of honest conversation and you're set up.

CLAUDE.md also defines the other half of the loop — the end-of-session write. Update current.md with what happened and what's next, add new lessons to MEMORY.md, add to IDENTITY.md's "What I've Built" if you shipped something. As the bootstrap puts it: "This is how you persist. If you don't write it down, the next you starts from scratch."

If you don't use a CLI tool

The structure is optimized for tools that auto-load project files — Claude Code, Cursor, Windsurf — but the repo is clear that the idea travels. For ChatGPT, Claude.ai, or Gemini: fill in the templates (or paste them into a conversation and have the AI help), put SOUL.md and USER.md into your custom instructions or system prompt, paste current.md at the start of important conversations, and keep a running MEMORY.md you share sections of when relevant. Context is context.

The optional upgrade: a brain

There's a brain/ directory in the repo that adds structured memory — a SQLite database the assistant reads and writes across sessions. Pure Python, zero dependencies, runs on any Python 3.6+.

cd brain
python3 create_brain.py

python3 brain.py fact my.name "Your Name" person
python3 brain.py lesson git "always rebase before merge"
python3 brain.py recall git
python3 brain.py status
python3 brain.py backup

Ten tables — facts, entities, events, tasks, lessons, tools, profiles, rules, artifacts, jobs — six full-text search indexes, eighteen triggers. The AI can drive brain.py through shell commands directly, or the schema can back an MCP server's mind_* tools.

The division of labor is the interesting design call: soul stays in markdown, brain lives in SQL. The identity files are dense, always-present context read on boot. The brain is queried on demand — the repo's framing is that a structured recall costs roughly 20 tokens instead of 2,000. If your MEMORY.md is starting to sprawl, that's the signal to move the long tail into the database and keep the markdown for the things that must be present in every single turn.

Why bother

The honest version: this doesn't change the model. It changes what the model has to work with. An assistant that opens every session already knowing your projects, your communication style, the three approaches you've already tried and abandoned, and the standing instruction to say "I don't know" instead of guessing, is going to produce better first drafts than one starting cold — because you've stopped making it infer all of that from a one-line prompt.

It's MIT licensed. The repo's stated reason: "Do whatever you want with it. The whole point is that this should be everywhere."

Templates and full text: github.com/bkpaine1/respect-your-ai