Every time I come back to a project after a few days, I notice the same thing
The AI tools I’m using — assistants, windsurf, copilots, agents — feel… dumb again.
Not because they’re bad.
Not because the models aren’t powerful.
But because they’ve forgotten everything.
What the app does.
Why certain decisions were made.
What’s in scope, what’s out of scope.
What “done” actually means.
So I re-explain.
Again.
And again.
That’s when it clicked for me: this isn’t a prompting problem — it’s a context problem.
The Real Problem: Context Lives in Your Head
When you’re deep in a project, context is everywhere:
- In your head
- In Slack threads
- In commit messages
- In half-finished READMEs
- In conversations that never got written down
Humans carry that context naturally. AI doesn’t.
So every time you:
- come back to a repo after a week,
- hand the project to another developer,
- spin up an AI agent,
- or restart a workflow…
Everything starts cold.
We keep trying to fix this with:
- better prompts
- longer system messages
- massive README files
- “memory” hacks
But those are all workarounds.
The Shift: Context Is Infrastructure
At some point I stopped asking:
“How do I prompt this better?”
And started asking:
“Why isn’t context treated like part of the runtime?”
We version code.
We version schemas.
We version configs.
But the why — the intent, constraints, decisions, and mental model of the app — disappears.
That’s backwards.
Context isn’t documentation.
It’s not prompts.
It’s not AI memory magic.
It’s infrastructure.
What App Context Is (and What It’s Not)
That’s why I built App Context.
App Context preserves runtime context so AI tools — and developers — don’t start cold.
It’s a small Node.js package that gives your application a structured place to store:
- what the app is
- what it’s trying to do
- what decisions have already been made
- what constraints exist
- how different parts of the system relate
And just as importantly: what not to do.
What it’s not:
- It’s not an agent
- It’s not an LLM wrapper
- It doesn’t generate text
- It doesn’t make decisions
It does one thing well:
It keeps your app’s context alive over time.
Why This Matters Now
This problem didn’t matter as much before.
But now we’re building:
- long-running agents
- AI-assisted development workflows
- autonomous scripts
- systems that hand work back and forth between humans and machines
In those systems, losing context isn’t just annoying — it’s expensive.
Cold starts mean:
- repeated explanations
- inconsistent outputs
- agents drifting off-task
- developers re-learning their own system
The more “agentic” our tools become, the more dangerous context loss becomes.
A Simple Mental Model
Think of it like this:
Your code explains how things work.
Your data explains what exists.
App Context explains why.
And “why” is the first thing humans ask — and the first thing AI lacks.
This Isn’t About Hype
I didn’t build App Context to chase trends.
I built it because I was tired of:
- re-explaining my own apps
- watching AI tools miss obvious constraints
- feeling like every session reset progress
This is a foundational layer — not a flashy one.
The kind of thing you add once, and quietly depend on forever.
The Bigger Idea
Long-term, I think this is where AI tooling is heading:
Not smarter models.
Not bigger prompts.
But systems that remember what they’re doing — and why.
Context shouldn’t live in someone’s head.
It should live with the app.
If you want to check out App Context, it’s available on npm.
If you don’t — that’s fine too.
The bigger takeaway is this:
If your AI feels dumb, it’s probably not the model.
It’s starting cold.
Try my new npmjs package: @contextlab/app-context
https://www.npmjs.com/package/@contextlab/app-context