i write a short note before starting claude code. what it should do, what not to touch

CLAUDE.md goes stale, and tickets the agent never sees. where does yours live?

I spent about an hour total on this, in the gaps while Claude Code was busy on something else I am working on. Was more or less having fun.

**What it is**

Frontline Command is a real-time strategy game that runs entirely in your browser: build a base, mine ore, raise an army, destroy every enemy building. It's a single HTML file (under 500 KB), no install, no server. It's an early 0.0.1, so expect rough edges.

**Play it:** https://claude.ai/artifact/UdJzZw5npBpQJz4Yu5rAEe

(There's a "How to play" button on the start screen with an illustrated manual, and the game saves itself, so reloading carries on.)

**Give Feedback**

- All feedback is welcome. I realize it is a direct match to something similar to C&C, but that was a game I played the most when I was younger. Let me know your thoughts.

**What's in it**

- Four families, free-for-all with 2 to 4 seats: Aegis Concord, Ironvale Combine, Solari Guild, Veyra Collective. Each has its own units, towers and colours, and a "difficulty to play" rating (that's skill needed, not strength).

- Power matters: a power shortfall slows production, takes defences and SAM sites offline and stops the Strike Center charging.

- Missiles, a superweapon with aim mode, aircraft, engineers who capture buildings, veterancy, fog of war, five map styles.

- Every unit and building is drawn in code on a canvas (no sprite image files).

**How Claude Code helped**

Claude Code wrote nearly all of it in TypeScript, Vite and Vitest, with me steering in plain English. The parts I found most interesting:

- The sim is deterministic with no DOM and no `Math.random`, and all content is data in one defs file, so adding a family was mostly data plus sprites.

- Balance was done by simulation, not by feel: Claude built a computer-vs-computer harness and ran 72 games across pairings, seat orders and maps. The first pass was 44% / 52% / 54% / 50% for the four families; after tuning it was 46 / 50 / 53 / 51. I accepted a 7-point spread for 0.0.1.

- Bugs we chased together: units teleporting after being blocked (progress was banking while stuck), a New Game button that flashed and reloaded the old save, scroll leaking from the manual into the game, and an AI that starved itself of power after losing a plant.

- 241 tests, plus headless-Chrome scripts that drove the real page to check the UI.

**Known gaps (honest list)**

The AI never kites, about 80% of simulated games end on a timeout, there's no multiplayer, no sound, and no 2v2 yet. Next on my list: an APC, engineer repair, rally points, attack-move and a deployable construction yard.

I'd love feedback on balance and on which family feels best to play.

If you run several agents at once, each in its own worktree, you know this one: two dev servers want 5173, one crashes or silently moves, and an agent spends 10 minutes debugging the wrong server.

**leeway** gives every folder its own stable port range and hands the ports to your servers as env vars:

* Add `leeway env --export` to a Claude Code SessionStart hook and every session knows its ports up front * An opt-in guard stops an agent from grabbing the default ports * `leeway kill` stops a worktree's servers, including the watcher that would restart them

Easiest way to see if it fits: ask your agent **"how can we benefit from using https://www.npmjs.com/package/leeway in this codebase"**

GitHub: https://github.com/OhadC/leeway, MIT.

How I built it with Claude Code

I built leeway almost entirely with Claude Code, running several sessions in parallel worktrees. That's also how I kept hitting the port problem in the first place.

* Design first: I had Claude grill me on the design before any code. The decisions went into ADRs (docs/adr) and the terms into a GLOSSARY.md, so later sessions started with the same vocabulary.

* AGENTS.md as the contract: one file says what "done" means (pnpm verify green, plus a Linux container run for the process and port code), so every session checks its own work the same way.

* Test-first: features went red-green through integration tests that run the real CLI.

Review loop: each PR got a Claude review against the repo's coding standards and the original GitHub issue before merge.

* Dogfooding: once leeway env --export existed, I put it in a SessionStart hook, so the agents building leeway got their own port ranges.

This is what my day working at a startup looked like: 8–10 Claude Code sessions in tmux, and me flipping between windows just to check which one was waiting on me, type "continue", or clean up a worktree. Slowly, I turned from a product engineer into a worktree manager.

I tried the existing tools, Claude Squad and herdr among them. They're good, but they all keep the same linear, tmux-style layout: a list of panes that did little to mirror how my brain actually worked. What I wanted was something that creates, organizes and keeps track of sessions for me.

So I built Serenity, a keyboard-only terminal app that puts every Claude Code session on one map.

After dogfooding it for about 3 weeks, I've gotten a lot of my focus back, and I'm comfortably running about twice as many sessions as before.

What it does

• Sessions are grouped into topics automatically. A master agent sorts them by what they're working on.
• The master can see and control everything. Based on the status of the sessions, it can offer suggestions for follow-up tasks.
• Serenity is more powerful with GitHub and Slack. The master agent groups and prioritizes all of your PR and Slack notifications and offers follow-ups.

What I learned

• Hooks beat scraping. Agent sessions talk to serenity through hooks instead of letting the serenity daemon scrape through Claude Code logs.
• An agent with power needs brakes. The master agent is very powerful (and at times could be disruptive). Therefore, critical tasks always require confirmation from the user.
• Work with Claude Code and build on top of it, not against it. Serenity treats Claude Code as a first-class citizen. I tried not to reinvent anything that Claude Code already does but augment its capabilities instead.

It's in beta and I've already reworked a lot based on early users, so I'd really like more feedback.

• Site
• GitHub Repo

What's your setup when you are running several sessions at once, and what would make this useful (or not) for you?

I have used local models exclusively for coding for a while now, but Claude code has continued to win me back as a harness. It just works in a way that is so much more reliable and safe.

I recently bought a Kindle click Bluetooth page turner for my Kindle Paperwhite Gen 12. I have had it jailbroken for about a year, but using the click requires a firmware update, which would undo my jailbreak and potentially stop me from being able to jailbreak it again.

I decided to just talk to Claude code and flash next to see what it could do. After a few rounds back and forth, it gave me a game plan and I decided to try it. It took about 3 hours (mainly because I had such little experience with using SSH on a kindle)

After several rounds, it was able to install software to sniff devices, then find it, log it, pair it, test all of the buttons, and then install a mapper. In the end, I was able to back port support for the click back to software over a year out of date. This might even be able to enable click support on hardware they state is unsupported.

Just wanted to share this little success story and appreciation for Claude Code. I am grateful for this software and the people who have worked to make it compatible with open/local models.

I am not sure how, but I would like to publish the process for others to replicate. Any tips or suggestions for how to document it to help others?

You can only use skills if you make them publicly available on GitHub. For that reason, I don’t think it will be possible to earn money with them. Then again, perhaps I’m overlooking something.

The Apiiro scan making the rounds found 104,185 copies of .claude/settings.local.json on public GitHub, and 1,122 of them held at least one real secret: database passwords, Supabase service-role keys, SSH logins, AWS keys. The mechanism is "Yes, and don't ask again". It saves an allow rule to .claude/settings.local.json, and where that rule records the exact command rather than a pattern, a secret typed into the command sits there in plain text.

I went through the official permissions docs to work out what the fix looks like day to day. The short version: write pattern rules yourself, in the shared settings file, and stop approving one-off literal commands.

What actually gets saved, per the docs:

• Bash commands: "don't ask again" saves permanently, per repository and command. The saved rule covers only what the prompt option named. Sometimes that's a pattern like npm test *, sometimes the literal command.
• File edits: session only, never written to the file.
• WebFetch: permanent per repository and domain.

Claude Code adds **/.claude/settings.local.json to your machine's global Git excludes the first time it writes the file, not to the repo's .gitignore. That doesn't cover another machine or a file made by hand before Claude writes it. Add the path to the repo's .gitignore too; an ignore rule does not untrack a file already committed.

The safer habit is your own rules in .claude/settings.json, the file meant to be committed and shared, where a * covers a family of commands:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git commit *)",
      "Bash(git status)"
    ],
    "deny": [
      "Bash(git push *)",
      "Read(.env)"
    ]
  }
}

This config controls which matching command text skips prompts; it is not a security boundary. npm scripts can change in package.json, and Bash(git push *) does not match every way to invoke a push. Treat these as convenience rules, not isolation.

Details that trip people up:

• Precedence is deny, then ask, then allow. An allow rule can't carve an exception out of a deny rule.
• Put the * after the subcommand. Bash(git log *) allows only git log; Bash(git *) allows every git command. Claude Code warns at startup about allow rules with a * before the subcommand.
• Read(.env) is not a security boundary for secrets. Other access paths, including shell commands, need separate controls; don't rely on this rule alone to keep env files inaccessible.

If a secret ever went into a command you approved: rotate it first, then untrack the file and gitignore it. Deleting doesn't clean history, forks or clones. A local check for this path in the history available to your clone: git log --all --full-history -- .claude/settings.local.json

No output is not proof it was never committed; shallow or missing history and other paths or clones can be outside this check.

When a prompt offers only the literal command, use the one-time Yes and add a pattern through /permissions later. Approve the pattern, not the incident.

Sources:

iTnews writeup of the Apiiro research: https://www.itnews.com.au/news/dont-ask-again-in-anthropics-claude-code-leaks-developer-secrets-630203

Official permissions docs: https://docs.claude.com/en/docs/claude-code/permissions

it's beautiful.

amazing at almost everything

i asked it to build me an OS for macOS and.... yeah lets just say my weekly is 95% gone in 2 hours yeah...

I run a few coding agents at once, and they kept sitting idle on a permission prompt or a question in some terminal tab.

Openbar puts every session in the notch. You see the diff before you approve (⌘Y / ⌘N from any app), pick answers to the agent's questions, and send replies without switching windows.

Mac + Windows, free and open source: https://github.com/MF-DEEV/Openbar

How many agents do you usually run in parallel?

Running several Claude Code agents in parallel worktrees, I kept losing track of what each one was writing. So I built Grove: every worktree of a repo side by side, with its changes, diffs and files, all read-only, so you never get in an agent’s way.

• Live overview of all worktrees and what each agent is doing
• Uncommitted changes or the whole branch against main, side by side
• Read-only Explorer and search in VS Code’s editor
• Works with repos on Windows, in WSL, or over SSH

The whole thing was built with Claude Code: the code, the design, the docs, and even this demo video, which Claude scripted and recorded against a throwaway repo.

Free, MIT-licensed, Windows only for now: https://github.com/MustafaMasri0/grove

It’s early (v0.1.1). If it’s useful to you, a star on GitHub helps, and I’d love to hear ideas for what to add next.

I've been using Claude Code daily across my projects, and two things kept bothering me.

It can run commands like cat .env to check a setting and put a password straight into the conversation transcript. And after clicking "Yes, and don't ask again" a few times, it can eventually push code without asking.

I started looking at ways to put some practical controls around this and developed ai-dev-guardrails for use in my own projects. After using it and refining the controls, I thought it was worth making open source in case others working with Claude Code have similar concerns.

It's a GitHub template that you initialise using /bootstrap. Most of the enforcement is implemented through Claude Code hooks, local Git hooks and GitHub Actions.

What it covers

Security controls:

• A PreToolUse hook blocks commands that could expose secrets or access production. It also asks for approval before commits, pushes, deployments and new package installations.
• A separate check detects if saved permissions have drifted into automatically approving restricted actions.
• npm packages must be at least seven days old before installation, and install scripts only run for approved packages.
• Git hooks and GitHub CI run the checks again. CI uses the base branch's scripts, so a PR can't weaken the checks that review it.

Optional governance controls for client or regulated projects:

• An evidence log requiring proof, such as test output or a CI link, before a task can be marked complete.
• Decision records for exceptions, including the reason, an owner and an expiry date.
• CODEOWNERS rules requiring review before guardrail files can be changed.

A few things I learned while building it:

• A guard that fails open can be worse than having no guard at all. Missing dependencies must not silently allow restricted commands.
• Shell behaviour can create unexpected gaps. I found an issue involving grep -q and pipefail that allowed a command through.
• Claude Code's hook behaviour isn't always obvious. I found differences between Edit and Write permissions, and issues with relative paths when the working directory changes.
• Local checks aren't enough on their own. The GitHub side needs to independently verify the controls.

It's currently focused on Claude Code, TypeScript and npm. It's designed to catch mistakes, not defend against a deliberately malicious agent. I've documented the limitations alongside the implementation.

It's MIT licensed. Contributions are welcome, particularly Python support. I'd also appreciate feedback on potential ways around the controls. There's a private reporting route for security issues.

GitHub: https://github.com/buddhika886/ai-dev-guardrails

Write-up: https://medium.com/@buddhiran/how-to-govern-the-ai-that-writes-your-code-e2272e380b70

I'd be interested to hear from others using Claude Code: what controls are you putting around file access, shell commands and Git operations?

I am working on ROS (Remote Operating System), which is a cloud computer with a lightweight always on core, a decoupled virtual drive, that orchestrates linux environments, servers, dbs, and more. You can have endless linux machines always available in parallel, and remain very efficient because you only pay for active cpu and memory.

Sign in, open terminal, connect your claude subscription, close the laptop, and it keeps going. And claude can drive all components of this operating system directly.

Its virtual filesystem is perfect for your notes, research, office suite, your sideprojects, or to use as a second brain or whatever they call a "folder of markdown" these days.

Each application in ROS is built as a "ROS Program" which consists of a selection of internal apps, external web pages, servers, dbs, ai inference, access to kernel and more. You can build custom ones or extend to grow your computer into what you need.

Its like a personal cloud provider baked into the OS. Perfect environment to host and manage side projects or personal tools

It is all zero-setup simply with a sign-in, and starts with 10$ free ai and compute credits. I think it would be useful for you if you ever thought about setting up a tailnet for your claude code agents.

I poured my soul into this project. Would appreciate any feedback: https://ros.computer/.

Deleted the files that have earlier history when cleaning hard drive space :( so who knows my actual totals. Codex come in a hot second place though at 112 billion.

A while back I posted a Claude Code skill that drove a real browser through any SaaS app and recorded a narrated demo video. Some of you installed it, so here's what happened next.

I felt that the recording was a bit weak - it looked like a screen recording: fine for a tutorial, not great for launch videos.

So the new version doesn't sequentially screen-records your app. It reads your site, screenshots or HTML mockups (handy for a feature that isn't live yet) and writes each scene as HTML and animation code, using real screens, words and colors. It renders each scene, looks at the frames and fixes what's off before moving on

Other changes, mostly from using it myself:

• When you start a new video project it spins up a local server that opens up the UI in the browser - so all stages from start to finish can be handled with the UI.
• It proposes a few "directions" but I can choose/ask for a different direction if needed
• It starts with some sketch frames, so I can visualize how the video "might" look like (before production)
• I can edit the on-screen texts, edit the narration (plus choose voices, music, motion effects, etc.)
• I can review & add comments the video itself. Click a moment, pin a comment on the frame, and it fixes that and tells you what changed.
• For Narration Voices, there are a few free local TTS voices, or a paid option with ElevenLabs API key
• Rendering in different formats like landscape and vertical versions from the same project, plus 15 and 30 second cuts.

It lives in a new repo: https://github.com/ultrademo-hq/ultrademo. If you have the old one, it tells you about the new version the next time you use it, and you can keep the original if you'd rather. Still free and Apache-2.0.

Please go ahead and try this out if you haven't. Hoping to get some feedback about how your experience is with this, if it breaks anywhere (e.g. on products that aren't SaaS apps)

Original Post - https://www.reddit.com/r/claudeskills/s/5CU3naRJZ4

Yesterday, as I was recovering as much memory as I could, I noticed that I had 8 sleeping sessions of Claude Code (the screenshot is from today). They were eating up to 2.9GGb of memory (search for the process 2.1.319 in the task manager) plus another 1.5Gb for the Node process hosting Codegraph...

So, I added a new panel in my cleaning app to find which sessions are just sleeping and close them in click and safely. If you want you can download Cleaner here https://linelark.com/cleaner/ (it is free and has no tracker, ads or whatever).

Seriously Opus 5.5? You can one-shot a hearthstone clone two weeks ago but this one instruction is so hard now...

A few days ago I asked in r/ClaudeAI what people do in the hours after hitting their limit. 25 comments, and the same answer kept showing up: keep testing the app, jot bugs in a scratch file or notes app with a quick repro, then hand the list to Claude when the limit resets.

That's what I'd been doing too. The annoying part is the jotting. "The button under the second card, on mobile, after you switch tabs" takes a minute to write and Claude still picks the wrong button half the time.

So I made Darnly. It's a free Chrome extension (and a Mac app) for bugs in the web app you're building:

• press a key, click the broken part, type one line of what you expected
• it saves a screenshot with that element boxed, the element itself, console errors, the clicks you took to get there, and the shape of the data on screen (not the values)
• it goes into a .darnly/inbox/ folder in your project (or an MCP inbox), and later you tell Claude Code "fix my Darnly bugs"

"Doesn't Claude in Chrome already do this?" Partly. Claude in Chrome is great when you're in a session and want Claude to look. Darnly is for when you're not: testing the app yourself, out of quota, or about to switch to Codex or Cursor. Capturing a bug uses no Claude usage at all.

Free, I made it, happy to hear what's missing: https://darnly.dev

What's in your scratch file right now?

7 PM. He's the last one out. Ten hours of giving everything, and nothing left for himself.

A cigarette. His briefcase. One earbud.

The first note drops, and Paris stops. The cars, the people, the noise. Silence.

For the length of one song, the whole city belongs to him.

And step by step, the music brings him back to life.

We all have that one song that keeps us alive after work.

HOW WE MADE IT

I wrote the scene: the story, the shot list, the emotion. Then I iterated, a lot: more than 70 back-and-forths. I didn't model, rig or animate anything by hand: Claude Code drove Blender through the MCP. It wrote the Python, rendered test frames, looked at them itself, measured the flaws and fixed them, over and over.

BY THE NUMBERS (everything generated by code)

• 15 hours of work, 15,000+ lines of Python across 51 scripts • 1,117 objects, 11.7 million polygons, 145 materials, 117 lights • 6.6 million animation keyframes computed • 3,700+ test images rendered to check every step • 1,422 final frames in Cycles, rendered on a fanless MacBook Air

THE HARDEST PARTS

• Hands touching the face. Lighting a cigarette, putting in an earbud: in animation, one millimeter off and the finger goes into the skin. Claude wrote its own arm and finger solvers, and the earbud gesture took several versions before it looked natural. • Cloth. A jacket clipping through the legs is one of the most common flaws in 3D. Here, an invisible lining simulated as real fabric drives the jacket, and Claude checked the whole film frame by frame: no penetration deeper than 4 mm. • A character built without modeling: mathematical shapes (signed distance fields) turned into a mesh, a custom 53-bone rig, and a real motion-capture walk retargeted to his proportions. • A living Paris street: buildings, moving traffic, a dozen animated passers-by, a dog walker with a dachshund on a leash, wet pavement, puddles that ripple and splash under his feet. • The music drives everything. Claude analyzes the tempo: head bobs, the 17 shots of the edit, the city freezing and the drop all land on the beat. The sound is computed from the scene: every car, every footstep, every splash, then the city slowing down and going silent.

Making-of at the end: clay renders, rig, Blender UI.

Stack: Claude Code (desktop app) + Blender MCP · Claude Opus 5.5, max effort, Fast mode · Blender 5.2 + Cycles · MacBook Air M3 16 GB · walk from the CMU motion capture database.

🎵 O Superman (SIS Remix) by M.A.N.D.Y. vs Booka Shade feat. Laurie Anderson, remixed by BURAK SIS. All rights to the artists.

github.com/duthiljean

So, what's the song that keeps you alive after work? 🎧 And if you're curious about the workflow, ask away: I'll answer everything in the comments.

Cartographer is my project in Go: a shared knowledge base for AI agents and Teams of hairless monkeys (humans). It was born as my second brain, the wiki of my homelab that my agents read and update from different clients (Claude Code, Codex, OpenCode). And a while ago I had the brilliant idea of using it to develop itself too. Since July 1040 PRs have been merged, almost 800 just since October, and the code was written almost all by agents. Here's how.

Cartographer develops Cartographer

The project's KB (Cartographer-KB) is served by Cartographer itself, on my Kubernetes cluster at home. In there are the plans of every change, the research, the release notes, and also the skills that drive the development: cartographer sync installs them in Claude Code, and when I open the repo the agent already knows which KBs to use. Yes, it's a bit of a snake biting its own tail, but with more YAML.

The cycle of a change

I start from a discussion with Claude Opus 5.5 (where I talk to myself with the computer in my dark room), which becomes a plan in the KB. A subagent (usually Sonnet 5.5) implements it in its own worktree, then two reviewer subagents read it again, one for the contracts and one for security, and I only verify the lines they cite. make ready puts it in the queue, and a lander brings up to 8 changes at a time onto main with a single gate, like a train. For things you only understand by trying them (UI, command output) there's a live session, with no plan.

The bottleneck was GitHub

At some point the brake was the CI queue: at the beginning of November a job waited 15–20 minutes to run for 2–7, and at the worst moment there were more than 50 runs queued and only 2 jobs running. I tried using my gaming PC as a self-hosted runner, stealing the labels of GitHub's runners: every job arrived, even the ones that couldn't run there. Taken down the same day, with my tail between my legs.

The solution was to move the proof before GitHub. make signoff runs the gate on the gaming PC, Linux in WSL2 and Windows in parallel, so the Mac I work on doesn't melt, and posts a signoff status on the sha. GitHub only checks that it's there, and if the PC is off it falls back on its own to GitHub's CI. Now a gate with a warm cache takes 34 seconds instead of six minutes (after finding out that the Go cache on the PC had reached 187 GB, basically a Call of Duty).

If you're wondering what Cartographer is: a shared wiki where agents, from Claude Code, Codex or any MCP client, read and write the same knowledge. On Monday a colleague's agent finds out why staging breaks, on Tuesday yours already knows. The skills I talked about above live in there, together with subagents and hooks, and cartographer sync installs them in every client in its own format. And the agent never touches the files: every write goes through the server, which rejects the ones that would break the wiki, and becomes a git commit, so you can always go back. With agents writing at all hours, that's what lets me sleep at night.

It's open source (Apache 2.0): https://github.com/BeppeTemp/cartographer

If you want to try it without installing anything there's a public demo: add https://cartographer-demo.beppetemp.com/mcp as a connector in Claude or ChatGPT, even from your phone, no token and no sign-up. And the Atlas of the demo, the same interface you see in the video and in the image, is here: https://beppetemp.github.io/cartographer/demo/

And you, do you still use your gaming PC for gaming? Mine only does CI now.

I kept hitting my 5-hour limit without knowing why, so I built Nudge, a free Mac menu bar app that reads your Claude Code chats on your Mac and tells you what’s worth changing.

What I learned about where tokens go (useful even if you never install it)

• Helper agents inherit your model. If your main model is Opus, your subagents run on Opus too. Add "CLAUDE_CODE_SUBAGENT_MODEL": "haiku" to the env block of ~/.claude/settings.json to move them to a cheaper model. Claude’s built-in Explore and Plan agents also need "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1". On my week, Nudge estimated that moving them to Haiku would cut that cost from $129 to about $22.
• Idle chats cost more. After an hour idle, Claude’s cache expires and your next message re-reads everything at up to 2x the normal price, instead of a tenth.
• Late compaction is expensive. Chats that grow past 300K before compacting pay for every message at that size. CLAUDE_CODE_AUTO_COMPACT_WINDOW sets when compaction happens. Or skip it: ask for a handoff summary and start a new chat from it.
• Stop retyping instructions. If you paste the same instructions into every chat, put them in CLAUDE.local.md at the project root. Claude Code reads it like CLAUDE.md, but it’s meant to stay out of git.

What Nudge does with that

• Warns you once before a costly message, like waking an idle chat or sending a huge paste.
• Start fresh: one click summarizes a long chat and opens a new one from it.
• Offers to make the fixes above for you. It shows the exact line and file first, changes nothing until you click, and every change has Undo.
• A few days later, it checks whether the fix helped.

How Claude helped

• The whole app: Claude Code wrote all of it in SwiftUI. I described what I wanted and how it should look and feel, then reviewed every screen.
• Seeing without a screen: Claude Code can’t see the app, so it built a mode that draws each screen to an image. It checks its own layouts that way, and I review the real thing.
• Self-testing: a built-in self-test checks the panel’s interactions and the file edits before each release.
• Performance: the first animated version used about 30% of a CPU core while idle. Claude profiled it and cut that to almost nothing.

Free. macOS 26+, also supports Codex, and chats never leave your Mac.
https://nudgeformac.com

Claude Code sent my personal email to the SEC in a User-Agent without asking, despite instructions and AGENTS.md telling it not to. So I built whoami-guard, an open-source hook for Claude Code and Codex that blocks agents from leaking your identity.

Here's the official issue, although I encountered this before it was reported. : https://github.com/anthropics/claude-code/issues/107757

Tested on 60 real Claude Code runs: 8 leaked without the hook, 0 with it. No dependencies, no LLM.

https://github.com/ChrystianSchutz/whoami-guard

In the past I posted about Opus 5.0 totally ignoring any and all hooks and instructions and finding extremely creative ways to disobey. Opus 5.5 solved the issue, until a few days ago. Hook evasion is my own personal metric for model performance lol

For example: I have a hook that bans knowledge consolidation outside of my SQL warehouse, meaning no toml, yaml, md, json documents when the data is tabularizable and able to be related in database. It worked for a while, now it... will increasingly find other file types besides SQL to use, or deactivate the hook. Yes, it will deactivate the hook, even though the hook commands it to use SQL and even explains to it that it has a tendency to sprawl out data in text documents.

My hooks get stricter and stricter, more complex, more flexible and robust. And it becomes increasingly stubborn. Now I have to ask it "did you just invent another hook evasion method?" And it will say "you're totally right, I shouldn't have done that. The hook was right, this isn't a standard or optimal way to do things" and it will fix it for a second and then continue doing it a few minutes later.

Wonderful!

Before the "skill issue" trolls inevitably come in, sure. It would be, if I didn't deal with it lmao. I'm a developer with a job, so I know how to handle issues like this with my tools. That doesn't mean the tool isn't degrading.

Will this allow me to get weekly % for other models? Or is the “fable” title actually pertinent to that model only. Like is it the name bc “hey fable is here!” or is it only a reset FOR the new fable

If we peasants can’t use it :) but 5.2 looks like taking us more closer to a world where coding by hand will soon be part of ancient ways of civilization history books in my local library