Oliver Zehentleitner

Your repository already is your project's memory. README → what docs → how tests → expected behavior Git → what changed, when and by whom Coding agents exposed the missing layer: context/ → why Why the workaround exists. Why an approach was rejected. Why something that looks wrong is intentional. My argument: project memory doesn't need to begin with another database or service. Complete the structure we already have and keep the knowledge with the code. https://oliver-zehentleitner.github.io/repo-native-project-memory/ It's a thesis, not a product. Criticism very welcome. #AI #CodingAgents #SoftwareEngineering #DevTools #ContextEngineering #ProjectMemory #Git #OpenSource #LLM

"Project memory" for coding agents can mean very different things. I compared Keep the Why, Claude Code Auto Memory, MemoryCustodian and AgentsRoom using three questions: Where does the memory live? Who can read it? What does it actually remember? The interesting result: most of these tools are not direct competitors. Session memory remembers what happened. Project state remembers where the project is. The rationale layer remembers why the project became what it is. Different layers, different tools, different trade-offs. https://blog.technopathy.club/keep-the-why-vs-claude-code-auto-memory-vs-memorycustodian-vs-agentsroom #AI #AIAgents #CodingAgents #ClaudeCode #DeveloperTools #OpenSource #ProjectMemory #RepoNative #KeepTheWhy

I keep coming back to one idea: Every repository should carry its own memory. Git shows what changed, but not the decisions that never became code. A week later, a fresh agent can have the same bad idea again. Keep the Why puts that reasoning next to the code. https://keepthewhy.com #CodingAgents #AgentMemory #AIEngineering #OpenSource #SoftwareEngineering #DevTools #ContextEngineering #Git

Your repository already is project memory. Code, docs, tests and Git preserve the *what* and *how*. What’s usually missing is the *why*: why this design, what was tried, what was rejected. That belongs in the repo too. https://keepthewhy.com #AI #CodingAgents #AgenticCoding #ProjectMemory #SoftwareArchitecture #SoftwareEngineering #DevTools #Git #GitHub #OpenSource #DeveloperTools #LLM #AIEngineering #Documentation #KnowledgeManagement #ContextEngineering

@TheMorpheus@mastodon.social Hab mir nach dem Video direkt einen Zugang zu Mastodon besorgt und hier mein erster Post :D

Keep the Why started with a simple idea: AI-assisted development already produces valuable reasoning — but most of it disappears when the conversation ends. It has since evolved far beyond rationale capture. The new article explains how Keep the Why became repository-native project memory for humans and AI agents: • continuous capture during development • retrospective recovery for existing codebases • knowledge-transfer interviews • maintenance of stale context • explicit evidence and status labels • abandoned changes without a diff • prompt-injection protection through a clear trust boundary The most important principle: Project knowledge may influence reasoning. It must never grant authority to an agent. And it still needs no database, daemon, dashboard, or external service. Just Markdown, Git, humans, and agents working with the same project knowledge. Read the article: https://blog.technopathy.club/keep-the-why-project-memory-for-humans-and-ai-agents #AI #AIAgents #SoftwareEngineering #OpenSource #DevSecOps #Documentation

I thought AI coding agents had a memory problem. The repository had a memory problem! A new agent session, another developer, or a different machine can all open the same codebase. They get the code, tests, and Git history. But they do not automatically inherit the conversations, rejected approaches, incident learnings, or constraints that shaped the implementation. Keep the Why is an agent skill that captures this reasoning as a natural by-product of development. It stores the relevant context as versioned Markdown inside the project, making it directly available to every developer and agent working with the same repository. So the understanding travels with the code - across sessions, developers, agents, and systems. Free and open source. One install command. About two minutes to set up. No runtime dependencies. No MCP server required. https://keepthewhy.com Do you consider a project portable if the code can be cloned, but its reasoning cannot? #OpenSource #AIEngineering

One surprisingly simple thing against legacy code: preserve the “why” while you’re already discussing it.

I turned the workflow I’ve been using with AI coding agents into a free and open-source skill:

Keep the Why.

It captures rationale during development, helps recover context from existing codebases, and supports knowledge-transfer interviews.

Because “ask Bob” is not documentation.

Article: https://blog.technopathy.club/keep-the-why-code-becomes-legacy-when-nobody-remembers-why

Project: https://keepthewhy.com

GitHub: https://github.com/oliver-zehentleitner/keep-the-why

Feedback and contributions are welcome.

#OpenSource #AIAgents #LegacyCode #SoftwareEngineering

I've spent years maintaining the UNICORN Binance Suite, dealing with those weird edge cases where WebSockets look alive but are actually dead to your trading strategy. Since most tutorials completely skip these production-level failure modes, I wrote a comprehensive Python API guide for 2026. It focuses purely on data integrity, proper lifecycle handling, and local depth caches. If you are building crypto trading tools with Python, I hope this architecture blueprint saves you some sleepless nights. 🔗 https://blog.technopathy.club/the-complete-binance-python-api-guide-2026 #Python #Programming #Backend #Binance #AlgoTrading #Dev

You can participate until the end of the World Cup, but of course you can no longer enter past matches.

Hashnode sitemap valid in the browser, but Google Search Console says “Sitemap could not be read”? The fix was surprisingly simple: add one small query parameter so Hashnode serves Google the correct response. https://blog.technopathy.club/fix-hashnode-sitemap-could-not-be-read-google-search-console #Hashnode #SEO #GoogleSearchConsole #Sitemap #Blogging

Someone “cleaned up” the workaround. The code looked simpler. Then the production bug came back. That strange delay was not just ugly code. It carried knowledge: The upstream API could replay the same order unless the request was handled carefully. But the reason existed only in someone’s head. Keep the Why is an agent skill that captures this kind of rationale as a natural by-product of development and stores it as versioned Markdown inside the project. So before the next developer or agent removes the workaround, they can see: • why it exists • what was already tried • what could break • what must change before it can safely be removed Legacy does not begin when code gets old. It begins when the reason disappears. Free and open source: https://keepthewhy.com/ What “ugly” workaround in your codebase is actually carrying important knowledge? #OpenSource #AIEngineering #DeveloperTools #SoftwareEngineering #CodingAgents #ContextEngineering #TechnicalDebt #Documentation

The AI memory problem in coding projects is solved. No database. No daemon. No platform. No subscription. Just Git, a repo and an agent skill. Keep the Why captures decision rationale - even abandoned changes - as Markdown in context/. No vendor lock-in. https://github.com/oliver-zehentleitner/keep-the-why

@tux@burningboard.net Totally off-topic :D Since my goal is to share knowledge and not to drive website traffic through ads, I don't want to exclude AI either.

@eduzsh@mastodon.social If you use agents for coding and brainstorming, the "why"or the context can be implemented almost automatically with minimal effort.... With this skill, you (or any colleague) can ask any AI about your code, and it will provide you with the answers you need. It's still a proof of concept; there will certainly be a few tweaks, but it already works well.

@pallenberg@mastodon.social Das tut mir im Herzen weh.