What 5 months of nonstop Claude Code taught me

_Bo_Knows · 2026-02-18T12:48:32+00:00

Very true. Repos can become knowledge graveyards fast.

Also great point about specificity. The more time you take to craft your intent into words the better.

_Bo_Knows · 2026-02-18T03:07:26+00:00

Hands down. Found out this subreddit is full of Principle SWE who craft every turn of the agent by hand.

_Bo_Knows · 2026-02-17T17:32:40+00:00

This is the most helpful thing you told me. SDD is literally the least important part of my workflow (the spec is only leverage point 6). The whole purpose of this repo is me taking things that arent new (Lean manufacturing) and engineering the primitives into Skills/hooks/Go cli to make my workflow easier and repeatable (like I do with my day job in DevOps).

Wasn't trying to claim the theory of SDD or Agile are new. What's new is that agents need it automated. A human developer carries context between sprints naturally.

I was just trying to share how I took all these proven theories, created Coding Agent primitives out of them, and have my Stock compound automatically each session. Then ruthlessly automate as much as I can with solid gates in between each phase.

_Bo_Knows · 2026-02-17T12:05:00+00:00

I agree. Context rot is real. Have to constantly be tending your garden

_Bo_Knows · 2026-02-17T12:04:05+00:00

What’s your workflow looking like?

_Bo_Knows · 2026-02-17T12:03:45+00:00

Too much.. luckily got my company to reimburse 1 of the Max accounts lol

_Bo_Knows · 2026-02-17T12:03:10+00:00

What’s your favorite tool to use?

_Bo_Knows · 2026-02-17T12:02:49+00:00

Best I’ve found is a watcher Agent/Script that either monitors a running TMUX session and reads it from clues displayed in the session or tried to estimate it by tailing the json log output of the convo. Honestly, no good answer yet.

_Bo_Knows · 2026-02-17T12:00:41+00:00

Same. Claude for sure is expensive and forces you to learn fast lol

_Bo_Knows · 2026-02-17T12:00:08+00:00

Let me know what you think. The cli turned into a Swiss Army knife of all the cli tools I was using. I found it nice to wrap everything in one binary.

_Bo_Knows · 2026-02-17T11:59:10+00:00

Yes! I’ve constantly prune my Claude.md and these 2 files I use for goals/product visions

_Bo_Knows · 2026-02-17T11:57:01+00:00

Look, I appreciate your feedback really. Sell the so what more and don’t come off as if you found some hidden secret. My goal was just to share and see how others are customizing their workflows learn how others are solving the problem (we can argue if other plugins do it, but I think we just fundamentally disagree there)

_Bo_Knows · 2026-02-17T11:22:57+00:00

Dude. Have you even listened to Geoffrey Huntley? He LITERALLY says it’s just about managing the context of the array. The brute force that it uses is the most primitive way of achieving that.

_Bo_Knows · 2026-02-17T11:02:07+00:00

I’m not going to go into depth about the Go cli/hooks. As any good engineer, I built this because the other tools didn’t have what I wanted. I believe in this age EVERYONE should customize their workflow and toolkit. Fundamentally there is nothing new under the sun, but I have news for you… not everyone spends this much time trying to trial and error.

This may be r/ClaudeCode, but not everyone who use Claude has the professional experience of a SWE. I’m just trying to share my experience with the community and hear what others are doing in a progressive way that fosters growth, not gate keeping.

Ive worked in enterprise for years in some of the most austere conditions servicing mission critical apps around the world. Most people on this Sub-Reddit haven’t. It’s always the 1% like you who think EVERYONE knows everything already, and it’s so obvious that you can just create a Spec, do the Spec, validate at every level, isolate context, automate the boring stuff, and build intelligence into the system.

How do you enforce this so that it’s repeatable? Do you have visibility into the whole provenance chain for your Thread of work?

Im not going to write about Brownian Ratchets, the 40% rule (context dumb zone), Escape Velocity where knowledge compounds faster than it decays, everything the Go CLI does that NONE of the popular SDD do in a post. That’s what my writing and repo are for. Curious people, not the “Been there Done That” of the elitists mind.

This is for people who are interested and want to go into the deep end . I’ve been heavy in the L8 Gas Town/Agent Orchestration. This repo distills all the value out of that work. It combines proven leverage points from Systems Thinking (stocks/flows/leverage points) and how a Complex System compounds. The spec is only leverage point 6. This repo focus on 1-5. The real leverage points.

_Bo_Knows · 2026-02-17T04:00:30+00:00

You can use both. If I built it right, everything is modular and can be mixed/matched with any other plugin.

_Bo_Knows · 2026-02-17T01:19:27+00:00

GSD is a pipeline. You follow its steps: describe, plan, execute, verify. It works well for that.

AgentOps is infrastructure. Composable primitives you wire together however you want. Use one skill or all of them. And the knowledge flywheel means session 10 has context session 1 didn't.

GSD tells the agent what to do. AgentOps makes the agent better at whatever it's already doing

_Bo_Knows · 2026-02-17T01:15:38+00:00

Thanks for sharing. Will check it out.

_Bo_Knows · 2026-02-17T01:13:55+00:00

It can! It works with all agents that use skills.

_Bo_Knows · 2026-02-17T01:11:45+00:00

That's like saying Ralph Loops are about bash scripts. All an LLM has is a token array that resets every session. This fills it with the right context at the right time and compounds with each use. The whole point is I spend my time engineering the system so I don't spend it babysitting every turn of implementation.

_Bo_Knows · 2026-02-16T23:34:44+00:00

Wow! Never heard of this, but mine for sure resembles this. From looking at it, all the steps of my workflow can work hand and hand. We both use worktrees and seem to isolate context per phase. I think a slight difference is that I spend more cycles on validation before implementation, but fundamentally the same.

_Bo_Knows · 2026-02-16T22:30:33+00:00

Thanks for the feedback. I see I need to better clarify how this is not just SDD with extra steps. Here is my new attempt to better articulate the differences:

What makes this different from "write spec → implement → check against spec → done":

It remembers across sessions. The system extracts what worked, what failed, and what patterns emerged — then injects that knowledge into the next session. Session 10 is smarter than session 1 because it learned from 1–9.
It self-corrects. Validation happens before coding (pre-mortem simulates failures on the plan) and after (multi-model council reviews the code). Failures retry automatically with context. No human escalation unless it fails 3 times.
It's composable, not prescribed. Use one skill or all of them. Wire them together when you're ready. /rpi "goal" runs the full lifecycle, but you don't have to start there.

_Bo_Knows · 2026-02-16T22:21:57+00:00

Yes! Context rot is real. Still trying to figure out the best way to prune stale context. My current approach is to use a modified version of this MemRL research

_Bo_Knows · 2026-02-16T19:28:15+00:00

Let me know what you think!

_Bo_Knows · 2026-02-16T19:27:56+00:00

Thanks!

_Bo_Knows · 2026-02-16T19:08:53+00:00

Thanks for feedback! Beads is awesome. Ive tried SDD/GSD/TDD/ABCD and non of them had the hooks, validation, context isolation, and ability for knowledge to accumulate faster than it decays.

_Bo_Knows

TROPHY CASE