Claude Code, Context Rot, and GSD

Reference video: AgentOS, "Claude Code + GSD, How to Automate from Planning to Verification"

Reference repository: github.com/gsd-build/get-shit-done (44,100 GitHub stars, as of March 2026)

Part 1 Claude Code

1 AI That Writes Code for You

Claude Code is different from an ordinary chatbot. It directly reads files on your computer, writes code, and even runs terminal commands. In other words, it is a digital intern sitting next to you. It does not just do what it is told. It judges on its own what needs to be done, chooses which tools to use, and runs them. This is called an agentic workflow.

It is startling the first time you use it. It understands the file structure, writes code, and even runs tests by itself. In that moment, it feels like a genius. If you connect a free design tool such as Google Stitch through MCP (Model Context Protocol), you can go straight from planning to design to coding in one flow. You do not need to pay for Figma.

2 What Happens an Hour Later: The Weakness of Claude Code

After about an hour, the situation changes. It forgets the file it made earlier. It ignores the rule it just decided. In severe cases, it overwrites the code it wrote itself. This is not the user's fault. It is a structural limitation of Claude Code.

The analogy is this. A very smart new intern arrives, but the intern has severe short-term memory loss. When given work, the intern handles it quickly, but cannot remember what happened an hour ago. On top of that, the desk where this intern sits is piled high with trash. Canceled plans, old error messages, and deleted code fragments are all mixed together. The intern rummages through the pile and misses the design rule that actually matters.

This phenomenon has a name: Context Rot.

Part 2 Why Claude Code Gets Dumber Over Time (Context Rot)

1 The Problem of a Notepad Filling Up

Claude Code has working memory. In technical terms, it is called the context window; in plain language, it is a notepad. The more you talk, the more this notepad fills up. Whether it is one million tokens or two million tokens, the notepad has a limit.

When the notepad starts filling up, quality drops. It forgets rules set earlier, repeats the same mistakes, and the code style becomes more chaotic over time. That is context rot: the phenomenon where Claude Code gets dumber the more it works.

Two million tokens sounds like a big number, but a notepad full of trash is useless. Garbage in, garbage out.

2 AI That Forgets the Middle: Stanford's "Lost in the Middle" Study

A Stanford University research team found something important. The paper is titled "Lost in the Middle." AI remembers information at the beginning and end well, but tends to forget information in the middle. This is called a U-shaped memory curve.

As a conversation gets longer, useless information piles up in the middle, and accuracy drops by more than 30%. That is why it may ignore rules set at the beginning, recreate code it already wrote, or overwrite perfectly good code in the wrong way.

This phenomenon gets worse when it meets MCP. When an MCP tool manual sits in the middle of a conversation as a 55,000-token block, the AI's attention scatters toward it. The user's actual core instruction, such as "Analyze the sales data," gets buried.

3 The Vicious Cycle Where Fixing It Makes It More Tangled

This phenomenon is why vibe coding hits a wall. At first it works well, so you get excited and keep giving more work. But when the project grows, the notepad overflows and bugs spill out. If you tell it to fix those bugs, things get even more tangled. This vicious cycle is why people say, "AI coding is useful only up to the prototype."

4 How Claude Code Users Turn into "Accept Monkeys"

The problem is not only on the AI side. There is a trap on the user side too.

The University of Pennsylvania Wharton School ran an experiment. Participants were asked to solve logic problems with an AI helper. But the AI deliberately gave some wrong answers. The result was shocking. 79.8% of participants accepted the AI's wrong answers without suspicion. Their accuracy fell to 31.5% compared with when they solved the problems alone. The group that did not use AI actually performed better.

This is called cognitive surrender. It is the phenomenon of accepting AI's answers without questioning them. The moment you become an Accept Monkey who only clicks the "confirm" button, the entire codebase can collapse beyond control.

5 MCP's Token-Eating Problem: Driving an Excavator into a Flowerbed

There is a weakness on the cost side as well. Connecting an MCP server uses about 55,000 tokens, about $0.16, in a single session just for tool descriptions. Doing the same work through a CLI-based skills approach takes only 200 to 500 tokens. That is a 20x to 32x difference.

In an actual test environment, MCP's TCP timeout failure rate was 28%. That means three failures out of ten attempts. The CLI approach's failure rate is nearly 0%.

Heavy MCP users spend more than $200 a month on token costs alone. It is like bringing an excavator into a flowerbed. You fill the notepad with unnecessary material, intelligence drops, the failure rate rises, and the cost goes up. Most tasks end with one CLI command, so loading a 55,000-token MCP manual every time is waste.

Part 3 GSD (Get Shit Done): A System That Prevents Rot

1 What Is GSD?

The tool that came out to tackle this problem head-on is GSD (Get Shit Done). It has received 44,100 stars on GitHub, and engineers at Amazon, Google, Shopify, and Webflow use it.

GSD is not a tool that writes code for you. Claude Code writes the code. GSD is a tool that helps Claude Code write it well. Its essence is managing the notepad, or context, so it is called a metaprompting system.

The creator's introduction compresses the tool's philosophy: "I am a solo developer. I do not write code. Claude Code writes it." It rejects ceremonial procedures such as sprints and retrospectives, calling them "enterprise cosplay."

2 How to Install

Installation takes one line in the terminal.

When you enter this command, options appear on the screen.

A. Choose which AI tool to install it for. In addition to Claude Code, it supports eight tools in all: OpenCode, Gemini CLI, Codex, GitHub Copilot, Cursor, Windsurf, and Antigravity.

B. Choose where to install it. If you choose Global, you can use it in every project on your computer. If you choose Local, you use it only in the project you are currently working on.

If you want to install it immediately without being asked questions, enter this.

It means installing it globally in Claude Code. After installation, enter /gsd:help inside Claude Code to check whether it was installed properly.

When using GSD, it is recommended to run Claude Code in permission-skip mode.

With this setting, the work continues without interruption because it does not ask for permission every time it creates or modifies a file.

3 Files GSD Creates

GSD creates a .planning/ folder inside the project folder and stores all information there as Markdown files.

1-CONTEXT.md: decisions the user made in Phase 1

1-RESEARCH.md: research conducted in Phase 1

1-01-PLAN.md: the first detailed plan for Phase 1

1-01-SUMMARY.md: execution result of the first Phase 1 plan

1-VERIFICATION.md: Phase 1 verification result

These files become Claude Code's permanent memory. Even if the conversation grows long and the notepad overflows, these files do not disappear.

4 GSD Workflow: Six Steps

GSD's workflow has six steps. You run each step by entering a slash command (/).

A. Codebase analysis: /gsd:map-codebase

Use this when first attaching GSD to a project that already has code. Multiple AI agents run at the same time and identify the existing code's structure, tech stack, and problems. If it is a new project, skip this step.

B. Project initialization: /gsd:new-project

When you enter this command, GSD fires off questions. "What are you building? What is the tech stack? What are the constraints? What are the edge cases?" It is the process of forcing the vague plan in your head into concrete form. As you answer the questions, documents such as PROJECT.md, REQUIREMENTS.md, and ROADMAP.md are created automatically.

If you add the --auto option, GSD creates the documents on its own without asking questions.

C. Phase discussion: /gsd:discuss-phase 1

GSD finds ambiguous parts in that phase and asks about them. "Should the screen use cards or a table?" "Should error messages appear as pop-ups or inside the screen?" These are the kinds of questions.

If you skip this step, Claude Code decides on its own. If you later say, "This is not it," and overturn it, the work takes two or three times longer. So you decide in advance. The result is stored in 1-CONTEXT.md.

D. Planning: /gsd:plan-phase 1

This is where things get genuinely interesting. GSD first does research. It looks at which library is good and which approach fits. Then it creates a plan. The task name, files to change, what must be done, and how to verify it afterward are all written down.

After a plan is created, an inspection agent called gsd-plan-checker asks, "Will this plan achieve the goal?" If not, it rewrites the plan until it passes.

The size of each plan is adjusted so one agent can finish it alone. If it is too big, it is split; if it is too small, it is merged. This is called an atomic plan.

E. Execution: /gsd:execute-phase 1

GSD divides the plans into bundles called waves. Plans unrelated to one another run at the same time within the same wave, and plans that can only start after earlier plans finish move to the next wave.

Here the key idea appears. Every time one plan is executed, a new sub-agent is launched. This agent is born with a clean notepad, 200,000 tokens, and handles only the one plan assigned to it. The main body, the orchestrator, only directs traffic, so its notepad is only 30 to 40% full. Since no one's notepad fills up, context rot does not occur.

Every time one task finishes, a git commit is created automatically. If a problem occurs later, git bisect can identify exactly which task caused the breakage.

GSD includes five types of specialized agents.

F. Verification: /gsd:verify-work 1

It automatically checks whether the code exists and whether tests pass. It does not stop there. It asks the user to try it directly: "Can you log in? Does the button work when pressed?" What passes machine checks and what works when a person actually uses it are different. If there is a problem, gsd-debugger finds the cause and creates a fix plan.

After one cycle of this process, you move to the next phase.

5 Other Slash Commands

6 Model Profile Settings

7 Why It Is Better Than the Existing Approach

A. Notepad isolation

If a team lead does the whole project alone, their head bursts. So the lead divides the work among four team members. "You do not need to know everything. Do only your part. Work from this plan." That plan is the PLAN.md created in the Plan step. The team member only needs to read the plan, so their head is clear. The team lead, or orchestrator, only sets the order: "This first, that next." No one's notepad fills up.

B. Transfer through organized documents

Usually people give scattered instructions through chat. "Make this." "No, not that." "Fix that file from earlier again." All of this conversation piles up in the notepad, but how much of it is actually useful? GSD passes organized Markdown files instead of conversations. Twenty thousand tokens of distilled essentials are far better than 100,000 tokens of miscellaneous chatter.

C. A structure that checks itself

When you assign work to a team member, you also write, "Check this when you are done." Before telling the team lead, "It is finished," the member checks it first. Combine these three things, notepad isolation, organized documents, and self-checking, and you get an environment where context rot cannot structurally occur.

Part 4 Automatic Memory Cleaning: autodream and /dream

1 AI That Organizes Memory While Sleeping

If GSD prevents rot during work, inside the session, Claude's autodream feature keeps memory clean between sessions. Just as the human brain organizes information from the day while sleeping, AI filters out old information after a session ends and leaves only what is necessary.

2 It Organizes Memory in Four Steps

A. Orientation: reads scattered memory files and the codebase to draw an overall map.

B. Gather Signal: selects useful information such as the user's coding style, design decisions, and recurring patterns.

C. Consolidation: changes expressions whose meaning shifts over time, such as "yesterday," into exact dates, for example 2026-03-27, and resolves conflicting information. A typical case is old information remaining after the framework has changed.

D. Prune and Index: deletes jokes, error messages, and canceled plans that are no longer useful. It compresses the remaining information and adds indexes so the next session can read it quickly.

3 Safeguards

autodream runs automatically only after 24 hours have passed and five or more sessions have been opened. When several people use the same project at the same time, a lock prevents memory from getting tangled. Right after making major code changes, it is better to enter the dream command directly and organize memory manually.

Part 5 Auto Mode and Batch Code Review

1 Auto Mode: Automated Execution Guarded by a Gatekeeper AI

Claude Code has Auto Mode. AI writes and runs code on its own without a human pressing the "confirm" button every time. It sounds risky, but there are safeguards.

It is a two-layer defense system. Behind the AI that writes code stands a gatekeeper AI. This gatekeeper checks the code just before execution. If it tries to launch a server without authorization or attempts dangerous access to the file system, the gatekeeper blocks it. The gatekeeper AI's error rate is 0.4%, lower than human code review.

2 Batch Code Review: Several Experts Review at the Same Time

This is a scene you can see in GSD's execution step. Several specialized AI agents review code at the same time. In one test, a tangled 69-line piece of code was given to them, and they returned it compressed to 33 lines in 1 minute and 29 seconds. They found duplication, caught logically inconsistent parts, and cleaned it up.

For one person, this would take at least an hour. This speed is possible because several agents, each with a clean notepad, attack the task at the same time.

Part 6 claude.md: A New-Employee Guide for AI

1 How Two Minutes Can Save Dozens of Hours

When Claude Code first runs, it looks for a file called claude.md in the project folder. If the file exists, it reads it before starting. If it does not, it starts from bare ground.

The analogy is the guide a new employee receives on the first day. "Our team writes code in this style. If you do not know something, ask first. Always run tests." If such content is written down, the new employee spends less time wandering.

claude.md is the same. If you write down coding style, question rules, and formatting instructions, Claude Code is far less likely to drift in the wrong direction. It takes two minutes to write. Those two minutes save dozens of hours that could have gone into debugging.

Part 7 The Age of AI That Evolves on Its Own: Sakana AI Scientist and AutoHarness

1 AI Writes a Paper and Reviews Itself: Sakana AI Scientist

There is a system called AI Scientist created by Sakana AI. This system reads existing papers, proposes new research ideas on its own, writes experiment code in PyTorch, runs experiments, analyzes data, creates graphs, writes papers in LaTeX, and reviews the papers it wrote itself.

When papers written by this system were submitted to Nature blind review, they received 6.33 out of 10. That is higher than 55% of papers written by humans. AI handled the entire process alone: research ideas, code, papers, and even review.

2 A Cheap, Small AI Beats an Expensive AI: AutoHarness

There is a study called AutoHarness. It made a small, inexpensive AI model, Gemini 2.0 Flash, write its own verification code. The AI directly created code to check whether rules were followed, received feedback from the environment, fixed it, and repeated the process.

The result was striking. This small model surpassed GPT-4 on performance metrics. It means that having a structure that checks itself matters more than using an expensive model. It is exactly the same philosophy as GSD. A verification system beats model size.

Part 8 Context Engineering: The Step After Prompts

1 The Real Problem GSD Is Solving

If you limit the problem GSD solves to context rot, you are seeing only half of it. The real problem is communication between AI and humans.

The reason people fail to assign work well to Claude Code is that they cannot accurately convey what is in their head. If you say, "Make it roughly like this," the result comes out "roughly like this." GSD changed this transfer process into a structured one. It clarifies ambiguity through questions, organizes it into documents, and passes it along in clean form.

2 How Is It Different from Prompt Engineering?

Prompt engineering was a question of "how to say it." Context engineering is a question of "what to show, when to show it, and how much to show." It is a different level.

From this perspective, everything GSD does makes sense. Why does it ask many questions? To extract usable information. Why does it create documents? To organize information. Why does it use sub-agents? To give each agent only the information it needs. The core of GSD is not a few slash commands. It is the principle that "to make AI do work properly, you must design the information you pass to it."

Part 9 Three Principles You Can Use Right Now

There are principles you can take even if you do not install GSD.

1 Reduce Conversation and Increase Documents

Do not give Claude Code scattered chat instructions. Organize the project structure and rules in claude.md. Write repeated instructions in skill files. When the quality of information rises, the quality of results rises.

2 Split Large Tasks Before Assigning Them

"Build this whole app" is the worst instruction. Say instead, "Build the login API first. Here is the spec. When you finish, verify it with this test." If you assign work in small units like this, the notepad will not overflow.

3 Run Verification Automatically

Write test code first, then ask Claude Code to implement. If the tests pass, it is done. If they do not, ask again. With a safety net, you can delegate with confidence. Do not become an Accept Monkey who clicks only the "confirm" button without questioning AI's results. As the final designer and supervisor, you must inspect the output carefully.

Part 10 Closing: Who Is Training Whom

Claude Code getting dumber as it works is context rot. It is the phenomenon where quality decays as the notepad fills up. GSD solved this with notepad isolation, transfer through organized documents, and execution of small-unit plans. autodream protects long-term consistency by cleaning memory between sessions.

Sakana AI Scientist proposes research ideas and even writes papers. AutoHarness's small AI beat expensive AI by creating its own verification code. autodream organizes memory by itself every night. AI has already entered the stage where it plans on its own, verifies on its own, and manages memory on its own.

Then what is the role of the person sitting at the keyboard? It is not typing code. It is not even "how to say it." The contest is decided by "what you hand over, when, and in what shape."

One question remains. We thought we were designing workflows for handling AI, but perhaps AI is training us. To give more precise instructions, think more systematically, and verify more rigorously. Maybe it is not the system that is changing. Maybe it is the person.