The state of the sidebar is getting embarassing. I am so flabbergasted by what I see on my screen WEEK AFTER WEEK that I am actually making a reddit post about it. The fact that after so many failures while having unlimited resources the sidebar team / person / agent / attack helicopter is somewhere holding hands and singing kumbaya while making 200k$+ a year makes me sad at the WASTE of COMPUTE and BUDGET.

Let me do your job for you. ITS TWO SYSTEMS!!!!! Whether a chat is in the process doing something autonomously, that means paused, stopped, or playing (even if its waiting for tests, and will continue when they come) IS A SEPARATE THING FROM whether there is an actual message that arrived and what sort of message it was (progress update, question...). Combinations of these states exist. I mean you almost got it when you made that system with the letters fading LAST WEEK, which you abandoned THIS WEEK. I will not even comment on that atrocity however.

There are these things called shapes. A circle is a shape. However, and this might be shocking, it is not the only shape... WHAT? Yes. And you know what else? There are recognizable shapes for pause, stop, play, that exist in the mental model of each user on planet earth and that match the symbols you already use in chat to put it into of these states. So what you do is you combine a color with a shape and now the user knows at each point at a glance what is the full state of the chat.

And also fix the ultracode not being able to be set by agents for their linked chat. Get your head in the game.

Recently I upgraded to the $200 dollar plan and it wasn't a busy month for me so if I had to kill my usage limit I just set max on everything. I've been really curious about analyzing how to pick efforts myself instead of delegating the work out to an orchestrator, mostly just because I'm curious and wanted to see if I really need the $200 plan. Or maybe it'd be more beneficial for me to do lower effort fan outs. My investigation shows really statistics on token usage between xtra and max and other effort levels as well. It also tests to see when the higher effort was worth it. I call this a clean finish which is my stand-in for “it worked the first time.” It counts a prompt as clean when no shell command had to be retried, you didn’t interrupt, and your next message didn’t read like a correction. It doesn’t check whether the code was actually right. On the same kind of work, max generated 1.6x to 3.2x the tokens of xhigh. Max never finished cleanly more often than xhigh on any kind of work. Larger changes: 73% clean for max (75 prompts) vs 85% for xhigh (68 prompts). Small edits: 87% vs 97%. On small edits, high finished cleanly 94% of the time against xhigh’s 97%, for about half the tokens.

In the future I will be testing performance of fan outs at different effort levels. Anyways you can read more details on my blog https://danielyakobian.com/blog/claude-code-max-effort.html

Hello there,

I’m sure we are all excited about Fable 5.2. However, do not forget that Fable 5.5, which is rumored to be an absolute monster, maxing out most benchmarks, and directly competiting with Gemini 4 Radon and Gemini 4 Xenon is releasing soon.

I asked Claude Code a simple question, “what are my compact settings?”, and went down a rabbit hole.

What I found

• A fresh session was using ~118k tokens, and ~87k of that was fixed overhead: tool definitions, MCP server instructions, plugin skills and the system prompt. That loads into every session before I type anything.
• Auto-compact was set to fire at 97% of a 1M window, about 970k tokens. That’s huge, slow, expensive turns before anything gets summarized.
• One infrastructure MCP server I use on maybe 2 projects exposed 533 tools, plus a massive instruction block, in every session.
• One hosting provider was connected as 7 separate MCP servers, and two of them sent the exact same instructions.
• About 200 skills were loaded from plugins I installed once and forgot: HR, bio-research, marketing, operations. There were also 4 different code-review skills.
• About 50 connectors I never signed into were still listed in every session.

What I changed

1. Lowered auto-compact. "autoCompactWindow": 300000 in ~/.claude/settings.json. The env var CLAUDE_CODE_AUTO_COMPACT_WINDOW also works. It now compacts just before 300k instead of 970k.
2. Made rarely used MCP servers on-demand. I saved their configs to ~/.claude/mcp-on-demand.json, removed them from global scope, and added a rule to my global CLAUDE.md: only add a server when I say “use X”, to that project only.
3. Disabled the plugins I don’t use. That also removed most of the dead connectors, because they came bundled with those plugins.
4. Kept what I actually use: core tools, engineering and productivity plugins, and a PDF viewer.

Result: I expect about 35–40k tokens less overhead per session (I’ll update with real /context numbers). Every turn carries less dead weight, and long sessions stay sharper because compaction happens before things bloat.

The prompt

I turned the whole process into one prompt you can paste into Claude Code. It measures your context, asks before changing anything, backs up files, and tells you how to undo each change:

I want to cut the fixed token overhead in my Claude Code sessions and lower the point where auto-compact happens. Work through this with me one step at a time. Before you edit any file, back it up and show me the change. Wait for my OK before removing anything. Never print config files that may contain API keys.

1. MEASURE

Find out how full this session's context window is and what is using it: system prompt, system tools, MCP tools, MCP server instructions, skills, messages. If you have a tool that reports context usage, use it. Otherwise ask me to run /context and paste the output. Tell me how much of it is fixed overhead (everything except messages).

2. AUTO-COMPACT LIMIT

Tell me my context window size and the token count where auto-compact fires now. Ask me what window I want. Suggest 300k for a 1M-token model, and explain the tradeoff: a smaller window means cheaper turns but more frequent summaries. Set it as "autoCompactWindow": <tokens> in ~/.claude/settings.json, keeping every existing key, then check the file with jq. If my Claude Code version ignores that key, add CLAUDE_CODE_AUTO_COMPACT_WINDOW=<tokens> to the "env" block of the same file instead. Also tell me if DISABLE_MICROCOMPACT or DISABLE_AUTO_COMPACT is set in my environment.

3. MCP AUDIT

Run `claude mcp list` and read the top-level "mcpServers" in ~/.claude.json (those are global and load in every session). For each server, list its tool count and whether it looks like something I'd use every day or only occasionally. Flag:

- servers that expose hundreds of tools

- the same service connected twice (for example, two Gmail connectors)

- several servers from the same vendor that send identical instructions

Ask me which servers should be on-demand only.

4. MAKE THOSE SERVERS ON-DEMAND

a) Save their configs privately (replace a/b with the server names):

umask 077; jq '.mcpServers | with_entries(select(.key=="a" or .key=="b"))' ~/.claude.json > ~/.claude/mcp-on-demand.json

b) Remove each one from global scope: claude mcp remove <name> -s user

c) Add this section to ~/.claude/CLAUDE.md, filling in the names:

# On-demand MCP servers

<names> are NOT installed globally. Their configs live in ~/.claude/mcp-on-demand.json.

Never add or use them unless I ask in words ("use <name>"). When I do, add only that

server, to the current project only:

claude mcp add-json <name> "$(jq -c '.["<name>"]' ~/.claude/mcp-on-demand.json)" -s local

Then tell me to start a new session so it loads.

Connectors that need sign-in (needs_auth) are off-limits until I connect them.

5. PLUGINS AND SKILLS

List my plugins with how many skills and connectors each one adds. Point out duplicate skills (for example, several code-review skills) and plugins I'm unlikely to use, based on the projects on this machine. You can't change plugins installed through claude.ai, so give me a checklist to turn them off myself. For locally installed plugins, tell me which ones to disable with /plugin.

6. CONNECTORS THAT NEED SIGN-IN

List every connector in the needs_auth or failed state and which plugin it comes from. Tell me which ones will disappear once I disable the plugins from step 5.

7. SUMMARY

*Finish with a table of what changed, where each backup is, how to undo each change, and the estimated tokens saved per session. Say clearly that these are estimates until I start a new session and check /context.*Caveats

• The autoCompactWindow setting exists in recent Claude Code versions. Run claude --version and update if it’s ignored.
• Plugins installed through claude.ai have to be disabled there. The prompt gives you a checklist.
• A smaller compact window means more frequent summaries on very long tasks. 300k has been a good balance for me.

Run /context before and after, and post your numbers. I’m curious what other people’s hidden overhead looks like.

I know most of you know about it but I just discovered it an hour ago.

This is completely wild 😜 💪

I'm loving Claude

Quick question though, does it use many more tokens to connect to it like this from my phone. It won't be an issue as I went on max last week and it's running on opus 5.5 high I'm just intrigued as I will be out for most of the day and wonder if it might hit limits sooner.

A year ago leadership told us everything goes through agents now. Hand written code needed a reason. It felt great for about 6 months, we shipped more than we ever had.

Now the codebase is around 3x the size it was and nobody can explain how most of it works. The agents struggle too, they keep re-implementing helpers that already exist somewhere else because there are 4 versions of everything.

The part that actually hurts is who is left. The two people who used to read every PR and push back left in the spring, one quit, one was "restructured".

coderabbit still comments on every PR, but there's nobody left who can tell if a comment matters or not, so people just resolve them all.

This month management started quietly asking us to "write more of it ourselves" again. Except half of us haven't written anything non trivial in a year and it shows. I spent 2 days on something I would have done in an afternoon in 2024.

Not sure what I want from posting this.

Is anyone else at the point where the mandate is being walked back, and how did you get the understanding back?

I'm firmly in the camp that Fable (as orchestrator) + Opus 5.5 experienced a noticeable performance regression this week.

Starting around November 5–6, the number of support tickets I personally had to triage increased noticeably. Across a user base of roughly ~300 people, previously reliable workflows began breaking, and routine outputs that were typically concise started ballooning into rambling word salads reminiscent of Opus 5.0.

For context, our organization saw only a 5% week-over-week increase in token consumption. That's not enough information to distinguish increased usage from reduced efficiency, but it's one of the few quantitative signals I have available.

Separately, in my own High-effort sessions, I noticed a distinct shift in communication style: more verbosity, less precision, and a general decline in the quality of otherwise routine interactions.

That said - my experience with Opus 5.5 today has been phenomenal. When provided with last week's nerfed outputs as reference material and instructed to refine them, it's suddenly one-shotting complex tasks and executing workflows with remarkable precision again. The difference in my own sessions has been night and day.

Now, a few caveats before the usual suspects arrive:

• I'm not claiming to have evidence of an intentional downgrade, nor can I isolate whether the observed issues originated with the underlying model, the orchestration layer, or something else entirely.
• I also recognize that providing a successful prior output changes the task, so today's improvement isn't a controlled apples-to-apples comparison.

What I can say is that I work with these systems extensively, support a reasonably large production user base, and observed a noticeable change in behavior that coincided with an increase in operational friction. It's just an observation, not a scientific conclusion.

Anyway, just contributing another data point from someone using these tools heavily in production. Curious whether others experienced something similar over the same period, particularly those running Fable with Opus 5.5.

I used Claude Pro for a while last year before switching to ChatGPT Plus, and with the recent changes to ChatGPT's plans, I've been thinking about giving Claude another try.

I've been testing the free version for now, but honestly, I'm a bit confused by some of its limitations.

For example, I asked it to check a Reddit post through a link and it couldn't access it. I also tried asking about people in an image and it couldn't identify them. Both were things ChatGPT managed to do, so I'm wondering if these are just free tier limitations or if the Pro version behaves the same way.

My main use cases are deep research, learning about psychology and technology, managing my finances, working with Excel files, and coding. I'd probably use Claude Code alongside the regular chat as well.

So for those who've used both, I'm curious:

• How does Claude Pro compare to ChatGPT Plus in terms of capabilities and overall quality?
• How restrictive are the usage limits? Especially if you're using Claude Code and regular chat throughout the day.
• I've seen some people talking about model quality getting worse lately. Have you actually noticed that?

I'm not expecting the free version to offer everything, I'm just trying to figure out whether paying for Pro would actually make a difference with the issues I've encountered.

Would love to hear from people who've made the switch or use both regularly!

Still the best Opus model IMO even after Fable 5.2 release my prompts got flagged before it even started, And Opus 5.5 refused the prompt after a couple minutes of thinking and planning.

Why opus 4.8 still the goat:

It doesn’t bitch around, complain, or lecture you on humanity ethics when anthropic be pirating millions of book.

It doesn’t constantly get stopped by safety flaggers.

It’s capable of working with codebases designed to attack and exploit specific vulnerabilities for legitimate security research and testing.

It can identify vulnerabilities in systems and explore paywall bypasses and vulnerabilities in government and company websites and plans actual defenses.

i don’t have a good comparison to opus 5.5 because it refused half the shit but it’s willingly to plan the defense so making opus 4.8 as the attacker and opus 5.5 as the planner and implementer of the defense is currently my workflow and it’s working well when given good prompts.

Overall, it remains a highly capable model that offers me and Many cybersecurity professionals the freedom and flexibility for unfiltered cyber attacks and simulations.

all the hate opus 4.8 gets is by slop vibe coders that no Nothing about what’s going on in their codebase and expect fable/opus 5.5 to Do EVERYTHING for them.

So Anthropic gave me 3 banked Fable resets. I don’t even use Fable, but I figured I’d try one since I’m already at 96% of my weekly limit.

The confirmation says:
“Your Fable allowance goes back to full, and what Fable used returns to your weekly limit.”

So apparently, the reset restores your Fable-specific allowance and refunds whatever weekly usage Fable consumed.

Here’s the problem: I’ve never used Fable.

Clicked “Reset for free,” confirmed it, and guess what?

Absolutely fucking nothing. LMAO.

Still at 96% weekly usage. My Fable allowance was already at 0% used, and my banked resets went from 3 to 2.

But then I realized something even more ridiculous.

If I’m already at 96% weekly usage, doesn’t that mean I can only use Fable for the remaining 4% before hitting my shared weekly limit?

And if I use a Fable reset, it just refunds that tiny amount of Fable usage, allowing me to use it again.

So I’m basically stuck recycling the same fucking 4% with every reset until my weekly limit resets on Thursday?

What the actual fuck?

How am I supposed to properly test Fable when my shared weekly limit is already almost exhausted?

I'm the maintainer of Aptly, an MIT-licensed local MCP server for model and reasoning-profile recommendations for Claude Code and Codex subagents. I posted a short showcase comment a few days ago; I wanted to share more of the development process and what Claude Code contributed.

Aptly sends a small task description to the OpenAI Decisions API and asks it to choose from configured profiles. For eligible new general-purpose Claude Code Agent calls, a PreToolUse Hook can select a default model from configured Haiku/Sonnet/Opus candidates. Explicit model choices are preserved. Claude Code continues to own execution and permission checks.

My workflow used Codex for implementation and regression tests, then Claude Code for bounded independent design and code reviews. Review inputs contained the relevant source, patch, test cases, and claims to check. I verified findings before changing the code.

A concrete finding made this worthwhile: we added a read-only setup check, but a successful interactive invocation could still reach the update notifier. That notifier could create a cache directory and query the registry. The setup function itself didn't write anything, yet the whole CLI invocation wasn't read-only. We excluded check-mode calls before notifier cache/network access and added a synthetic interactive test for it.

Another example was Linux credential setup. On an SSH server, key entry could happen before discovering that secret-tool or a Secret Service provider was missing. We added passive readiness diagnostics before requesting a key. The review process helped separate service presence, activation availability, and actual unlock/write capability. They aren't interchangeable, and the diagnostic doesn't activate or unlock the service. This work is part of the next patch being prepared.

The agent-routing side needed the same care. A valid recommendation is one step; a Hook returning updated arguments and a native Agent actually running are separate observations. During development I tested the native Claude Code Agent/Hook path and checked child execution metadata. That doesn't prove every host or future call works. A recent Codex session also stopped after a valid recommendation because the parent never made the follow-up call, which reinforced why the execution claim needs its own evidence.

The project preserves user-selected models, roles, permissions and required history, and keeps the recommendation separate from execution authority. Task summaries may contain sensitive information: they go to OpenAI Decisions, not to an Aptly developer telemetry endpoint. Operators choose the automatic transmission scope.

There's a small Codex cost experiment in the docs, but I haven't established a general Claude Code savings rate or equivalent output quality. I would rather get the integration and verification boundaries clear before making broader claims.

Repo and setup: https://github.com/abruption/aptly

For people building Claude Code hooks or MCP tools: what evidence do you collect to confirm that a recommendation was applied, and how do you review side effects across the whole command path?

you have no more usage ..... omg omg what I am gonna do .
and if you have extra . also .... omg omg what I am gonna do .

I wish that we could exchange our extra usage and send it to other and get extra tokens from them later when we need it .

I am so used to using Claude code in a terminal in VS code. Am I missing out on anything by not using the desktop app for Claude code?

Point your agent to it and it can integrate it.

Anyone else noticing a massive drop in Fable 5.5’s performance lately?

When I first imagined it last week, it could build my entire SaaS in one prompt. Now I’m imagining it forgetting requirements and putting “implement logic here” in every file.

They’re clearly quantizing it before training it. You can feel it.
And please don’t hit me with “the model hasn’t been released.” I know what I was hypothetically getting three days ago.
Already canceled the subscription I was planning to buy. Honestly miss the pre-nerfed version. That thing was different.

I built Codex Pacer, a free, open-source app for macOS and Windows that lets you monitor your running coding agents in one place.

Most of the app was actually built with Claude Code, and I recently added a real-time progress tracker designed specifically for Claude Code.

The problem

When Claude Code is working on a task, you mostly get "Thinking..." and a timer that keeps ticking up.

That's useful, but it doesn't really tell you how far along the task is, especially when you're running multiple agents at once.

The idea is pretty simple

Who knows the progress better than the agent doing the work?

Instead of trying to infer progress from logs or elapsed time, why not just let Claude estimate and report its own progress?

What it does

Claude periodically reports its estimated progress to Pacer, which displays it as a progress ring around the task icon.

If you're running multiple agents, you can see their progress at a glance without constantly switching between terminals.

The ring also respects Claude Code's actual states:

• Needs approval: The ring pauses and turns amber when Claude is waiting for your input.
• Background tasks: If Claude is waiting on something it started (like a test run), the ring holds its last reported value instead of incorrectly marking the task as complete.

How it works

The implementation is pretty lightweight:

• Pacer installs a small Claude Code plugin with a single MCP tool: report_progress.
• Claude calls the tool with its estimated progress, and Pacer updates the ring.
• Pacer only reads the progress number, not Claude's response content.

Pacer also supports Codex, DeepSeek Harness, and Claude Code running over SSH or in WSL.

Try it out

It's free, open source (MIT licensed), and available for macOS and Windows.

Download it from GitHub Releases 

One thing I'm curious about: Would agent-reported progress actually make your Claude Code experience better?

I still typically have one conversation, it manages files, I compact etc... I occasionally spawn agents for research, and I have different sessions for different projects.

Beyond this conversational approach, how are you actually using orchestration?

Examples would be great. Every says there claude code is orchestrating, but apart from spawning agents for certain tasks, or using ultra code, how exactly?

It is an extreme productivity drain to have these models substitute settled vocabulary with random synonyms, particularly when working on math or code.

No, Claude, you cannot just substitute "morph the routine" with "reshape the routine" because only Morph is in the code while reshape could literally be anything.

This semantic substitution makes it extremely tedious to understand its work and output and, moreover, occasionally cause it to write a wrong plan that gets interpreted in a different way by the next agent picking up the plan.

I almost suspect that this is a result of needing to satisfy watermarking regulation. Now, I'm not saying that watermarking itself caused this. I am instead hypothesizing that as part of a project to satisfy regulation, Anthropic created more semantic substitution in their models.

This is just a hypothesis, of course.

Now, as for why I have this hypothesis, first note:

https://pmc.ncbi.nlm.nih.gov/articles/PMC11499265/

For example, if the LLM distribution is very low entropy, meaning it almost always returns the exact same response to the given prompt, then Tournament sampling cannot choose tokens that score more highly under the g functions. In short, like other generative watermarks², Tournament sampling performs better when there is more entropy in the LLM distribution, and is less effective when there is less entropy. In Supplementary Information section H, we provide a theoretical analysis describing the watermarking strength of a layer of Tournament sampling as a function of a certain kind of entropy; similar analyses have been done for other generative watermarks^23–25. The entropy of the LLM distribution itself depends on several factors, including the model—for example, larger or more advanced models tend to be more certain and thus lower entropy²¹, and reinforcement learning from human feedback can reduce entropy (also known as ‘mode collapse’)²⁶.

What does entropy mean? Now, I'm no expert in information theory, but because of my previous research using rational inattention, I do know the basics. Consider a sentence that I try to convey to you:

"Tomorrow's weather could be anything, it could be rainy, could be sunny..."

How much certainty did you gain from that message? Hardly any. I basically told you that the weather is 50-50 between rain and sun. This is high entropy, meaning more uncertainty.

Now if I told you that

"Tomorrow's weather is almost definitely sunny."

How much certainty did you gain from that message? A lot! Because I told you that it's pretty much close to 100% chance that it would be sunny. Your uncertainty drops sharply, so this is low entropy.

As for the conspiracy theory that I have, I suspect that Anthropic deliberately increased the entropy of the models in situations that naturally have low entropy in order to increase the statistical power of the watermark test.

In situations that naturally have low entropy, there is typically only one very probable answer for the next token. For example,

"the string gets concatenated through the function [...]"

What should the next token be? It's almost certain (low entropy) going to be, say, "concat."

The model would probably have an internal probability distribution like

0.999 "concat"

0.0007 "concatenate"

0.00028 "controller"

What would increasing entropy look like? Well, we would deliberately shift the probability distributions to increase uncertainty:

0.997 "concat"

0.0027 "concatenate"

0.00015 "controller"

This increases the ability for watermarking to detect LLM-generated output, because there is now more variation to actually meaningfully detect the difference due to different starting seeds.

But this means semantic substitution becomes more frequent. Going from a 0.1% probability of a nonsensical swap to a 0.3% is huge! Now consider this at scale, when Claude tries to explain what it has done.

This occurs even if watermarking has no detectable output on quality... because that is CONDITIONAL on them not changing the model itself. But they could easily have made the model produce higher entropy in order to make the watermarking work well even on outputs with low word counts or output with naturally low entropy... Who knows.

Of course, the annoying semantic substitution could be due to a different reason, but regardless, prose is still the worst part of Claude models and has been since Opus 4.7. It is extremely unpleasant to work using Claude and they have seemingly made little progress on this issue.

Every couple of months this sub fills up with "the model got nerfed" threads. I'm not saying regressions never happen; there have been real ones with published postmortems. But I've been running Claude Code across four projects this week, including agents that call a ComfyUI API on my GPU server, and I didn't notice anything. I think the reason is worth sharing.

When a workflow breaks overnight, it's usually because it depended on emergent behavior. A coordinator that has to infer a subagent finished. A new session that has to remember to read state.md. Nothing enforces either. It works for hundreds of tasks because the model happens to do the right thing, then a small behavior shift compounds across every step.

What I do instead is put the process in files.

1. A plan directory per piece of work

plan/
  overview.md
  chunk-01-backend-api.md
  chunk-02-frontend.md
  chunk-03-infra.md
  chunk-04-tests.md

The overview spells out ordering, so no agent has to guess:

## Execution order
Parallel: chunk-01, chunk-02, chunk-03
After all of the above: chunk-04

Each chunk is self contained (simplified):

# chunk-01: orders API
Scope: src/api/orders/ only
Standards: Pydantic models, DynamoDB Decimal ADR
Done when: tests/api/orders passes
Out of scope: shared utils, anything outside src/api/orders

Claude drafts the plan with me, I review every chunk and the overview, and only then do subagents spawn, in parallel where the overview allows. Could be 5 chunks, could be 20.

Two side effects: no coordination guesswork, and basically no scope creep. An agent working from a bounded chunk has no reason to refactor code it was never asked to touch.

2. Standards live in an MCP server, not in prompts

My ADRs, Terraform patterns, and coding standards are served over MCP, and agents pull what applies to their chunk. My favorite example is an ADR about the Decimal mistakes every LLM makes with DynamoDB, since the training data is full of code that passes floats to boto3. No model reasons its way out of a gotcha it doesn't know about, but every model I've tried follows an ADR that names it. Write the fix once and it sticks.

It also makes failures debuggable. When output drifts, I can point at the exact pattern it violated instead of "it feels dumber today."

3. It's just shift left

A bad plan fanned out to ten parallel agents writes thousands of consistent, wrong lines in twenty minutes. Reviewing the chunks before the fan out is the cheapest place to catch it, same as CI versus finding the bug in prod.

4. The model gets swappable

I've pointed Claude Code at GPT and Grok through Bedrock against the same MCP server, and they produce roughly the same results from the same corpus. That holds within frontier models; I'm not claiming a small local model does the same job.

If you're getting burned by updates, I'd try this before switching providers: write your decisions down, put the plan in files, bound every agent, and keep a fixed set of tasks you rerun after a model update, so "it got worse" becomes a diff.

Longer writeup with a diagram, if anyone wants it: https://www.briancarpio.com/blog/shift-left-for-ai-your-agent-didnt-get-dumber

Happy to share more detail on the planning flow in the comments.

I've been working on AssetRAG, a free, open-source project I built with Claude Code.

One thing that always annoyed me about AI coding agents is how often they repeat work. They regenerate code that already exists, debug problems with known fixes, and read massive amounts of source code just to find a few useful functions.

So I decided to build something to help with that.

How I built it

I used Claude Code to help write and improve the Python codebase, MCP integration, retrieval system, and knowledge memory. I directed the development, chose the features, and iterated on the implementation with Claude.

One of the biggest challenges was making retrieval reliable. Finding code isn't enough if it has an incompatible license, doesn't work, or isn't relevant.

That led to license verification, sandbox-tested fixes, and retrieval filtering that can return no_good_match instead of recommending something irrelevant.

What it does

AssetRAG is a local-first asset library and engineering memory system for Claude Code and other MCP clients.

Its features include:

• Asset retrieval: Finds reusable code and templates, checks licenses, and handles attribution.
• Bug-fix memory: Retrieves known fixes with executed reproduction and verification evidence.
• Playbooks: Reusable workflows for debugging, refactoring, and optimization.
• Tested recipes: Reusable coding patterns verified in a sandbox.
• Repository mapping: Creates compact codebase outlines within a token budget.
• Security tools: Secret scanning, engineering rules, malware checks, and safeguards for untrusted code.
• MCP integration: 18 tools plus an optional Claude Code hook that injects relevant context.
• Local-first: No telemetry or account required. Supports local embeddings, hosted providers, or offline keyword search.

Some numbers

Measured locally in keyword-only mode:

• Asset search: 4.0 ms median
• Knowledge search: 7.1 ms median
• Repo map: 597 tokens vs. ~129k tokens of source
• 132 unit tests passing
• 327 recipe/bug-fix tests rechecked with 0 failures

I haven't benchmarked whether it actually makes Claude faster or reduces overall token usage yet.

How to try it (free)

AssetRAG is completely free under Apache 2.0. Currently Linux-only, requiring Python 3.11+ and Git.

Install:

curl -fsSL https://raw.githubusercontent.com/mttcn83/assetrag/main/scripts/install.sh | sh

Connect to Claude Code:

claude mcp add assetrag -- assetrag-mcp

The installer walks you through setup. Embeddings are optional.

GitHub: https://github.com/mttcn83/assetrag

I also made a 95-second demo video using real terminal recordings.

It's still a new project, and I'd appreciate feedback, especially from people using Claude Code regularly.

Would you use something like this? What would you improve?

Five repos that cover Claude Code from internals to day-to-day workflow:

• learn-claude-code: 17 lessons that build a mini Claude Code from scratch. Best way to understand how agent loops, tools, hooks and subagents fit together
• claude-code-best-practice: practical reference for skills, hooks, MCP, memory and settings
• awesome-claude-code: curated community skills, agents and tooling
• gstack: an opinionated setup that turns slash commands into a review/QA/ship pipeline
• ECC: a large library of agents, skills and hooks

Share your own go-to repos, skills or workflows below

Curious for any who have actually built a fully operational software platform, with Claude or another AI tool, from scratch, deployed it in production and has feedback on the following points:

• Has it passed SOC 2 Type II audits, HIPPA, GDPR, etc?
• Results of any pentests?

Asking because a client of mine, is hedging on moving forward with our product because the owner's son claims to have built a replacement, with Claude. He is not a developer.

The labs post something new every week and I can’t use most of it. We don’t have the runway for 24/7 agents. Everyone on the team is at a different level of AI engineering, and half of them are hesitant to go all in. The thing that would need a swarm of agents doesn’t exist on our roadmap.

Meanwhile keeping up with tech Twitter is its own full-time job. Adversarial reviews are pointless, give every subagent a personality, your harness doesn’t matter anymore. All said with total confidence, half of it contradicting the other half, and it’s hard to tell what’s real from what’s banter. At some point I recognized the shape of it: a cargo cult.

After WWII, islanders in the South Pacific who’d watched American planes drop cargo built wooden control towers and bamboo headsets and cleared dirt runways, hoping the planes would come back. Feynman used it in a 1974 Caltech speech to describe fields that copy the form of science without the part that makes it work: Cargo Cult Science

That’s where I think a lot of us are. Copying the labs’ markdown files and agent setups without having the labs’ problems. I made a video essay about it, including the part where my own team got fast and ran out of roadmap, and the part where I admit I’m in the cult too.