Stop prompting. Start conversations with your agent.

You have a folder. Somewhere in your repo or your notes app there is a growing pile of prompt templates: the system snippet, the codebase preamble, the style rules, the "always run tests before committing" reminder you paste in because the last agent forgot. Every session starts with the same ritual — copy, paste, re-explain, restate, and hope nothing drifts by turn ten. And every time the pile grows, it feels like progress. It is not. It is a symptom.

I ran that ritual for months. We stopped in December 2025, when our own agents started running with a memory system behind them — the same one we now ship as brethof-brain. Since then, not a single pasted preamble. This is what the shift actually looks like, including the part nobody tells you: the first week, when you drop the templates, is uncomfortable, and here is exactly how it goes wrong.

Why prompts can never be good enough

A prompt is a one-shot brief for a stateless session. That is the structural problem, not a skill problem. The rules that should hold forever — how commits are worded, which tests matter, what was already tried and rejected — get re-argued from zero every time you open a new session. So you write the prompt longer. Then it hits the point where the agent skims it, or the task drowns the rules, or the session drifts anyway and you start over.

The fix is not better prompt-writing. It is taking two jobs out of the prompt entirely:

1. Standing rules that bind every session automatically. Written once, loaded with almost every message, never re-pasted.
2. A brief composed before each prompt from whatever in the memory bears on what you are asking right now.

Once those exist, the prompt only has to carry the task. Everything else is already there when the agent answers. A prompt was never meant to be a memory; it was just doing the job because there was nothing else to.

What conversation looks like instead

The difference is easiest to see on a Tuesday morning. I open a session and type "continue" — and it is. The agent has the notes from where the last session stopped and the next lines of the project plan, so it picks up mid-task. No recap, no "here's the codebase structure", no five-bullet orientation message I used to spend the first ten minutes of every session writing.

The second difference shows up when I want a change. Instead of a template, it is a sentence: "the deploy script should always run the migration check first." Said once, deliberately, and it is a rule from then on — I have never restated it since. When a prompt touches a rule, the rule arrives with the prompt; I am not trusting the agent to remember, the briefing happens before it starts answering.

The third is the one that saves real money in tokens and real minutes in patience: the agent stops re-proposing things I already killed. The record that replaced the old idea arrives with the prompt, and when it digs, the rejection itself is there with its date and my reasoning. Nobody argues with a decision I made in March for the fourth time.

That is what "conversation" means here. Not chat for its own sake — it means the prompt stopped being a brief, because the brief is composed for it, every time, automatically.

What breaks when you first drop the templates

Here is the honest part, because the first week taught us more than the months since.

You reach for the preamble out of habit. The first few sessions after dropping the templates feel loose. Something is missing and you cannot name it, so you paste the old preamble "just in case." It was dead weight by then; the standing rules covered it. The habit broke around session five.

Rules need writing down once, deliberately. The memory does not read your mind. The stuff in your old templates — the conventions, the tone, the never-do-this list — has to be stated as rules, on purpose, once. If you skip this step and expect osmosis, you will have a bad first day and blame the wrong thing. Budget an hour.

Rules can rot into a junk drawer if you let them. We watched ours creep: near-twins, a stale one from a finished project, one that had grown into three paragraphs. This is why ours are capped at 1,000 characters each, and the memory points out twins and says when the rules are getting big — it never edits or deletes them for you. You do not need our caps, but you need some discipline: when two rules say the same thing, merge them.

Memory is not instant. An exchange becomes a record after the conversation settles, not the second you say it — the memory reads in windows, so it keeps what the conversation settled rather than every half-thought. The failure mode is saying something in session three, assuming it is now canon, and being surprised in session four. The fix: when it matters now, say it on purpose. When it matters eventually, let the curation catch it. Knowing which is which is most of the skill of talking to an agent that remembers.

How to make the switch

In order, runnable today:

1. Get the memory in place. Tell your agent: "install brethof-brain." That is the whole install — it fetches the client, wires the hooks, and checks its own work. You do the one human step: sign up, choose local or hosted, and approve the connection on brethof.ai when the installer asks.
2. Write your standing rules once. Empty your preamble folder into explicit rules before you delete it. General ones for everything; project-specific ones per project.
3. Stop pasting. Deliberately. Open the next session with just the task and see what the briefing already covers. You will find it covers more than you expected and misses exactly the things you never wrote down — which brings you to the test.
4. The test: whenever you catch yourself re-explaining something, that is not a prompt to write. It is a rule to save. Say "remember this" and move on.

The prompt pile was never a craft problem. It was a memory problem wearing a craft costume. Teach your agent once and stop gatekeeping it.

Disclosure: I build brethof-brain. How it works, in one page: https://brethof.ai/brain/how-it-works/