The Problem Nobody Talks About
Most people using AI today are stuck in a strange loop. Every conversation starts from zero. You explain the project. You explain your preferences. You paste the same context you pasted last week. The AI produces something reasonable, you correct it, and by tomorrow those corrections are gone.
Now scale that to a team — or to multiple AI agents working in parallel on the same codebase. Suddenly everyone is relearning the same lessons. The knowledge lives in your head, in scattered Notion pages, in Slack threads nobody reads. The AI is technically brilliant and practically forgetful.
I spent a long time treating this as a prompting problem. It isn't. It's an infrastructure problem.
The Shift: Treat Your AI Setup Like a System
The mental model I landed on is simple: stop thinking about individual prompts, and start thinking about the workspace your AI lives in. A good workspace has memory, reusable playbooks, automated behaviors, and clear boundaries for when multiple workers collaborate.
That's the whole idea behind the setup I'll describe below. It isn't exotic. It doesn't require new tooling. It's mostly about deciding, once, where knowledge lives — and then letting both humans and AI contribute to the same place.
The Four Layers
Here's the architecture in plain terms. Four layers, each doing one job.
1. Memory — the shared brain
At the base sits a persistent, file-based memory the AI can read and write on its own. Not a vector database, not a RAG pipeline — just structured markdown files with an index on top.
What goes in it:
- Who you are — role, preferences, how you like to work
- Project state — what you're building, current decisions, deadlines
- Feedback — corrections the AI received, with the why behind them
- References — pointers to external systems (Linear, dashboards, repos)
The key rule: the memory is an index of small, focused files, not one giant brain dump. Each entry is semantic (by topic, not date), short, and updatable. When something becomes wrong or stale, you delete it. This keeps the signal high and prevents the classic AI failure mode of confidently citing outdated truth.
2. Skills — reusable playbooks
Above memory sit skills — named capabilities the AI pulls in on demand. Think of each skill as a tightly-scoped expert colleague: one for brainstorming, one for frontend work, one for debugging, one for code review, one for writing specs.
A skill isn't a prompt. It's a procedure with a trigger condition and a checklist. When the AI starts a task, it checks which skills apply and loads them before taking action. This replaces the "just be smart about it" approach with a predictable workflow — the same way a senior engineer follows a checklist when cutting a release, even though they technically know the steps.
The payoff: consistency across sessions. The same task, approached the same way, producing the same quality floor.
3. Hooks — automation at the edges
Hooks are the quiet layer. They run automatically at session boundaries: when a new conversation starts, when a tool runs, when you stop working. You don't think about them day-to-day, but they do the invisible plumbing.
Examples from my own setup:
- On session start, load the memory index and today's date
- Before a risky command runs, pause for confirmation
- On session end, flush anything worth remembering back into memory
Hooks turn one-off behaviors into policy. "Always do X before Y" stops being a thing you nag the AI about and starts being a property of the environment.
4. Agents and worktrees — parallel silos with a shared brain
The fourth layer is where it gets interesting. I run multiple agents in parallel — sometimes a main thread working with me, sometimes a background agent exploring a codebase, sometimes a subagent doing a focused research task inside its own git worktree.
Each agent operates in isolation. They don't share a conversation. They don't see each other's scratch work. But they all read from — and contribute back to — the same memory.
This is the architectural piece that makes the whole thing worth building. A human developer can work on a feature branch; when they merge, their learnings flow back into the shared knowledge base. An AI agent can do the same. A subagent dispatched to audit skills, review code, or investigate a bug writes its findings to a place the next session can read. No one silo owns the truth.
The Loop That Makes It Self-Improving
Once the four layers are in place, something subtle happens. The system starts getting better without anyone explicitly improving it.
Here's the loop:
- I ask the AI to do something.
- It uses its current memory + skills to attempt it.
- If I correct it, that correction — with the why — becomes a new memory.
- If it succeeds at something non-obvious, that also becomes a memory.
- Next time, the starting point is higher.
Multiply that across hundreds of sessions, across multiple agents, across multiple humans, and you end up with a workspace whose collective competence compounds. The AI I worked with six months ago and the AI I work with today are technically the same model — but the workspace around it has quietly absorbed a year of lessons.
This is what people mean, or should mean, when they talk about "self-improving AI." Not the model getting smarter. The environment getting richer.
What Actually Changed for Me
A few honest observations after running this setup for months:
- I stopped repeating myself. Preferences I mentioned once ("no pricing on the landing page", "use CSS variables so components are theme-switchable") stick. Future sessions already know.
- New work starts from context, not from scratch. When I open a new session to build a feature, the AI already knows the stack, the design language, the constraints, and which skills to pull in.
- Agents feel like teammates, not tools. A dispatched subagent can investigate something while I keep working, and its findings land somewhere I can act on. That's a different relationship than "I ask, it answers."
- Corrections compound. The most valuable entries in memory aren't facts — they're feedback with reasoning. "Don't do X because last quarter Y broke" survives across sessions in a way no prompt ever could.
It isn't magic. It's just that the default way people use AI throws away 95% of what they teach it. This setup keeps it.
How to Start Small
You don't need my exact stack to get most of the value. Three steps, in order:
- Pick one place for persistent context. A single markdown file your AI reads at the start of every session is enough to begin. Put your role, your project, and five things you've had to explain twice.
- Write down corrections as rules, not moments. When you correct the AI, don't just fix the output — capture the rule and why it exists. That's the unit that compounds.
- Separate playbooks from prompts. When you notice yourself giving the same procedural instructions repeatedly ("always do X before Y, then check Z"), that's a skill waiting to be extracted. Pull it out of your conversation and into a reusable file.
Do those three things and you'll already be ahead of almost everyone shipping with AI today. The full four-layer architecture is just what happens when you keep pulling on that thread.
The Bigger Point
The interesting frontier isn't which model is a few points smarter on a benchmark. It's how well the environment around the model captures, preserves, and redistributes knowledge — across sessions, across agents, across the humans on the team.
Treat that environment as a first-class system. Give it memory, playbooks, automation, and clear boundaries between parallel workers. Let corrections flow back into it. Let agents contribute to it the same way humans do.
Do that, and the AI stops being a chat window you talk to. It becomes a workspace you build on.
That's the shift worth making.