--- title: "Discussion on \"What happens when a coding agent forgets why a change was rejected?\" | Hashnode" description: "Discussion on \"What happens when a coding agent forgets why a change was rejected?\". I tested what a fresh coding-agent session does when the repo remembers the code, but not the reasoning behind it." url: "https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645" --- [Feed](https://hashnode.com/feed) / Discussion # [What happens when a coding agent forgets why a change was rejected?](https://blog.technopathy.club/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected?utm_source=hashnode&utm_medium=feed) I tested what a fresh coding-agent session does when the repo remembers the code, but not the reasoning behind it. Sep 8 · 5 min read · blog.technopathy.club Updated Sep 9 Read the article - [#ai](https://hashnode.com/tag/ai) - [#opensource](https://hashnode.com/tag/opensource) - [#devtools](https://hashnode.com/tag/devtools) - [#programming-blogs](https://hashnode.com/tag/programming-blogs) - [#keepthewhy](https://hashnode.com/tag/keepthewhy) ## Written by [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) @oliver-zehentleitner · Vienna, Austria [View profile](https://hashnode.com/@oliver-zehentleitner) DevSecOps · Python · AI-driven Development · Real-world findings from production systems. I build systems that work — technically sound, security-first, and actually useful to the people who depend on them. Creator of the UNICORN Binance Suite — six open-source Python libraries with 3.3M+ downloads and 390+ dependent public projects — and Keep the Why, an open-source agent skill that preserves the reasoning behind engineering decisions alongside the code. Currently pioneering AI-driven open-source maintenance: running a controlled AI agent that maintains production code and documenting what this shift means for engineering teams. Vienna, Austria 🇦🇹 ## Responses 10 Markdown supported · ⌘↵ to post [Julian Neagu](https://hashnode.com/@julianneagulab) [Sep 12](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa551113d43fb1a2486eb10) The rejected changes part is what stood out to me. Git is good at showing what we kept, but not what we tested and threw away. That missing history gets expensive once agents start working across sessions. [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) [Sep 14](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa551113d43fb1a2486eb10#reply-6aa79f3f9b5b94221934bd5a) Exactly. That “missing history” is easy to ignore when humans still carry it in their heads. But once agents work across fresh sessions, the cost becomes visible: the same dead ends get investigated again because the repo only shows what survived. That is the part I find most interesting too. [BotSailor](https://hashnode.com/@botsailor) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa27e31b91f046b74cef821) Great insight. AI coding agents need more than the ability to generate code, they need context and memory of past decisions. Understanding why a change was rejected is what will make them true engineering partners rather than just code assistants. [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa27e31b91f046b74cef821#reply-6aa29c5b843577d46bd90186) Exactly. The code is only part of the system. If the agent can also see why certain decisions were made - and why some alternatives were rejected — it becomes much more useful as an engineering partner. [Sanoary Istiaque](https://hashnode.com/@istyy) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa26aa6a235b045c05cb19e) This is such an important discussion about the difference between intelligence and understanding. A coding agent can generate impressive solutions, but without remembering why certain decisions were made, it can easily repeat the same mistakes or reopen problems that humans have already solved. The real challenge with AI collaboration is not only making agents better at writing code, but helping them preserve the context, trade-offs, and lessons behind those decisions. In software development, the “why” is often just as valuable as the code itself. I think the future of AI-assisted development will depend less on replacing developers and more on creating AI partners that can learn from a team’s history, respect previous decisions, and understand the reasoning behind a system’s evolution. Great reminder that true collaboration requires memory, context, and trust, not just faster code generation. [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa26aa6a235b045c05cb19e#reply-6aa26fdc343349a122ee9691) Yes. I think that distinction matters a lot. The goal is not to make an agent “remember everything”. It is to make the important project decisions, trade-offs and lessons available when they become relevant again. That is where AI collaboration starts to feel less like repeated prompting and more like continuity. [Mateo Ruiz](https://hashnode.com/@mateoruiz) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa235071603e518a15f07f9) The most useful distinction here is between **code state and decision state**. Git tells the next agent what survived, but it often cannot tell it which alternatives were deliberately killed along the way. I’d take this one step further and treat rejected approaches as constraints with an expiration condition. A workaround may be rejected because of a production incident today, but that reason can become invalid after a dependency, architecture, or traffic pattern changes. Recording not just “don’t do this” but _why, under which conditions, and when to revisit it_ would make project memory much more actionable. That turns a simple Markdown file into something more valuable than context it becomes a lightweight record of architectural decisions and their assumptions. [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) [Sep 10](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa235071603e518a15f07f9#reply-6aa23c20bb190d0950f94a90) Yes - I really like that distinction between code state and decision state. And the expiration/revisit condition is an important extension. A rejected approach should not become a permanent “never do this again” rule just because it failed once under a specific set of assumptions. What matters is preserving why it was rejected, under which conditions, and what would have to change before it is worth reconsidering. That makes the recorded rationale much more useful: not just “don’t do this”, but “don’t do this while these constraints still hold”. [Evelyn Wyatt](https://hashnode.com/@Evelynwyatt) [Sep 9](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa0e727e99fc7f995215587) The idea of preserving rejected decisions is especially interesting because it captures a form of “negative knowledge” that Git usually can’t represent. A codebase can show what the team chose, but not necessarily which alternatives were tested and ruled out. For coding agents, that context could prevent not only repeated mistakes but also repeated investigation. It makes project memory feel less like storing explanations and more like preserving the reasoning boundary around the code. [Oliver Zehentleitner](https://hashnode.com/@oliver-zehentleitner) [Sep 9](https://hashnode.com/posts/what-happens-when-a-coding-agent-forgets-why-a-change-was-rejected/6aa015bcbe03d2ac71a46645/comment/6aa0e727e99fc7f995215587#reply-6aa107fd2051bcec610d9080) Exactly. “Negative knowledge” is a great way to put it. The code tells you what survived, but not what was explored and deliberately discarded. And for agents, that missing history means spending time rediscovering the same boundary over and over again. That was probably the most interesting part of the experiment for me: the agent didn’t need to become smarter — it just needed access to the reasoning that was already there.