I used to think the problem was my prompts.
Every time an LLM lost track of what I was building mid-session, I'd rewrite the prompt. Add more detail. Be more specific about the architecture. Paste more code. The model would snap back on track — for a while — and then drift again.
After months of this, I finally diagnosed the real problem: I was prompting when I should have been looping.
The difference nobody talks about
Prompting is a one-shot act. You write a request, get a response, and start fresh next time. The model has no memory of what came before unless you manually re-paste it. Every new conversation is a blank slate.
Looping is a different mental model entirely. Instead of treating each request as isolated, you maintain a persistent, structured snapshot of your project that travels with every context window. The model isn't starting from zero — it's continuing from a known state.
That distinction sounds small. It isn't.
Why prompting alone breaks at scale
Here's a scenario most of you have hit:
You start a session, paste your codebase overview, explain the architecture
The model gives great answers for 20 minutes
Context fills up. You start a new session.
You forget to re-explain something. The model suggests a refactor that conflicts with a decision you made two sessions ago.
You spend 15 minutes debugging something that wasn't broken — you just lost state.
This is context drift. And no prompt, however well-crafted, fully solves it. Because prompting is fighting the symptom. The disease is that there's no single source of truth the model can always reference.
Looping: what it actually means
Looping means your project has a living document — call it a snapshot, a context file, a manifest — that gets updated as the project evolves and is automatically included whenever you start an AI session.
Instead of asking:
"Here's my project, it does X, the architecture is Y, now help me with Z"
You just ask:
"Help me with Z"
Because the model already knows X and Y. They're in the loop.
The loop is closed. Context is continuous. Drift disappears.
This is what I built TokenCap to solve
TokenCap is an open-source CLI + VS Code extension that generates a TOKENCAP.md — a clean, AI-optimized snapshot of your entire codebase.
It's your looping artifact. One file. Every AI tool reads it. You attach it once per session and stop re-explaining your architecture from scratch.
But the original TokenCap was still prompt-adjacent: it gave you better input for your prompt. The snapshot was static. Useful, but not truly looping.
TokenCap v1.3.0 — The Task Intelligence Layer
This is where v1.3.0 changes everything.
v1.3.0 ships the Task Intelligence Layer — the first version of TokenCap that doesn't just snapshot what your code is, but tracks what you're doing with it.
Here's what's new:
🔁 Task-Aware Snapshots
TOKENCAP.md now includes an active task context block — what you're currently building, what decisions have been made, and what's in-progress. When you start a new AI session, the model knows not just your architecture, but your intent.
Active Task Context
Current task: Refactor auth middleware to support OAuth2
Status: In progress
Last decision: Using passport-oauth2, rejected node-oauth2-server (too low-level)
Blockers: None
Next steps: Wire up callback route, write integration test
🔂 Session Continuity Blocks
Between sessions, TokenCap generates a continuity block — a brief structured summary of what happened, what changed, and where you left off. It's appended to your TOKENCAP.md automatically. No manual note-taking.
📋 Decision Logging
Every significant architectural decision you flag during a session gets captured as a structured entry. Future sessions (and future teammates) can see why something was built the way it was, not just how.
🔃 Loop Mode (CLI)
bashtokencap --loop
Loop Mode keeps TOKENCAP.md in sync in the background as you work. File changes, new decisions, task completions — the snapshot stays current without you lifting a finger.
The mental model shift
Here's the clearest way I can put it:
PromptingLoopingYou explain context every sessionContext travels with youModel starts fresh each timeModel continues from known stateDrift is inevitableDrift is structurally preventedBetter prompts = marginal gainsBetter loops = compounding gains
Prompting is a skill. Looping is infrastructure.
You can keep getting better at prompting. Or you can stop losing state between sessions entirely.
Try it
bashnpm install -g tokencap
tokencap
The CLI works with any codebase. The VS Code extension generates and updates your TOKENCAP.md from inside the editor. Both are free and open source.
v1.3.0 is launching soon. If you want to be part of the early access, drop a comment or find me on GitHub.
npm: npmjs.com/package/tokencap
If this resonated — or if you've been fighting context drift in your own workflow — I'd genuinely love to hear how you've been handling it. What's your current strategy between AI sessions?
Top comments (0)