← Back to blog

Stop Packing Your Whole Life Into Every AI Session

Personal context should not be trapped in one tool or dumped wholesale into every AI session. The useful primitive is projection: source context shaped for the room, the harness, the privacy boundary, and the cost.

Every useful interaction with AI begins with the same ritual:

You explain who you are and what you’re working on. You explain what matters, what tools to use, and what boundaries to respect. You hand over the background, the constraints, writing or code style preferences, recent decisions, and the weird project-specific one-offs that keep the AI from spitting out generic boilerplate.

Then, a few days later, you do it again.

This is one of the stranger frictions in how we use AI right now. We have systems that can reason across huge amounts of text, write code, summarize documents, plan projects, and help us think. But when we move between tools, tasks, devices, projects, or sessions, it’s Groundhog Day.

The obvious answer is memory. Lots of start-ups are getting VC billions to work on AI memory. The model and agent labs are shaping their own approaches to it, but those come with strong opinions and incentives that aren’t necessarily compatible with mine: optionality, privacy, sovereignty. They’re certainly not trying to make it easy to leave or use other tools.

So like a lot of engineers, I’m evolving my own setup as I work with these tools. The switching cost is essentially zero now if you’re careful not to get too attached to proprietary enticements.

But memory by itself is not enough. Not every task needs your life history. Not every tool should receive the same background. A coding agent, a writing surface, a research assistant, a calendar helper, and a business planning system may all benefit from knowing something about how you think and work. They do not need the same context, at the same level of detail, for the same reasons.

The useful future is not one giant AI memory that knows everything about you. The useful future is portable personal context that you can project into the right situation.

The metaphor I keep coming back to is a backpack and a room. Your personal context is the backpack. It contains things like your work style, goals, constraints, preferences, background, active projects, operating principles, and accumulated decisions. Some of that material is public. Some is fine to share with trusted tools. Some is private. Some should almost never leave your control.

A task, project, meeting, or AI-assisted work session is a room. The room has its own purpose, and it already has materials on the table: documents, code, tickets, notes, timelines, rules, people, obligations, and decisions.

When you enter a room, you do not dump your whole backpack onto the table. You unpack the parts that belong there.

That’s context projection.

In practice, context projection is choosing the right subset of background for the job. It means asking practical questions:

  • Who or what is receiving this context?
  • What are we trying to do?
  • What does this specific tool need to know?
  • What should stay private?
  • What information is fresh enough to trust?
  • Which source should be trusted if two notes disagree?
  • What evidence should exist showing what was shared?

That sounds more formal than it needs to. The everyday version is simple: the context should fit the work.

If I’m using an AI coding agent, it helps for the agent to know how I like to work, how cautious it should be with edits, what repository it’s in, what tests matter, and what boundaries to respect. It doesn’t need the whole life story.

If I’m using an AI system to help shape an essay, it helps for it to know my voice, the intended audience, the privacy boundary, and the main idea I’m trying to clarify. It doesn’t need access to every operational note behind the idea.

If I’m asking for help planning a business offer, the useful context is different again: goals, audience, constraints, positioning, and the difference between private thinking and public language.

The same person. Different rooms. Different projections.

This matters more as AI work moves beyond one friendly text box.

I use a mix of AI and agent harnesses: coding agents, research tools, writing surfaces, local experiments, and my own workbench-style systems. Each one has different strengths, weaknesses, interfaces, and assumptions. I don’t want my personal context trapped inside any one of them.

So I manage my context outside the tools.

The source lives somewhere I can inspect and edit. From that source, I can create different projections for different harnesses and situations. One tool might receive a compact collaboration profile. Another might receive project-specific working rules. Another might receive public-safe writing context. Another might receive almost nothing, because sometimes the correct amount of personal context is “please just answer the question.”

If you like seeing the wires, a toy version might look something like this. Not an API. Just the shape of the thing:

context-kit/
  source/
    voice.md
    current-work.md
    boundaries.md
  projections/
    coding-agent.md
    writing-agent.md
  adapters/
    claude-code/CLAUDE.md
    antigravity/GEMINI.md
  render.mjs

And the glue is intentionally unimpressive:

import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { dirname } from "node:path";

const profiles = {
  "claude-code": {
    source: ["source/voice.md", "source/current-work.md", "source/boundaries.md"],
    output: "adapters/claude-code/CLAUDE.md",
    header: "# Context Projection for Claude Code\n\n",
  },
  "antigravity": {
    source: ["source/voice.md", "source/current-work.md"],
    output: "adapters/antigravity/GEMINI.md",
    header: "# Context Projection for Antigravity\n\n",
  },
};

const profile = profiles[process.argv[2]];
if (!profile) throw new Error("Usage: node render.mjs <claude-code|antigravity>");

const body = profile.source
  .map((path) => readFileSync(path, "utf8"))
  .join("\n\n---\n\n");

mkdirSync(dirname(profile.output), { recursive: true });
writeFileSync(profile.output, profile.header + body);

Different harnesses want context in different shapes. Claude Code might get a CLAUDE.md. Antigravity might get a GEMINI.md. A future tool might get an MCP resource. The point is not the file name. The point is that the AI tool is not the source of truth. It receives a projection.

This shape now exists as a public DYFJ example: the solo-operator context kit. Context kits, skills, workflows, MCP surfaces, whatever the final packaging turns out to be. The primitive still matters before the packaging does.

The important part is not my exact setup. Most people don’t need to keep context in source-controlled files or build their own agent harnesses. The important part is the primitive.

There should be a layer between your durable context and whichever AI system you happen to be using today. The harness isn’t the context; it’s just one place the context might be useful.

That layer keeps your context portable instead of trapping it inside a single vendor’s memory silo. It makes the system inspectable rather than magical. It lets you update the source when something changes instead of correcting the same stale assumption in five different text boxes like some cursed productivity ritual. And it helps decide whether a piece of context is worth paying to include at all.

This is the difference between memory and managed context.

Memory says: “The system knows something about me.”

Managed context says: “I have context I can maintain, revise, classify, and project into the right work.”

That distinction sounds small. I think it is load-bearing.

Without it, we drift toward a few bad defaults.

Sometimes it’s amnesia: every interaction starts from scratch, and we waste energy restating the basics.

Other times it’s oversharing: we let a tool accumulate whatever it can, whenever it can, then hope it uses that material appropriately later. Data hoarding.

Then there’s the bill. Context isn’t free. The more background you drag into every request, the more tokens you burn. That’s a nuisance for one person experimenting with tools, and a lot more when teams start running agentic workflows all day. Context efficiency is going to be one of the disciplines that keeps AI work from becoming absurdly expensive.

And eventually it’s context rot: old decisions, stale preferences, abandoned project details, and tool-specific residue hanging around in the working set. The model may technically have the right fact somewhere in the window, but it has to dig it out from under everything else we piled on. Bigger context windows don’t magically fix that. At some point extra context stops being helpful background and starts competing with the signal. It’s hard to find the screwdriver in the kitchen junk drawer.

None of those defaults is good enough for serious work.

The better path is deliberate context. Not a giant prompt or a mystical memory blob, but a living set of source material that can be shaped into the right projection for the work at hand.

This is useful for individuals, but the same pattern applies to teams and small businesses.

A business has context too: how it works, who does what, what customers expect, what promises have been made, what constraints matter, what history should not be forgotten. If that context only lives in scattered documents, old messages, and a few people’s heads, AI tools can help only so much. They can answer questions, but they cannot reliably participate in the work.

For AI to become genuinely useful in real organizations, it needs access to the right operating context under the right boundaries. Otherwise it is mostly a very articulate visitor wandering around without a map.

That doesn’t mean every system should see everything. It means the organization needs a way to know what context exists, which parts should be trusted, which parts are private, and which parts can be projected into a specific task.

The same backpack and room metaphor still works. The backpack may belong to a person, a team, or a company. The room may be a project, a meeting, an incident, a customer support ticket, a software release, or a writing workflow. The work is deciding what gets unpacked.

I suspect this will become one of the practical literacies of working with AI.

We’ll need to learn how to maintain our context, not just how to prompt. We’ll need to know how to separate private source material from public language. We’ll need to know how to give tools enough background to be useful without handing every room the keys to the basement.

The goal is not to make AI more intimate. It’s to make it more situated.

When a tool has no context, it guesses. When it has too much unbounded context, it may overreach, lose the important bit in the pile, or just burn money carrying around material it didn’t need. When it has the right projected context, it can help with the work in front of it.

That is the shape I want: less reintroducing myself, less dumping everything into the nearest input field, more deliberate unpacking.

Context you maintain compounds. Context you retype just costs you again.

We don’t need AI to remember our entire lives. We need it to know what room it’s standing in.