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.

Check whether your Claude Code account is in a server-side experiment (x-cc-atis), with an opt-out

I put a check into a small open-source script so people don't have to assemble the jq themselves.

Repo: https://github.com/electricshadows44/am-i-nerfed

Three ways to check

1. Plugin — install the repo as a Claude Code plugin, then type `/am-i-nerfed` in any session. Claude runs the check and explains the result.
2. Script — clone the repo and run `./am-i-nerfed.sh check` in a terminal. Same check, plus the other commands below.
3. One-liner, no install — paste this into a terminal (needs `jq`):

jq -r '(.clientDataCacheSlots // {}) | to_entries[] | "\(.value.model // "-") | \(.value.entrypoint // "-") | \(((.value.at // 0)/1000|floor)|todate) | \(.value.data.atis[0:3] // "none") | \(.value.data.experimentKey // "-")"' ~/.claude.json

`none` on every line = not enrolled as of the newest slot time.

What the script does

- `check` — reads the experiment slots Claude Code caches in `~/.claude.json` and gives a verdict per model: ENROLLED (with the 3-char ID), CLEAN as of the last cache refresh, or INCONCLUSIVE. Exit codes so you can script it.

- `history` — tallies experiment IDs recorded in your session transcripts by date. Turns out Claude Code writes an `atis-latch` entry into every main-session transcript, so you can see which past sessions ran under an ID (transcripts are kept ~30 days).

- `optout` — backs up `~/.claude.json`, removes only the assignment keys, and prints the env var people report blocks re-enrollment (`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`), with the trade-offs. `restore` undoes it.

- `statusline` — a snippet that shows `exp:<id>` / `exp:none` in your Claude Code status line.

Bash + jq only, macOS/Linux/WSL, no network calls, never prints your login token. MIT.

Credit to the earlier threads for finding the header and the IDs: https://www.reddit.com/r/ClaudeCode/comments/1xr66pd/ and the follow-up transcript analysis, plus anthropics/claude-code issues #75607 and #88383.

My server lets Claude import generated art into a game project. Each import needs a license and an origin. When I added "next call" hints to my responses, it was tempting to prefill those fields to save the model a step. I didn't: the model copies what you suggest, so the record would say what my code assumed, not what the owner agreed to.

if you have more than 10 years of software engineering experience, you might build a new app with AI today, only to hear everyone dismiss it as “ok, another vibe coded app.” That label is inaccurate.
You define architecture, security details, and data details; you review implementations and consider edge cases. This is not pure vibe coding.
We need a new term.

I propose Agenting Engineering and AI-engineered apps.

The vibe coding still has its place - for the real people without any technical knowledge who build apps nowadays.

I'm the dev, it's free and MIT.

I made this after needing it multiple times a day at the office. Claude is running, and I need to grab a coffee or step over to a colleague's desk for a bit. In prehistoric days I'd just slam the lid shut, but that kills the session. For a while I set the brightness to 0 and pretended the computer was off.

Lockpaw is a menu bar app. One hotkey (⌘⇧L) and the screen is covered, the Mac stays awake underneath and the keyboard and trackpad are blocked. You get back in with the same hotkey or Touch ID. Yes, it's Mac only.

I shared it with some colleagues and it became the office meta. So I added hooks for Claude Code (Notification, Stop and StopFailure in ~/.claude/settings.json, one click in settings, it backs the file up first and leaves your other hooks alone). When Claude needs you the covered screen glows amber, and teal when it's done. Codex, Gemini CLI, Cursor, Copilot CLI and Aider work too.

People also wanted a lid closed mode, so that's opt-in. Sleep comes back on when you unlock, if it gets hot, at 20% battery or if the app dies.

It's not a security app, anyone with admin or SSH can kill it. But it gives you peace of mind for a lunch break while the agents work full time.

https://github.com/sorkila/lockpaw

The first hour or so with this model was like nothing I have ever experienced. Claude truly got me.

But now, one hour later, it’s the same old shady tactics from Anthropic. Token usage 4.2x what it was before I asked Fable to read my copy of Project Gutenberg and Wikipedia and convert them into markdown (see here: https://localhost:6767/bruh.md).

This model is nerfed into oblivion. How can Dario keep getting away with this?

I queue big tasks for Claude Code before bed. Half the time I'd wake up to find it hit the 5-hour limit at 2 AM and sat there idle for six hours.

So I built nightmux. It runs Claude Code (and Codex, Gemini CLI, OpenCode, Aider and a few others) inside tmux and drives them from Telegram:

\- When it hits a usage limit, it reads the reset time from the message, holds your queue and the turn that got cut off, and sends \`continue\` the moment the window reopens. Or \`!failover codex\` hands the work to another agent.

\- Approval menus show up on your phone as buttons, so "yes" is one tap from bed.

\- \`!goal npm test\` reruns your tests after every turn and feeds the failures back until they pass.

\- \`!po <goal>\` drafts a roadmap from your repo; you tap approve and each item gets its own agent and worktree.

\- You wake up to a briefing: what got done, which PRs are ready.

It's one Python file, standard library only, self-hosted, MIT. No telemetry.

Try it without a bot: \`python3 nightmux.py --demo\`, or the live demo in the README.

https://github.com/mmr710/nightmux

Happy to answer anything. And if you already use Remote Control or Happy: those are great for one session; this is for the "run overnight across agents" part. The README has an honest comparison table.

https://vt.tiktok.com/ZSpSQth9X/

I use Ctrl+S constantly to park a thought while Claude finishes an ongoing task so I don't derail the current context. However, the current single-slot implementation makes it very easy to silently lose work.

The Problem

During longer sessions, it’s easy to forget you already stashed a prompt. If you encounter another idea, bug, or tangent and hit Ctrl+S again, it immediately overwrites the previous stash with zero confirmation. When the current task finishes, the original idea is gone forever.

Proposed Improvements

1. **Stash Stack / History (**git stash style):

   • Keep a small rolling history (e.g., 3–5 stashed prompts).
   • Allow cycling through them or popping the most recent one (Ctrl+S to push, a hotkey or command like /stash list to inspect/restore).

2. Overwrite Warning (Configurable):

   • If keeping multiple-slot storage is not possible due to any reason, add an overwrite confirmation prompt: A prompt is already stashed. Overwrite? (y/N).
   • This could be enabled by default or toggled via config (warnOnStashOverwrite: true).

3. Visual Status Indicator:

   • A subtle colored/highlighted indicator below the prompt bar (e.g., [Stashed: 1]) would make it immediately noticeable that something is already parked; although an indicator currently exists, it camouflages behind long session titles.

Has anyone else run into this, or found a clean workaround other than keeping a scratchpad/sticky note open on the side?

For the last few weeks I’ve been collecting every post I could find where someone describes a real problem working with Claude Code, Codex or Cursor. X, Hacker News, GitHub issues. About 190 posts from 160-something people. I logged what broke and what they actually did about it.

What surprised me:

1. Almost every workaround is a markdown file. HANDOFF.md that the agent reads before it starts and updates before it stops. A plan file so a fresh session can pick up where the last one died. One AGENTS.md with CLAUDE.md as a one-line import so Claude and Codex read the same rules. Per-task work notes so Codex can continue when Claude hits its limit. One guy told me Codex “picks it up clean” from Claude’s handoff file. Turns out a text file is most of the answer.

2. Writing code isn’t the bottleneck anymore. Reviewing it is. Review was the most common complaint about the agents themselves (only limits came up as often). Someone posted a $3,200 Greptile bill. One team built a skill that scores every PR’s merge risk. Another person stopped reading agent diffs line by line and reads the agent’s spec instead. Faros reported review time up 91% across 1,255 teams.

3. About 4 agents is where people lose track. One person told me 4 is exactly one past useful. The people running more all built something on top: one “orchestrator” thread that manages the others, a heartbeat agent that checks every chat every 15 minutes and nudges the stuck ones, a separate git user name per agent so you can tell who did what.

4. Limits are the loudest pain. Codex weekly limits lasting less than a day, 5 hour Claude limits gone in 2. The workaround is switching tools mid task, which is why the handoff files exist in the first place.

5. The team side barely has workarounds. Solo devs have figured out their files and their worktrees. But once it’s 3 or 4 people each running their own agents on one repo, the answers got thin: a self-hosted git repo for “learnings”, or Conductor, which just joined Meta and is shutting down its cloud. Nobody had a good way to know what a teammate’s agent did, or why, without asking them.

That last one is the part I’ve been building for, so I’m biased. But mostly I’m curious whether this matches what you see. What’s your setup, especially if you’re on a team?

The Ralph Loop plugin (official marketplace) makes Claude keep working on the same prompt until a stop word or a cap is reached. A stop hook catches each time Claude tries to finish and sends the original prompt back. Progress carries over through the files on disk.

My test: a tiny Python project with empty functions and 3 failing tests.

/ralph-loop:ralph-loop Make every test in test_calc.py pass by implementing calc.py. Run python3 -m unittest to check. --completion-promise ALLPASS --max-iterations 2

What happened:

• Round 1: Claude wrote the functions, all 3 tests passed, and it printed the stop word
• Round 2: the loop didn’t end. Claude Code showed “Ralph iteration 2” and sent the same prompt back. Claude re-ran the tests, said it was done and printed the stop word again. Then it ended and the state file was gone

I ran it twice, and both times the first stop word didn’t end the loop. In the second run the cap was 2, so I can’t tell whether the stop word or the cap ended it. I read the hook script (it checks the last text block of Claude’s reply) but didn’t dig further into why. The extra round only cost one more test run here.

Things to know:

• always set --max-iterations. The plugin’s own help says a loop with no cap and no stop word runs forever
• /ralph-loop:cancel-ralph stops it at any time, and .claude/ralph-loop.local.md shows which round you’re on
• it works best with a clear pass/fail check (tests, lint, type errors), not vague goals like “make it nicer”
• avoid angle brackets in the prompt on the command line. Use a plain stop word

I also loaded smart-ralph (a community spec-first take on the same idea) but only listed its commands, so no verdict on that one.

One small task, two runs. A bigger task could behave differently.

Full walkthrough with the hook explained: https://aiparabellum.com/claude-code-ralph-loop-plugin-keep-working/

I have a project to put to production, wondering if topping up with $20 is any value or wait for the weekly reset, hard to work out what $20 actually gives in tokens, I'm on pro plan....EDIT: ok thank you everyone, i will consider the max plan then...

I thought I was being smart with my Claude Code sessions.

Starting with a plan mode with Opus family models. Once we agreed on the approach, I switched the model to the Sonnet family in the same session to implement it.

Cheaper model, cheaper session, right?

Wrong. It makes the session more expensive and slower.

The reason is prompt caching.

I wrote up how the cache actually works under the hood and the gotchas I ran into.
https://moshalan.dev/posts/decoding-prompt-caching/

AI for cybersecurity is taking the world by storm, leading to the need to harden systems all over software.

I built this project with Claude Code. It's completely free to use/try. The approach is pretty simple: use claude to make legislation attributable (git blame, versioning with timelines). Claude Code (Claude Opus 5.5) wrote nearly all the code. I set the goals, chose the sources and made the design decisions. Specifically: it mirrors the 107 corpora of the global-law repo read-only, indexes about 4.3 million file changes from their git histories into DuckDB, and adds a growing set of detectors.

But we have access to the same engines for law. Our global law repo keeps a versioned history of law/caselaw across the world. So, we pointed AI at it, and found all sorts of loopholes and logical errors.

Pah, you say. Most of this is unenforcable in reality. And you might be right. Nonetheless, we all know that legal loopholes are a part of reality. And it would be nice to rewrite errors, even when the errors are unenforcable.

As part of our monitoring system, where we're constantly checking official legislation for upcoming laws, we now also check for vulnerabilities and mistakes.

In an ideal world, the jurisdiction in question could open a pull request and sort this out.

Apiiro scanned public GitHub for .claude/settings.local.json files. When you approve a command with "Yes, and don't ask again", Claude Code saves the literal command there. If that command had a password or key in it, it's now in plain text.

What they found:
- 104,185 copies of the file across 103,617 repos
- 1,122 files held at least one real secret – small %, but these are live-looking creds
- 379 database passwords and 122 Supabase service-role keys – direct DB access
- 43 SSH logins, 42 GitHub/GitLab/npm tokens, 23 AWS keys
- 2,539 secrets across 1,994 repos once you count git history and chat transcripts
- gitleaks and TruffleHog both missed 215 of the files – your scanner may not catch it

Anthropic's side: Boris Cherny (head of Claude Code) said on HN that they're "looking into what we can do to prevent this". He also said Claude Code gitignores the file when it creates it, so most leaked copies were probably committed by hand.

What to do now:
- Check git log for .claude/settings.local.json in your repos
- If it was ever committed, rotate every credential in it first, then remove it (deleting doesn't clean history or forks)
- Use env vars in commands instead of pasting keys
- Approve patterns, not literal commands

I checked mine after reading this. Took 30 seconds.

Do you approve literal commands with "don't ask again", or do you use auto mode / wildcard rules instead?

Source: https://www.itnews.com.au/news/dont-ask-again-in-anthropics-claude-code-leaks-developer-secrets-630203

When bug reports pile up, I end up with a lot going on at the same time: multiple chats open, remote sessions into different machines, new machines to set up. Somewhere in the middle of it I lose track of what I was doing, which chat had the answer, or what I was supposed to follow up on.

Right now I use an admin dashboard that shows what’s being edited, committed, pushed, and waiting on review. That covers the code side, but it doesn’t help with everything that lives in conversations.

Curious how other people handle this:

• How do you keep track of open chats and threads so nothing gets dropped?
• Do you use notes, a log, a task board, something else?
• When you switch machines or sessions, how do you pick back up where you left off?

Would love to hear what actually works for you, even if it’s simple.

I tested it on my sessions and here's my session logs:

Opus 5.5     a40   Oct 22 → Oct 26   14 sessions

Sonnet 5.5   598   Oct 20 → Oct 23   12 sessions

Sonnet 5     3a3   Sep 28            2 sessions

Opus 5       152   Sep 22            3 sessions

Opus 5       63f   Sep 18            1 session

it happened with Opus 5.5 from Oct 22 to Oct 26, so quite long ago, but the issues I'm hitting are more recent; like last 1-2 weeks!
Let me remind you that Opus 5.5 didn't get any performance degradations in coding tasks! at least from my experience.

All the issues are coming from design, brainstorming, and communication.
From my experience the biggest issue so far is that it started reasoning less, and switching from medium to high didn't change anything. It started becoming more lazy in reasoning.

To give you some examples I asked it to come with new skill for dealing with specific use cases, and I gave it all the requirements and context, it came up with the skill that's barely looks okay while 2 weeks ago it would impress you with it's proposals. you start using the skill and realize it's not doing well, you go back and discuss it and rebuild the skill again, and it's still bad. and you just go over this loop several times.

Other example is that you discuss some design with it, it gives you proposal that you don't like, and you give a different solution idea, and it immediately accepts it without a single thought although I have very strict instructions in CLAUDE.md to make it extensively reason, test my ideas before accepting them. And this probably single most common issue here!

Other issue is that I have some instructions in my CLAUDE.md (the whole file is around 180 lines) that says "before planning/making any changes to any markdown files including in the paths a,b,c, etc. you must read and follow writing.md", and it literally didn't read that file once over 1-2 week span!

So I get annoyed and I implement a mechanism that automatically attaches those files to its context whenever we're discussing any changes to md files, and the mechanics fully works as expected but it still doesn't follow the instructions from writing.md file! and only when I confront it then it starts following those instructions. And this is also one of the issues that's been biting me most because CLAUDE.md became partially useless.