When context starts working against you

I was in the permissions system of a product I maintain. It was not a fire. It made sense to restructure a couple of pieces and, while there, adjust some tables. The work, at first, was simple.

I took Grill.me. I talked about this a few weeks ago: you can go skim it. I sat down with the agent. An hour answering questions. The map came together. When it felt enough, I let it work.

When I came back to review the implementation, one specific part was right. The rest, halfway. Not because the code was wrong. Because the vision from the start was gone.

The conversation had grown on its own. I answered a question. The agent read three files. A test failed. It retried. It asked for another clarification. Each turn adds. At some point that pile stopped fitting in what the model sees.

The context of a conversation is not the disk. It is a window. The recent comes in. The earlier drops off. I do not fully know how these tools trim internally. I spent a while reading. The feeling was concrete. The agent was no longer loading the original plan. It solved what was in front of it. The rest fell off.

That is not a detail of how much text fits. It is the working model. If the session is the memory, when it fills up, the memory gets trimmed. And what gets trimmed first is not the last file. It is the agreement from the start.

It was not the dump from Anti-Cliché: average code that still compiles. It was losing the map.

Putting more information in the same conversation looks like the obvious move. You just spent an hour making the map explicit. Why not let the agent continue there?

Because you stay in the thread that is about to get trimmed. Grill.me is for discovery. It is not memory for a three-hour implementation. If the same conversation carries discovery and close, the second eats the first. The agent does not get dumb. It gets local.

The other reflex is not wanting to throw the hour away. The answers are in that thread. Opening another conversation feels like starting over. So you do not open one. The hour is not saved. It thins out.

The way out was frustrating. It was also the one that worked. I took what Grill.me had pulled out and dropped it into a Markdown plan: a text file with phases and steps, outside the chat.

# Permissions

## Phase 1: the base
1. Who belongs to the project
2. What each role can do

## Phase 2: the console
3. The actions that say no
4. The reads that hide what you cannot see

## Phase 3: the rest
5. API keys
6. Internal jobs

That is not the whole plan. Mine ended in three phases and twenty-five, twenty-seven steps. The block is the tell: the map no longer lives in the conversation. It lives in a file.

From there I opened agent conversations in parallel and assigned each one a phase. Each loaded the Markdown and its slice. None had to drag the hour of questions, or the retries from the one next door. After a couple of iterations, the integration closed.

Grill.me first. The plan in writing after. One phase per agent. Do not reload the whole history in every conversation. If a phase depends on another, the Markdown says so, not the previous chat.

What you write into each new conversation is short. The plan file. The phase number. And the border:

Read permisos-plan.md.
You are phase 2. Do not touch phase 1 or phase 3.
If something from another phase blocks you, stop and write it down.

That changes what you do the day the “simple” work starts to grow. You do not ask the same thread to remember hour one. You give each agent a concrete objective and a file that does not get compressed.

It does not replace Grill.me. Without the hour of questions, the Markdown would have been an empty list. Discovery is still discovery. What it cannot be is the memory of the implementation.

And it does not yet prove AI loops: letting the agent continue on its own, at intervals, on a long task. I am going to try it. I want to see if it actually holds consistency and direction when the work grows, or if it only lengthens the same conversation until it gets trimmed again.

More context does not necessarily produce better results. At a certain point, the same conversation that helped you discover is the one that keeps you from closing.

Until loops prove otherwise, the move is that: split the work, write the stages, give each agent a concrete objective. The map comes from Grill.me. The close does not fit in the same thread.