The Copilot Loop My agentic development framework.
A 7-phase methodology for building software with Claude Code — from idea to retrospective. Not a silver bullet. Not written by an AI expert. Just what works for me, refined through real use, and designed to evolve.
A note before we start. I'm not an AI expert or a methodology consultant. I'm a product owner who started using Claude Code and learning from it and wanted a structured way to work with it — so I built one. This framework is written from practice, not theory. It is incomplete, opinionated, and it will keep changing. That's the point.
How this framework was born.
The Copilot Loop didn't start as a framework. It started as frustration. I'd been exploring AI coding tools for months — first OpenAI's Codex, then Claude Code — and every time I sat down to build something, I felt like I was reinventing the wheel. No structure. No repeatable process. Just vibes and prompts.
I tried existing approaches. "Get Shit Done" was pragmatic but too big for a small start like mine. Spec-driven development had the right rigor but felt heavy for a solo developer working with an AI agent. Neither fit the way I actually work: fast iteration with clear quality gates, product thinking baked into every step, and a loop that improves itself over time.
From Codex to Claude Code
I started with OpenAI's Codex — impressive for content generation, but limited in code, context and tooling. When I switched to Claude Code, something clicked. A terminal agent that reads files, runs commands, uses git, and understands project context. It felt like working with a colleague, not a chatbot.
Testing other frameworks
"Get Shit Done" was the first framework I tried seriously — action-oriented, not that minimal ceremonies, but very straightforward. Then spec-driven development, which brought structure but too much upfront documentation for a fast-moving project. Both taught me something: I needed a process that was structured enough to be repeatable, but lightweight enough to not slow me down.
Building my own
So I built one. Not from theory — from practice. Every phase of The Copilot Loop exists because I hit a real problem: ideas getting lost (IDEA), research happening too late (STORM), scope creeping mid-sprint (SCOPE), code shipping without validation (VERIFY). Each phase is a scar from a mistake I made and decided not to repeat.
The surprise
What surprised me wasn't just what the framework could do — it was how much further it pushed what I thought was possible. A structured loop with an AI agent turns a €20/month subscription into a development team. Not a replacement for human judgment, but a multiplier for human capacity. We're in the early days, and it already feels like a superpower.
Claude Code and the agentic tools landscape.
Not all AI coding tools work the same way. Each occupies a different position in the development workflow. This framework is built specifically around Claude Code — Anthropic's terminal-based coding agent. Here's how it fits in the landscape, and the four concepts that make the framework make sense.
Claude Code
Anthropic's terminal agent. Full tool access: reads and writes files, runs commands, uses git, spawns parallel subagents. Context-aware at the project level. Works from any terminal, integrates with any editor. This is the tool this framework is built for.
Cursor
An AI-enhanced IDE built on VS Code. AI lives inside the editor — strong for inline editing and code chat. Not designed for long-running agentic workflows from the terminal.
GitHub Copilot
The most widely adopted tool. Strongest at inline autocomplete and code suggestions. Now includes agent and chat modes. Tightly integrated with GitHub's ecosystem of PRs and issues.
ChatGPT / Codex
OpenAI's tools. Chat-first by design. ChatGPT can write and run code in a sandbox. Less suited for complex, long-running project-level workflows — but excellent for quick generation and exploration.
Gemini CLI
Google's equivalent of Claude Code. A terminal agent with similar capabilities — reads files, runs commands, manages project context. Uses Gemini models instead of Claude.
Four things you need to know.
Claude Code introduces a handful of concepts that aren't obvious the first time. Understanding them is what makes the framework's structure — fresh contexts, CLAUDE.md, skills, agents — click into place.
Context window
How much the AI can "see" at once in a session — conversation history, files read, tool outputs. When it fills up, quality degrades. The framework counters this with fresh contexts per task and CLAUDE.md as persistent reference outside the window.
CLAUDE.md
A markdown file at the project root that Claude Code loads automatically at the start of every session. The project's persistent memory: tech stack, conventions, constraints, patterns. Every insight captured there makes the next session better than the last.
Skills & slash commands
Named, reusable workflows stored in .claude/skills/. Each skill is a SKILL.md file with instructions Claude follows when invoked. Type /skill-name to trigger one. This framework's phases are each backed by a skill.
Agents
Claude can spawn independent AI instances — subagents — each with its own fresh context window. They can run in parallel. The framework uses agents for research and for any task that benefits from isolation and parallelism.
Seven phases. One living cycle.
Each cycle starts with an idea and ends with a retrospective that improves the framework itself. The output of RETRO feeds directly into the next IDEA. Nothing is wasted — not even the things that didn't work.
From idea to ready-to-build
The first three phases are about thinking before doing. Getting the idea right. Understanding the space. Defining exactly what to build and how. Most of the value is created here — before a single line of code is written.
A structured conversation where AI asks, human answers. The AI never writes the output until you confirm it understood. One question at a time. No rushing to solutions.
Key principle: You know what you want. The AI's job is to help you articulate it — not to tell you what to want.
Research first, brainstorm second. Parallel agents investigate the idea space and return findings. Then an open conversation to explore directions, generate options, and populate the backlog.
Key principle: No brainstorming blind. Research grounds the conversation — diverge before converging.
Define what to build, how to build it, and the Definition of Done. Scope (in/out), technical approach, and a DoD covering four categories: Functional, Quality, Documentation, and Delivery.
Key principle: DoD is non-negotiable. Define it before building. If it's not in the DoD, it won't happen.
Done means all four categories. Always.
The DoD is defined in SCOPE and validated in TEST. It's never just "the code works." It always includes documentation and — critically — framework updates. Because if a new pattern emerged and it's not captured, it's lost.
Definition of Done — Template
✦ Functional
✦ Quality
✦ Documentation
✦ Delivery
Build, test, ship, improve
The second half of the cycle is where things get built — but also where the framework gets smarter. RETRO is not a formality. It's the phase that justifies everything before it.
Claude Code works through the task list from SCOPE. Each task gets its own fresh context window and produces one atomic commit. Tasks that are independent run in parallel. Dependent tasks run sequentially.
Key principle: One task = one fresh context = one atomic commit. Makes debugging, reverting, and reviewing easy.
Validation against the DoD from SCOPE. Four modes depending on what's needed: automated (CI/tests), manual review, guided UAT (walk through scenarios), or free UAT (explore and report). Not all phases need all modes.
Key principle: Validate against the DoD. If the DoD was well-written, there's no ambiguity about what "done" means.
Document and release the value delivered. Release notes focus on VALUE ("users can now do X") not implementation ("added Y component"). Includes DoD status, known limitations, and notes for the retrospective.
Key principle: Document VALUE, not features. "Users can now X" is more useful than "added Y."
The retrospective that can update the framework itself. Reviews what worked and didn't. Proposes changes to CLAUDE.md, skills, or methodology docs — but only applies them after human validation. This is what makes the framework living.
Key principle: The framework earns its authority by being useful. Update it when it isn't. Every /retro can change anything.
The framework as slash commands
Each phase with AI involvement has a corresponding Claude Code skill — a SKILL.md file that gives Claude a detailed playbook for that phase. These live in .claude/skills/ and are available as slash commands in every session.
IDEA
Structured idea capture conversation. AI asks one question at a time. Produces IDEA.md only after you confirm its understanding.
STORM
Research first, brainstorm second. Spawns parallel agents to investigate the idea space, then opens an interactive brainstorm grounded in the findings.
SCOPE
Defines what to build, how to build it, and writes the full Definition of Done. Covers scope boundaries, technical approach, and a task breakdown ordered by dependency.
BUILD
Activates Senior Tech Lead mode. Evaluates the technical approach, implements with production quality, and follows the project stack guidelines for frontend, backend, and DevOps.
TEST
Validates delivered work against the Definition of Done. Runs automated checks, walks through the DoD line by line, and guides a UAT session before marking the phase complete.
SHIP
Creates release notes focused on value delivered. Validates DoD status, documents limitations, and surfaces notes for the retrospective.
RETRO
Retrospective facilitator that can update the framework itself. Proposes changes to CLAUDE.md, skills, and methodology docs — always with human validation first.
Six rules that hold everything together
Research before conversation
Run /scope before /plan. Give the AI context, not just problems. The quality of its output is proportional to the quality of the context it has.
Claude proposes, you decide
Every AI output needs human validation before it becomes real. This isn't AI skepticism — it's good engineering. You are the pilot. Claude is the copilot.
Context is the foundation
CLAUDE.md is the project brain. Keep it updated. Every new pattern, convention, or constraint that emerges should be captured there — that's what makes the next session better than the last.
Atomic tasks, atomic commits
One task = one clear outcome = one commit. Each task gets a fresh context window — no accumulated garbage from previous tasks. Makes debugging, reverting, and reviewing easy.
The DoD is sacred
Define it before building. It always includes functional, quality, documentation, AND framework criteria. If something isn't in the DoD, it won't happen. If it happened and wasn't in the DoD, add it for next time.
The framework evolves
Don't follow this methodology because it's written down. Follow it because it works. Every /retro is an opportunity to update, simplify, or remove any part of it. The framework you're reading is already different from the one I started with.
Learning in public.
This framework is on GitHub — the skills, the docs, the CLAUDE.md. If something here is useful for your own workflow, take it. If something is wrong or could be better, I'd genuinely like to know.
Let's talk about this
Drop me a note — questions, feedback, or just want to say hi.