TL;DR: I built a fairly involved Claude Code setup with 24/7 Slack access, persistence across sessions, scheduled workflows, overnight retrospectives, and morning briefings. It worked. Then Anthropic started shipping more of the primitives I had built around: channels, Dispatch, scheduled tasks, etc. The hard part was not building ahead of the platform. It was recognizing when a working custom stack had stopped being leverage and had turned into maintenance. The architecture had 3 environments: Mac for interactive work VPS container for always-on automation phone access through a custom Slack daemon The VPS was not there for fun. Laptop sleep, reboots, battery, and local process fragility are real constraints if you want workflows to keep running while you’re away. The Slack daemon gave me 24/7 communication with Jules from my phone. Cron jobs and scripts handled recurring work. The whole thing was built directly on Claude Code, not as a separate framework or wrapper product. For a while, it was the right answer. Then the platform started catching up. Channels changed the phone-access story. Dispatch changed the async-work story. Scheduled tasks changed the recurring-work story. The replacements were not perfect one-for-one, but the direction was obvious: more of what I had custom-built was becoming native. What made this tricky is that the custom stack did not break. It stopped being leverage. That is a much harder thing to notice. Broken systems are easy. You fix them or replace them. Working systems are dangerous, because every piece can still justify itself. I had months invested. The stack still did what I asked it to do. Nothing was obviously wrong. But the center of gravity had changed. More and more of the custom layer existed to preserve an earlier era of Claude Code rather than to give me a real advantage. The thing that made this visible was auditing the self-improvement loop I had built around the system. Over 47 retrospective cycles, it had applied 115 changes: 105 additive 3 simplifications So basically a 35:1 bias toward adding over removing. Before my first prompt, I was loading around 1,850 lines of rules, profiles, memory, and workflow instructions. A lot of them were tied to the VPS era, one-off failures, or workarounds for platform limitations that no longer existed. That was the part I did not expect. The self-improvement loop was making the system better and heavier at the same time. Every individual fix was locally reasonable. The accumulation was not. The simplification pass ended up touching 879 files and removing roughly 62,000 lines. What I learned from it: Building ahead of the platform can absolutely be worth it. The hard part is recognizing when the platform has caught up enough that your custom layer is no longer buying you much. Self-improvement loops usually will not help you see this. They optimize the layer they live in. They do not ask whether the layer should still exist. So the lesson I am keeping is: build what the platform is missing. learn from it faster than everyone else. then delete it when the platform catches up. Curious how other people here think about this. Have you hit the moment where a working Claude Code customization stopped being an advantage and started being maintenance? Full article: https://builtwithjon.com/articles/best-ai-infrastructure-is-temporary/ Repo: https://github.com/jonathanmalkin/jules submitted by /u/jonathanmalkin
Originally posted by u/jonathanmalkin on r/ClaudeCode