I Built a Claude Cowork Loop That Improves Itself. Here's the Exact Setup.
A Karpathy-inspired self-improving loop, rebuilt for Cowork's visual interface. No terminal. No code. Just compounding workflows.
TL;DR
A self-improving loop in Cowork is a recurring task that rewrites its own execution instructions after every run. Three components: a context.md file, folder instructions, and an explicit Self-Improvement Directive. A no-code auto-research loop — same pattern Karpathy open-sourced in March 2026, rebuilt for Cowork's visual interface. Set it up once. Quality compounds across runs. After 20-30 runs, context.md becomes a playbook Claude wrote for itself. Claude Code intimidating? You don't need it.
This guide is the full architecture, the setup, the Reflection Skill, and the guardrails, written for AI builders who want compounding workflows without a terminal.
By the end, you’ll be running a self-improving loop I built on top of Karpathy’s Auto-Research Pattern, adapted for Cowork.
So even if Claude Code feels intimidating, you’re covered.
Hey, I’m Karo 🤗
I’m an AI Product Manager and builder. I write Product with Attitude, a newsletter about building with AI and developing critical AI literacy through practice.
If you’re new here, welcome!
Here’s what you might have missed:
→ Claude Cowork Guide for Power Users (2026)
→ Claude Skills Are Taking the AI Community by Storm
Join 17K readers and learn AI the only way it sticks: through immersion in real experiments and real projects.
What’s Inside
How to turn Anthropic’s Claude Cowork into a self-improving AI agent
Step-by-step tutorial from project creation to a running automation loop
Ready-to-use prompts and a complete Reflection Skill
An evaluation rubric so you know the loop is improving, not just changing
Risks, guardrails, and what happens after 20-30 runs.
AI Prompts & Skill Decay: The Problem Self-Improving Loops Fix
A workflow could sit at half its potential for months and we’d never know because we stopped looking.
Every AI workflow decays.
We set up an AI workflow. It works beautifully at first.
Then the world around it changes: files move, naming conventions change, things get re-organized, new edge cases pile up.
The instructions stay frozen. Our needs don’t.
The conventional fix would be to open the prompt or Skill, read through it, edit it, test it again. Rinse, repeat, lose a chunk of our busy week to maintenance.
And it has a blind spot:
we only improve what we've already seen go wrong.
New inputs, new edge cases, new failure modes, those slip through.
A self-improving loop changes that. It makes improvement part of the task, not something you remember to do when things go wrong.
What a Self-Improving Loop Is
A self-improving loop is a recurring task that rewrites its own execution instructions after every run.
Three components have to work together:
1. A context.md file - the evolving brain of the task
2. Folder instructions that tell Claude to read context.md at the start of every run
3. A Self-Improvement Directive inside context.md that tells Claude to update itself when the task finishes.
Without the directive, you don't have a loop. You have a recurring task.
With it, every run reviews what worked, rewrites the rules in-place, and logs the change. The next run starts from a sharper instruction set. Quality compounds.
This is the same pattern Karpathy open-sourced in March 2026 — adapted for Cowork instead of a code repository.
Claude Cowork vs Claude Code: Two Paths To The Same Pattern
Both Claude Code and Cowork support self-improving loops, but the implementation is different.
The Code path wins on depth of the optimization system. The Cowork path wins on accessibility. If “self-improving AI workflow without a terminal” describes what you need, this is the tutorial.
This guide covers the Cowork path exclusively: no terminal, no code repository.
And it requires only three things working together:
The Cowork Self-Improving Loop vs. the Karpathy Loop
This idea isn’t new.
Developers have been building self-improving AI loops in code-heavy tools for months, with Andrej Karpathy’s autoresearch loop going viral.
Karpathy's setup requires a terminal, scripting, and a Git repository. The agent edits training code, runs experiments, scores results, keeps what works.
What I’m proposing achieves the same result in Cowork, via a visual interface and one command. No code, no terminal.
Premium members get the complete playbook:
- the full architecture diagram,
- step-by-step setup
- the Reflection Skill that makes improvement passes surgical,
- my real before/after context.md showing 10 runs of evolution,
- the evaluation rubric that measures whether the loop is working,
- and a guardrail system that prevents instruction drift.
The Full Architecture
Each cycle tightens the Execution Instructions toward our specific workflow. Not a generic template.
After 10+ runs, context.md contains a playbook Claude wrote for itself.
Here is how every piece connects: