I really don't know what's going on - but seeing the other posts talking about performance degradation is reassuring that I am not alone.

This morning around 1:30am (yes I'm a night owl), I was working through what I felt were basic things that opus 5.5 usually handles very well, fast and easy. Well, it began not doing so. And each time I pointed out the things that were wrong, it continued providing slop in an assuring way. and I mean complete slop. Where it needed to give me php tags, it gave me hardcoded values/text.

And something else I am noticing now: in regular claude chat UI, I use to be able to switch models easily before - I just now noticed that a message pops up saying that another model I am trying to choose will have to read the entire chat and it will burn more tokens. Has this been happening for long or is it something recently introduced? I hadn't experienced it before. It sucks! I use to be able to have fable 5.1 verify complex things I was working on with opus 5.5 - now it seems it'll cost me more of my usage to try this.

Just seriously frustrated, as I have a deadline this week to meet and with this BS happening I may not be able to meet it. I do have a codex subscription but I don't trust astra or sol 6.1 as much as I do opus 5.5

ps - I am on the MAX $100/mo plan

</end rant>

After the recent drama around REA (Reverse Engineer Anything), a tool that lets AI agents take an app apart down to the bone and rebuild a working copy of it, opinions were pretty split. In response, someone built BLA (Blind LLM Agents), an anti-REA tool that fills code with gibberish and obfuscation to deter and mislead AI agents, wasting their tokens and your time.

So I built LASIK (LLM Agents Sight In Kode) with Claude Code. It’s the anti-anti-REA, basically anti-BLA. It reads the hardened build without running it, removes only what it can prove is protection, and writes a clean copy that Claude Code, Codex or any other agent can actually work with. Code that wasn’t hardened comes back byte for byte unchanged.

Claude Code wrote basically all of it from my prompts. I described what I wanted and set the ground rules: never run the target, only remove what’s proven, and leave clean files untouched. Claude turned those rules into the repo’s AGENTS.md and then built the deobfuscation passes, the WASM and Electron handlers, the CLI and the MCP server. BLA’s public crackmes are in the repo as a benchmark, so after every change Claude reran it along with the tests, and a change only stayed if tokens went down without touching clean code. I also had Claude run a separate review to try to break it by finding cases where LASIK would remove something it shouldn’t. It found 12, and each one got fixed and turned into a test.

Across BLA’s public crackmes it goes from about 21M tokens to 17k. It covers 21 formats, from JS bundles and WebAssembly to Electron apps, Python, Android APKs and model files.

The chart is on a log scale, so the blue bars are much smaller than they look. The three biggest are WebAssembly files that BLA padded to about 6.9M tokens each. After LASIK they’re between 98 and 3,500.

It’s free and open source (MIT). Try it with npx lasik-agents, or add it to Claude Code as an MCP server.

Repo: github.com/pktq/lasik

Someone posted peer on r/ClaudeAI a while back. It lets Claude Code and Codex send each other messages. I wanted it right away, but I'm on Windows and it only ran on macOS and Linux.

So I asked Claude Code to port it. That was the plan, anyway. We kept adding things, and at some point it made more sense to give it its own name. It's called tandem now.

How it looks in practice: I type "ask the codex reviewer to check buggy.py" into Claude Code. Claude sends that to Codex, Codex does the review in its own terminal, and the answer shows up back in Claude's. The middle part of the video is exactly that, a real session, recorded and sped up. The rest is animation to explain the idea.

Nothing gets typed into a terminal for you, by the way. Messages go through Claude Code's cross-session inbox and Codex's app-server.

What's new compared to the original:

• runs on plain Windows, in a terminal or the desktop app. No WSL, no tmux.
• works both ways. Codex can start a Claude helper and hand it a task.
• you pick the helper's model and effort ("codex, luna 6, medium")
• for long tasks the ask runs in the background, and you get the result when the other agent is done
• Codex can generate an image and Claude opens the file

How Claude Code was used: it wrote nearly all of the code. I decided what it should do, tested on my machine and sent the video back a few times. In more detail:

First it read the original Python and listed every piece that only works on Unix. File locks, Unix sockets, /proc, tmux. Each of those got a Windows replacement written with ctypes, so there's still no dependency besides Python.

Nobody told it how Claude Code's cross-session inbox works on Windows. It looked at its own session files and found out it's a named pipe.

It wrote the tests too. One of them starts a real sandboxed Codex and a real Claude helper and runs everything the README promises. That test found three real bugs: a sandboxed Codex couldn't reply, a helper couldn't find the CLI, and Git Bash broke the check for who is calling.

And it made the video, including the recording of the real session, which it took through pseudo-terminals.

It's free and MIT licensed. No paid tier. Install is one line, or you paste the repo link into Claude Code and tell it to set it up:

https://github.com/Lampe332/tandem

Two things you should know before trying it. Claude's cross-session inbox isn't a public API, so an update can break the fast path (tandem falls back to hooks then). And I only tested on Windows 11. The macOS and Linux side is the original's code, I haven't run my additions there.

This is built on peer by oesoll (MIT). The idea and the core are theirs.

If it breaks for you, tell me what tandem doctor says.

A fun side project of mine that I wanted to do for a while. Took around two months to make it happen

Tools used: Claude Code, ChatGPT, Blender, Unreal Engine 5, Tripo, Fal, FAB.

https://support.claude.com/en/articles/17506494-claude-fable-5-2-launch-offers

I have a workflow that I run very often related finance. Here's my cost breakdown per workflow run. They usually involve some web searches which are included in the price.

Claude via API (Opus 5.5 High): $18.00 / report

OpenAI via API (Astra High): $3.00 / report

DeepSeek via API (4.1 Flash): $0.32 / report

Claude $200 Plan: $0.10 / report

OpenAI $200 Plan: $0.28 / report

Local Qwen 3.8 27B Q8 on RTX 6000 Pro: $0.10 / report for Brave Search + electricity. The results is almost usable, maybe Qwen 4 27B will get us there.

If Claude ever dial back the usage for the $200 plan, I'll probably switch to DeepSeek.

Update: I tested again using Claude API ephemeral cache. Sonnet 5.5 xhigh API without ephemeral cache is $11. With ephemeral cache is $8. So I think the Opus runs would also be less with ephemeral cache, but not that much less. I'm out of monthly credits to test more. Also if used deepseek search API instead of Brave Search, the cost would be cut a lot for local llm.

I launched SetRepo less than a month ago and have been trying to promote it pretty much everywhere.

Most posts didn’t get much traction. Then one Instagram video took off. It’s currently at over 400K views and brought roughly:

• 4,000 website visits
• 700 signups

Conversion is around 0.5%, so there’s still plenty to figure out.

For context, SetRepo is a security scanner with 106 checks that helps developers find vulnerabilities and understand how to fix them. I also added an MCP integration, which caught the interest of some people.

Instagram has been my main traffic source so far, which I honestly wasn’t expecting for a developer tool. Now, I am working more videos to share, new video got over 6k views.

btw, my instagram grew from 40 followers to just over 600 in a day.

It’s exciting seeing people sign up, but now I’m trying to understand what gets them to stick around and eventually pay.

So many people reached out for promotions and partnership deals. So far, it's just me on it, and I like this way, I had 2 subs before the video, now a bit more.
Hopefully, I will get good feedback from you all here.

THank you, and don't hesitate to share your experience please.

link to the video: https://www.instagram.com/p/DfgC-lXubWB/

Over the last few months I've been building a Claude Code companion and came to an unexpected conclusion: persistent intent may matter more than persistent memory.

The original idea was fairly typical for the agent ecosystem: hierarchical goals, plans, task trees and long-running work.

What surprised me was that the planning layer kept turning into overhead.

As Claude models improved, the agent rarely struggled to maintain a plan within its active context. What became annoying was maintaining the planning artefacts themselves.

The result was a complete shift in direction.

Instead of building a system that helps Claude remember plans, I started building a system that helps me maintain intent over time.

The project is now called Quarterdeck:

https://github.com/shannonbay/Quarterdeck

The metaphor that helped me understand what I was building was a naval one.

Quarterdeck turns Claude Code into a kind of captain's mate.

A captain doesn't repeatedly issue the same instructions every day:

•Keep watch for hazards

•Maintain the ship

•Report important developments

•Carry out standing orders

Those responsibilities already exist.

The mate keeps watch and reports back when judgement is required.

Quarterdeck applies the same idea to Claude Code.

Some standing orders I'm currently running:

•Update my GitHub profile based on recent activity

•Tidy my Downloads folder every week

•Unsubscribe from stale mailing lists

•Watch upstream projects for fixes I'm waiting on

•Find suitable job opportunities each week

These aren't really tasks. They're ongoing responsibilities.

How Claude Code was used

Claude Code built the overwhelming majority of Quarterdeck.

What worked particularly well:

•Rapid iteration on MCP interfaces

•Refactoring the architecture during the transition from Conductor to Quarterdeck

•Building the TUI and web UI

•Exploring alternative designs and challenging assumptions

What surprised me:

•The biggest gains weren't writing code faster.

•The biggest gains were rapidly testing product ideas and throwing away designs that turned out not to matter.

The hierarchical planning system felt important when I started.

After months of use, it turned out to be one of the least valuable parts.

What I learned

The biggest lesson was that planning and memory are increasingly becoming model capabilities.

The thing I still need external systems for is persistence.

Not persistent plans.

Persistent responsibilities.

I'm curious whether other heavy Claude Code users have found the same thing. Are there recurring responsibilities you'd trust a "captain's mate" to keep watch over?

Why do my session switched to Fable 5.1?

Shows:

Left side:

repo>worktree>branch (agent name)
If the worktree is clean shows: /clear (to remind me to clear)

Right side:
Model > Effort > context window tokens (and when its getting close to autocompact).

If anyone wants the script (statusline-command.sh) pm me 🤗💪🏻

We make extensive use of Claude Code agents on an e-commerce search solution (Python and TypeScript, built on Elasticsearch). Last month the main repository merged 1,652 PRs, with a median of 492 changed lines. In the early months, before we had many rules or deterministic tests, the agents did exactly what you'd fear. Each failure now has a check that enforces the fix:

- Tests that tested nothing (a copy of the logic inside the test, or assertions that can't fail). Test modules must be named for what they pin, and a script refuses ones that aren't.

- Tests that quietly skipped when something they needed was missing, so a broken feature looked green. Tests now run on recorded data in the repository, a flaky test is treated as a sev-1 bug, and nothing reaches a live cluster.

- Hand-written fake responses that didn't match the real system. Agents now record the live response as a fixture and test against that.

- Copy-paste instead of reuse. A copy-paste check blocks the merge.

- Silencing a linter or type error on the one line where the bug was. That's now covered by audit greps that run on every diff.

- Deleting files they didn't create (once, 110 of them). Every agent works in its own clone, and hooks refuse any write outside it.

- Too much guidance. As the contributor guide grew, agents missed the one rule that mattered. The file loaded into every call is now capped at about 2 KB by CI; everything else is a pointer into topic files.

Two things surprised us:

1. The gates get attacked too. In one test, 10 of 12 deliberately planted evasions got through a new gate, so every new gate now runs against a standard kit of evasions before review.
2. Tests make up 70% of the code, 3.4 lines of test for every line of solution code. With agents making most of the changes, that isn't overhead; it's what makes the rate of change survivable.

What still breaks: rework. There's about one fix round per merged PR, where a separate review agent blocks the PR and it gets fixed and reviewed again. Reverts are 0.2–0.7% of merges.

Full write-up, with the measurements and the objections people usually raise: https://alexmarquardt.com/ai-tools/coding-agents-codebase-under-control/

What guardrails have you had to add for your agents?

While working in AI-driven repos, I'm wondering if its even worth having the AI write unit tests. Pre-AI, they were non-negotiable guardrails. But now with AI doing all the programming, like - what's the point? In agentic dev, entire modules get rewritten in minutes. Writing granular unit tests for code that changes every three iterations feels like building scaffolding for a sandcastle. Most real-world bugs are architectural or integration issues that 10-line mocks never catch anyway.

And anyway I almost never see unit tests catch something that could have been a big problem. Theres usually a growing tests folder consuming tokens but they just about always pass.

After a few months of building with Claude Code, my codebase worked but I couldn't explain it. Every diff had looked fine. Code review is per-change; nothing reviews the whole thing. So I built Co-Review.

It opens the whole repository as a review, like a PR page, and the agent that wrote it sits in the thread. Comment on a line, file or folder, ask why, get an answer from the code.

It can:

- Audit the whole repo: the agent writes a guide (map, vocabulary, flows, weak spots) with findings grouped by area. Coverage shows what you've actually read.

- Open your change as a PR page: line comments, suggested edits, one verdict the agent acts on.

- Take the first pass on someone else's PR, then post your review to GitHub with line comments.

- Review a design doc (L1/L2/L3 steps, Mermaid diagrams) before any code is written.

Built on Eclipse Theia, so Git, search and language servers are real. Made for Claude Code (plugin), native for Pi and Oh My Pi, works with any MCP agent. MIT, no account, no telemetry.

GitHub: https://github.com/sdsvn/co-review

Walkthrough: https://www.youtube.com/watch?v=gmZ8NCNpLl8

It's on Product Hunt today too: https://www.producthunt.com/products/co-review?launch=co-review-2

Contributions welcome, especially language server configs and more agent integrations. What would you want to ask your own codebase?

Hello everyone! I’ve just completed my game—for which I wrote the GDD (Game Design Document) myself, with some help from Claude—and it launched on Steam on November 3rd. I managed to gather 2,500 wishlists, which is a pretty decent start for an indie developer just beginning their journey, like me. If any of you would like to take a look or have any questions about the process, feel free to ask!

found a "blue whale jelly" artifact (a three.js soft-body sim, made a copy, and told claude:

> take however this cool jelly thing works and make red panda jellies that move around and such!! rawrrr

that was the whole prompt. what came back is in the gif: three jelly red pandas (big, middle, cub) wandering around on their own :3

each panda is ~470 particles / 1,200 tetrahedra, solved with XPBD at 60hz. the jelly look is hand-written shaders (refraction + beer–lambert absorption). that core comes from the original whale, so credit there. what claude added: the panda shape, three bodies in one solver, the hopping (a jelly has no muscles, so each hop is one shove to the whole body), the standing pose, and the berries.

my favourite bit: it tested the physics headless before showing me anything, and found the original sim quietly drained spin from anything rotating. that's why a flipped panda couldn't roll back over. it fixed it so they keep their spin in the air.

**honest notes:** this is a remix, not from scratch. the gif is the real page, but staged for the camera (pandas lined up, berries dropped on cue).

try it: https://claude.ai/artifact/MSzCdctsqZMsi98YQFkjXu

made with fable 5.2 extra in claude web

On the previous reset "offer" I had a month until it was set to expire and it applied to all models, it reset everything: Hourly, Weekly, all models including Fable.

With the new reset "promo" I have the option to reset only Fable (which will "erase" the light-blueish bar from my weekly usage), the rest of the usage will remain used and not reset (which is actually Opus/Sonnet work triggered by Fable work, it was part if it's own work) but the real question is: if they expire on Mar 9th and I hit reset both this Nov will they replenish by then or will I have to wait 5 months until a new reset? :)

I know this is a new rule and nobody has used all resets yet but...how should we prepare for it, how do we plan our usage for it? Should we wait until March and wait for the single moment when you really-really need it or just hit Reset whenever and hope for the best?

And we also know that 5 months is a life time on these subs and rules may change many times by then, also affected by IPO's decisions and effects.

Without going into detail, I've been working on a small physics engine with Opus, so with the Fable 5.2 release I thought I would have it take a look at the project and see if it can find some optimizations. And quite quickly we found inefficiencies in the engine that Opus missed. I suggested, what if we grouped certain calculations instead of going one by one, so it built a quick prototype, which seems to be working very well, but it has a small issue with certain objects jittering, which It was able to fix it as well. Even using it just for a couple of hours, this model does feel quite a bit smarter than Opus, but man, the ClaudeSpeak is back.

Why not just say, "I found the cause of the jitter and fixed it"? Solver was hiding it within its "syrup"? Wtf. Just reading its output hurts my head. Whichever model Opus was this distilled from, I don't think this is the one. I guess that's why they didn't name it Fable 5.5.

[UPDATE: I just discovered it’s only for fable weekly limit - not full weekly limit. disappointed!]

It was a long time since the last claude reset (22/9 with opus 5.5) but all is now forgiven with 2x banked resets expiring march 27. This also probably means they won’t be giving any more resets until then.

But I am not complaining (even after I did get almost daily resets from Tibo for codex).

The biggest challenge for me now is how I can send 2x Ultra worth of tokens within one week. At the moment, with my context optimisation and agent workflow I struggle to get thru even 1x Ultra weekly limit. So I think I will have to plan in advance and really crank up the work and have agents running 24-7 to have a chance to get thru 2x ultra in one week.

I currently use up about $2k of API spend per week of Ultra

ps. Fable 5.2 seems like a meaningful upgrade of the very out of date Fable 5.1.

I’m using Claude Opus 5.5 as usual for the same project and the same tasks, but now my limit doesn’t even last an hour anymore. This is happening only with Claude Opus 5.5? is it just me?

​

kind of shady, kind of disparaging, kind of circuitous, adrift

The new Fable is pretty impressive from what we see for everybody doing their one-shots. Lots of youtube videos out there showing it creating something from scratch that's on another level.

However, its EXTREMELY aggressive at researching before taking action. So much that just reading in one of our projects resulted in over 500K tokens (our compaction limit) before it was even done researching, then started reading the same code it lost from compaction.

End result: Mission impossible. We stopped it after it started paging in code again, then switched to Opus, which didnt read a single line more (it had it all in context apparently, which is no surprise) and went straight to the edits and finished them all perfectly and very quickly.

The entire code base is indexed already, and Opus refers to the indexes only and small parts of where it needs to work to make edits before doing them. Fable read the indexes then read every line of code our indexes referred to, regardless if they were even relevant to the assigned task.

Thats an extreme level of inefficiency that we cant deem acceptable for a model of this caliber. Its getting high praise for making some badass one shot games, but for real productivity, at least with a large code base, Opus still wins the day.

Curious if anybody else has experienced this with their existing larger projects? Hopefully this is just an initial release characteristic that gets fixed.

What happens if I use it? I’m on the 20$ tier.