Teaching your AI to teach itself
Despite all the doom and gloom you hear about AI being the end of software development as we know it, the engineers at Keel3 are actually having a blast. Every day, somebody on the team has taught their AI how to do something wild. Our Slack channel is constantly pinging with the engineer’s version of “show-and-tell” – everybody wants to show off their new tricks.
I’d known one of our engineers was working on something pretty technical. He’d been quiet on the Slack channel recently. I sat down with him the other day and asked him to walk me through what he’d been doing. It turns out he’s basically created ambient memory for his entire work process.
Our engineer stopped working inside his tools
What does that mean? It means that rather than working in specific tools like Claude Code or Codex, he works inside a memory system he built himself that the tools flow through. Every action he takes – his prompts, what his agents do, the artifacts he creates – all get captured and replayed into whatever task he opens next. When he opens a new browser or starts a new session with his memory system, it already knows what he’s working on and how he likes his options presented. When the same pattern recurs often enough, the system builds itself a skill for it. If he corrects the skill once, the prompt rewrites itself.
His agent has learned, for example, to offer him three options instead of one whenever it needs more guidance. And it now defaults to using the specific research tool he prefers. He didn’t tell the system to do this. It noticed on its own.
And it’s not just us at Keel3. I just watched this Y Combinator making the same argument at company scale about how to build an entire self-improving company with AI. So now we’re working to take the ambient memory our Keel3 engineer built for himself and thinking through how to extrapolate it to an operating system for our whole company that continues to self-improve. Here’s the future-state enterprise-wide concept we’re playing with:
How it actually works
For anyone interested in a little more detail on how our engineer’s ambient memory system works, here are the basic five steps:
Work happens. Email, Slack, Twitter bookmarks, the terminal, pull requests, customer signals. The normal mess of an engineer's day.
Hooks capture. Every time he presses enter on a prompt, a hook fires. Every tool call the agent makes, every response, every artifact. And we aren’t burning tokens unnecessarily to do this step. This logging of the JSON is performed by plain code – not AI.
Memory forms. A background process reads the buffer, extracts patterns, decisions, and current state, and writes them into a graph of markdown files at the root of his laptop. Stale nodes decay into an archive. He caps the total size on purpose, so the system actually has to choose what matters.
Skills emerge. When the same pattern recurs often enough, a skill gets written. He doesn’t have to configure this or build the skill. The system just notices on its own.
A cockpit governs. A small local dashboard tells him when any of the background jobs failed. He never has to worry if the memory has silently stopped updating.
‘Heads-up’ innovating
None of this came from a roadmap or a vendor pitch. One of our engineers got curious, started capturing his own work, and let the patterns do the teaching. That's the exciting part. The engineers who are able to spend ‘heads-up’ time on how AI can help us build tools that make their own work compound. We're still early on in turning one person's setup into something the whole company runs on, but the path is already there. It started with somebody deciding to teach his AI how he actually works, and then getting out of the way while it learned the rest.