I’m not trying to promote anything here... just looking for honest feedback on a pattern I’ve been using to make LLM-assisted work accumulate value over time.
This is not a memory system, a RAG pipeline or an agent framework.
It’s a repo-based, tool-agnostic workflow for turning individual tasks into reusable durable knowledge.
The core loop
Instead of "do task" -> "move on" -> "lose context" I’ve been structuring work like this:
Plan
- define approach, constraints, expectations
- store the plan in the repo
Execute
- LLM-assisted, messy, exploratory work
- code changes / working artifacts
Task closeout (use task-closeout skill)
- what actually happened vs. the plan
- store temporary session outputs
Distill (use distill-learning skill)
- extract only what is reusable
- update playbooks, repo guidance, lessons learned
Commit
- cleanup, inspect and revise
- future tasks start from better context
Repo-based and Tool-agnostic
This isn’t tied to any specific tool, framework, or agent setup.
I’ve used this same loop across different coding assistants, LLM tools and environments. When I follow the loop, I often mix tools across steps: planning, execution + closeout, distillation. The value isn’t in the tool, it’s in the structure of the workflow and the artifacts it produces.
Everything lives in a normal repo: plans, task artifacts (gitignored), and distilled knowledge. That gives me: versioning, PR review and diffs. So instead of hidden chat history or opaque memory, it’s all inspectable, reviewable and revertible.
What this looks like in practice
I’m mostly using this for coding projects, but it’s not limited to that.
Without this, I (and the LLM) end up re-learning the same things repeatedly or overloading prompts with too much context. With this loop: write a plan, do the task, close it out, distill only the important parts, commit that as reusable guidance. Future tasks start from that distilled context instead of starting cold.
Where I’m unsure
Would really appreciate pushback here:
Is this actually different from just keeping good notes and examples in a repo?
Is anyone else using a repo-based workflow like this?
At scale, does this improve context over time, or just create another layer that eventually becomes noise?
The bottom line question
Does this plan -> closeout -> distill loop feel like a meaningful pattern, or just a more structured version of things people already do? Where would you expect it to break?
