I have a button on my laptop. I press it, walk away, and come back to a finished piece of work.
The button lives on a small web page I built. It’s connected to my issue tracker on one side and an AI coding agent on the other. I click it on a task I’ve been putting off — “add multi-select to the products page,” “fix the timezone bug in exports” — and an agent disappears into a sandbox on my computer, reads the task, writes the code, opens a pull request, and tags me to review it.
I don’t hover over it. I make coffee, take a break, do something else. By the time I’m back, the work is sitting there waiting for review like any PR from a teammate.
The first time it worked end-to-end, I just stared at the screen for a minute. Something had taken a task I was dreading and handled it the way I would have.
I’ve shipped dozens of tickets this way now. It keeps getting better. Here’s the story — and then the setup.
Why I built it
Half the time, I’m effectively a one-person engineering team. My bottleneck isn’t ideas. It’s execution bandwidth. The backlog grows faster than I can clear it.
Most AI tools I tried wanted to sit inside my editor and have conversations with me. That’s useful for bigger architectural questions, but for the endless stream of “rename this,” “fix this bug,” “update this flow,” I don’t really want a discussion. I want the task handled.
What I wanted was something closer to delegation.
I also didn’t want to constantly think about usage meters or surprise invoices. I wanted a setup that felt local, predictable, and entirely under my control.
So I built one.
What it feels like to use
The interface is simple: three columns — To Do, In Progress, Done.
The To Do column pulls tickets directly from my tracker. Every card has a button labeled cook.
I scan the board, pick a task, and click it.
The card moves into In Progress. A fresh isolated environment spins up, the agent reads the issue, explores the codebase, makes changes, runs tests, and opens a pull request on its own.
There’s a logs view if I want to watch it work — scrolling reasoning steps, file edits, commit messages, decisions. Honestly, it’s hard not to watch sometimes.
If the ticket is vague, there’s a “polish” step where I tighten up the requirements with the agent before sending it off. And once the PR is open, I can leave follow-up comments directly on the task card — “rename this too,” “update the tests,” “handle this edge case” — and it picks up where it left off.
When the PR gets merged, the card automatically moves to Done. The board stays synced with reality.
The part that changed everything
It remembers.
After every completed task, the agent writes a short summary: what changed, why it changed, and anything worth remembering later. Those summaries get stored as markdown notes in a local knowledge base.
The next time I send off a task, the system searches through those notes and surfaces relevant context automatically.
“Here’s how this module was handled last month.”
“Here’s the tradeoff you made before.”
“Here’s why this weird edge case exists.”
By the tenth task, the system had context from the previous nine. By the twentieth, it was referencing decisions I’d forgotten I made.
The effect is subtle but powerful: every completed task improves the next one.
At some point it stopped feeling like “an AI tool” and started feeling more like working with someone who already understands the project.
How to build one
The whole setup is surprisingly lightweight.
You need:
- A way to spin up isolated environments
- An autonomous coding agent
- GitHub access for branches and PRs
- A small web app as the dispatcher
- A local knowledge base
- A search layer over that knowledge
That’s basically it.
My setup uses OrbStack, a lightweight local cluster, Codex CLI for autonomous execution, a tiny Python dispatcher app, markdown-based memory files, and Qdrant for semantic search.
The important part isn’t the exact stack though. The important part is the loop:
- Pick a task
- Hand it off
- Review the result
- Store what was learned
- Reuse that context later
Everything else is implementation detail.
What I like most about it
Nothing here feels fragile or over-engineered.
The memory layer is just markdown files.
The state is mostly SQLite.
The UI is simple.
The workflows are understandable.
No giant SaaS dependency chain. No proprietary “AI workspace.” No mystery black box holding the project hostage.
Just local tools stitched together carefully.
Where this goes
Right now it’s just me: one laptop, one backlog, one button.
But it’s easy to imagine this pattern scaling beyond an individual workflow. A small team could have shared memory, shared context, shared accumulated decisions — every completed task making the next session more informed.
The longer the system exists, the more context it carries forward.
For now, though, it’s simple.
I press a button.
I walk away.
I come back to a pull request.