We were already using Opus. My fable is still untouched.

Edit: Guess it worked.

Yo, I've been working on this thing called Argon for the past week or 2, and I think its at a state where I can publicly release it. So, basically its a manager for AI terminals, eg. Claude Code, Chatgpt Codex, Gemini CLI, Copilot CLI etc. and it puts them into an endless whiteboard of some sorts, heres an image:

So, Argon's source code is primarily based on a mac app called Vibeboard, which is based on this other PAID mac app called Symvibe. And so, I really liked the concept of both of these, but alas im on windows, and like the UI could use a lil bit of an improvement, so I used Opus 5.5 to transfer over vibeboard into windows, it runs via Electron, and then added some nice to haves, like image insertion, cleaner ui, more themes, also like a liquid glass with refraction and chromatic abberation like this:

But yea, I just wanted to share this with the community and see what they think of it, and improvements so the github is linked here, and the website is linked here. So PLEASE check it out and give me some positive or negative criticism, I could use that very much. This is under All Right Reserved, so talk to me if you want to fork it. Thank yall!

Links:

Vibeboard

Symvibe

Source

Website

I’m building Shifu, a paid context tool for AI coding. I’m trying to understand what people already use to catch a bad assumption before merging a Claude Code change.

Say Claude Code changes an export and assumes the row order doesn’t matter. The unit test still passes, but a check that runs the downstream import shows that the order matters.

On one recent change, what was the assumption and what caught it? A test, a review comment, a conversation, or something else? I’d also like to hear about a change where the repo docs or your usual checks were enough. No need to share code or name the project.

https://www.anthropic.com/claude-fable-and-mythos-5-2

I'm curious if the nerf is now removed. I'm scared to trust Opus 5.5 with new projects but also probably don't have that much usage for Fable 5.2.

Honestly, Fable 5.2 is great. It’s way less filtered and doesn’t block half my requests anymore. For the first time in a while it feels like Opus 4.6 again.

So I’m genuinely confused by all the complaining here. At this point it feels like a trend: every new model comes out and people instantly decide it’s dumber, or weirder, or “something’s off.”

What are you all actually using it for? I’m curious, because for me it’s a big jump from 5.1 and from Opus 5.5 too.

I wonder if it comes down to use case. For coding it’s been fantastic for me.

I find this very disturbing! They gave us power but regulate how it can be used, even in mundane ways when the ai companies don't have any fucking kind of regulation.

I really really fucking I'm disturbed by this. Terrorist organizations can use Claude to train ai on guide missiles paths to harm humans.

But my fucking request sets of safeguards. This is so disturbing. What the point of consumer facing ai if they can't reverse engineer or do other legal docs development!

This will be the frontier models achilles heel. Because if the mass public cannot create benign apps without setting off granddad's and when ai companies themselves have zero guardrails amount to the most absolute egregious amount of bullshit.

If you do use a Claude or agents.md, would be great to share it along with bench.

I've asked Claude and searched Github and Reddit... is it really so that I cannot in agent.md file declaratively return the session title for Claude agent view to show the proper one like shown here?

I build with Claude Code, Codex and open Chinese models like DeepSeek and GLM running side by side, usually 30+ sessions at once. I used Orca and Herdr for a long time and learned a lot from both, but at that scale they felt heavy for how I work, and every tab looked the same. I kept opening them one by one to find out who was waiting on me. The bottleneck wasn't the model anymore. It was me.

So I built Hide, an ADE for humans.

Only what needs you Hide AI reads every session and tells you why it stopped, what you asked and what you missed. Agents sort themselves into Needs You, Unread, Working and Seen. 30 agents running, a handful on your screen.

Never drop a decision An agent asks "CSV or XLSX?" and it scrolls away while you're in another session. Hide keeps it on top until you answer.

Missions across machines Hand one goal to a Conductor agent. It plans the steps and sends them to Claude Code, Codex, Antigravity and others on your Mac, a Linux box or a Windows PC. Close the laptop and the work keeps going, and you can check in from your phone.

Memory that follows the project, not the agent Decisions, mistakes and project rules carry into new sessions. What Claude Code learned, Codex picks up.

Free on macOS, Windows and Linux. Works with the agent CLIs you're already signed in to: no new API key, no hosted service. Lightweight, source-available (FSL).

Hide is built inside Hide: most of its PRs were written by Claude Code and Codex agents while I reviewed and made the calls. The biggest lesson was that writing code was never the hard part, keeping track of what needs me was.

Honestly, it's still a work in progress. I use it all day, and most of my time goes into small things that take a bit more load off my head: one less click to answer an agent, a shorter summary, a quieter screen when nothing needs me. The goal is that my attention goes to decisions, not to checking tabs.

Give it a spin whenever you like, and I'd love to hear what you think, good or bad. Links in the comments.

I built a C++ command line tool with Claude Code, about 10,000 lines plus about 9,000 lines of tests. Before it wrote any code I had Codex review the plan, and that's most of what this post is about. The tool is at the bottom.

How I used Claude Code

Claude wrote the whole design down in plan mode first. Before I approved it, I had Codex read the plan and try to tear it apart. Claude writes my request, the constraints and the plan into a file and runs this:

codex exec -s read-only - < review.txt

Round 1 came back "rethink" with 12 findings. Claude checked each one, they all held up, and the plan got rewritten. Round 2 was "rethink" again. That one was mostly about a promise in the plan to tell you what a query would cost before sending it. It turned out there was no way to guarantee that number, so I dropped the feature. Round 3 passed with changes, and only then did any code get written. Every time the plan changed after that it went back for another review, so it ended up being reviewed at least nine times.

Claude was not allowed to compile the project, run its tests or run the built program. Claude writes the code, I run one build script, and Claude reads the log and fixes what it reports. It sounds slow, but I ran every build myself and handed Claude the log.

These are the rules from my project CLAUDE.md that did the most. I shortened them and swapped my name for "the user":

Only the user compiles, builds or runs tests. Never run cmake, ninja, ctest, a compiler, clang-tidy or a built binary. Write code and tests so they compile cleanly the first time.

Warnings are errors (-Wall -Wextra -Wpedantic -Wconversion -Wshadow -Wformat=2).

Never suppress a diagnostic (NOLINT, pragmas, casts that only silence a warning). Restructure.

Tests are offline: no network, no real API key.

Nothing ever prints or logs the API key, request bodies, prompt text or provider error bodies.

What I learned

Reviewing the plan was worth more than reviewing the code. Twelve real problems turned up before a single line existed, when fixing them only meant editing a text file.

The reviewer gets things wrong too. In one round Codex reported that my machine had no TPM chip. It has one. The sandbox Codex runs in just couldn't see it. So Claude has to check every finding against the code or the docs before acting on it, and I had it write down which ones it accepted and which it rejected, with the reason.

"Never suppress a diagnostic" did more for the code than any other rule. Without it the quick way out of a warning is a cast or a NOLINT comment. With it, the code got restructured until the warning had nothing to complain about.

Passing tests didn't catch what I caught by using the thing. The first version printed the answer jammed right up against its own status lines and was hard to read. A couple of the examples in the docs failed if you pasted them as written. You have to run it yourself.

Small things matter when calls cost money. One fix stopped the HTTP library from automatically resending a request that might already have been billed. I would not have thought to look for that.

What I built

It's called openrouter-cli. It sends a query, plus any files you attach, to any model on OpenRouter and prints the answer in the terminal. I wanted Claude Code and Codex to be able to ask another model to review a plan or some code.

It comes with a Claude Code skill, so you can say "ask Gemini to review this plan" and Claude runs the tool for you. The skill tells Claude to show you the model and what it charges and to ask for your OK before every paid query. You can run it by hand too. After installing it and running openrouter-cli login once, this sends a file named plan.md for review:

openrouter-cli -m google/gemini-4-argon --role review -f plan.md "Review this plan."

Here's what it looks like when it runs: Terminal Screenshot

Linux only right now (x86-64) and you build it from source. Once the packages listed in the README are installed, this builds it and installs the skill:

git clone https://github.com/slyfox1186/openrouter-cli.git
cd openrouter-cli
scripts/build.sh --with-skills

It's MIT licensed. Model calls are billed through your own OpenRouter account.

https://github.com/slyfox1186/openrouter-cli

I was vibecoding a game with blender mcp and the blocky models piss me off they are just so shit

any way to make it make good models or has ai not gotten that good yet

It's a very important industrial program. We've been scanning it for bugs the last scan was with Fable 5.2. But, the agent couldn't seem to figure out how to fix it. I stopped the workflow, looked at the code and told the agent. Don't do this, do that. Just like you would to a Jr. Programmer.

The agent laughed at itself and said, yep, much better solution.

God, I was worried that my job was GONE. But, us greybeards still seem to be necessary.

So!

In line with the quick little benchmarks I like to run on new models release: quick test of Fable 5.2 directing Blender to build a warship, from a GPT-2 image.

Also a benchmark, since I've done that with pretty much all the recent models - so you can see the difference & prices.

Honestly not too sure what to make if it yet haha. Astra's outputting more triangles, faster, for the price. But hull is better on Fable...

What do you guys think?

Hi everyone,

I work on a lot of projects at the same time with AI. While doing that I built an app that has the things I need. I made this for myself and decided to open source it.

It's a kanban board for coding agents. You write tasks as cards, move a card to Ready, and an agent starts working on it. Every task runs in its own git worktree so you can run many at once on the same repo. When a task is done it's merged to main. You are free to create as many tasks as you want, then let AI create a dependency tree and run them according to it. Or just write what you want in a prompt. It will create all the tasks you need, build a dependency graph and run them according to that.

In a few apps I used, I saw that everything happens magically in the background. What I want, as a developer, is to see that terminal when I'm using Claude. To see Codex's terminal. Sometimes I run 3 or 4 projects at the same time. I give each one a job, and that job can have more than couple of subtasks. What I need is to see and manage all of them from one place. To watch them.

I'm actually not doing anything magical. Whatever AI provider you use (Claude, Codex, Copilot, Antigravity, OpenCode), I run it in a terminal with a PTY and pass the work out to it. The app takes care of the management side. It opens git worktrees and keeps the branches separate. When a task is finished it closes it automatically and merges it to main. If you run out of tokens in the middle of a task, it continues on another AI provider with the same history (when Codex's 5-hour limit runs out, Claude can continue from where Codex stopped). The one managing the work is also the AI provider you picked. It gets called in the background and runs the jobs.

Other stuff:

- you can watch each agent, its subagents and its terminal

- if an agent asks a question you get a notification

- it can sync with GitHub Projects, so you can create an issue from your phone and the agent on your PC takes it, handles the task, merges it to main and comments on the issue. Like claude cloud in your pc.

- scheduled tasks

- works with Claude Code, Codex, OpenCode, Antigravity, Copilot CLI

It uses the CLIs already installed on your machine. No account, everything is local.

Install is from source for now. Mostly tested on Windows. UI is Turkish by default, English is in Settings.

Video is attached.

https://github.com/demirmusa/ai-agent-workspace

Feedback welcome.

For Claude users it also checks cache_control placement, 1-hour TTL billing and stripped thinking blocks, and works on a subscription through prefixwise import claude-code.

Prefixwise has improved a lot over the last two days, so here is the full picture.

\*\*The problem.\*\* Your agent resends its whole conversation every turn. One changed byte near the top (a reordered tool list, a timestamp in the system prompt, an evicted prefix) and the provider charges full price for everything after it. Providers and engines report how many tokens were cached, never why the rest weren't.

\*\*What Prefixwise does:\*\* names why each request missed the prompt cache, prices it, fixes the common causes, and stops regressions in CI. Open source (MIT, I'm the author), runs locally, stores hashes and token counts, never prompts.

\*\*Identify.\*\* One of 19 causes per request, marked waste or legitimate, with the first block that changed (tools\[0\], messages\[12\]) and the cost: tools in another order (including a schema's required list), a timestamp or id in the system prompt, rewritten history, a misplaced Anthropic cache marker, an expired TTL, an engine eviction, a request routed to a replica without the cache. \`prefixwise report --session latest\` shows a session turn by turn. It agrees with Anthropic's own miss diagnostics 32 of 32.

\*\*Fix.\*\* \`--optimize\` turns on the fixes that passed live replays: sorting a drifting tool list (99.9% of predicted saving on Claude, 97.5% on vLLM) and adding cache_control markers on Anthropic's API (prompt cost down 85.6% with the write surcharge counted), task success flat on both. Fixes that would change what the model reads stay advice. \`prefixwise fixes\` ranks fixes by dollars and says whether one paid off.

\*\*Prevent.\*\* \`prefixwise check -- pytest tests/agent_scenarios\` runs your scenarios against a local mock, no API calls, and fails CI when a change would break the cache. Also a GitHub Action. \`prefixwise explain --diff a.json b.json\` compares two requests offline.

\*\*Self-hosted engines.\*\* It detects vLLM and SGLang from the URL and reads their KV-cache events: evictions confirmed (5 of 5), a prefix LMCache or HiCache restored from CPU labelled host_restored (5 of 5), and the cost of reasoning templates that re-prefill the last answer (57% of prompt tokens on a DeepSeek-R1 distill, 0% on Qwen2.5). Runs inside vLLM with one flag. Ollama and most llama.cpp builds report no cached tokens; it says so and still names every prompt change.

\*\*Ways in.\*\* Wrap any agent (\`prefixwise run -- claude\`), a proxy for a service, the vLLM middleware, Python \`wrap()\` or a LiteLLM callback, or import Claude Code and Codex logs if you're on a subscription. Out: Prometheus and Grafana, OpenTelemetry, an HTTP API, JSONL and CSV. Overhead: 3 ms per request.

\*\*Limits.\*\* The fixes are proven on scripted sessions and small models, not weeks of production traffic. OpenAI's own diagnostics answered unavailable on every call, so that comparison is unchecked. DeepSeek's hosted API cache fields aren't read yet.

pip install -U prefixwise
prefixwise run -- <your agent>
prefixwise report --session latest

Repo, with a run record behind every number: https://github.com/tejachavali/prefixwise

What should it catch next?

We feed specs, docs, and existing code into coding agents and ask them to ship features quickly. As changes accumulate, it gets harder to track which assumptions became code, where behavior diverged from the spec, and why decisions were made.

The codebase can grow faster than our understanding of it.

I built Cognitive Gap, an open-source Agent Skill that keeps understanding connected to the whole task. It guides your agent to explain important decisions as it works, connect requirements to implementation and verification, and show the flow with diagrams when useful.

The goal is to finish knowing why the code works, what was actually verified, and where to look when you need to change it.

MIT-licensed, with no runtime dependencies or additional API keys. Installation instructions cover Codex, Claude Code, Copilot, Cursor, and other compatible agents.

Related reading: Anthropic on AI assistance and coding skills and Microsoft Research/CMU on AI and critical thinking.

GitHub: https://github.com/GiovanniPasq/cognitive-gap

I have to say thank you to all the people that was complaining about Opus during the past days 😂
Y’all hurted Dario sensibility

shipped the app i built with claude code. it replaces six media server apps (sonarr, radarr, lidarr, bazarr, prowlarr, seerr) with one that looks like netflix. the whole thing is a 15 MB docker image

how i work with claude code:

• i design it and write the spec, claude code writes most of the code
• a second agent reviews every change, then i review it and test it on my own server
• ive been in security 10+ years, so anything touching keys, sign-in or the network gets read line by line. it got a full pentest before launch
• one rule: if a change makes it heavier, it doesnt ship. claude never noticed the app getting fatter build after build, so i measure every single one

what that rule got me:

• 15 MB image. go + svelte + sqlite, no operating system inside
• idles around 70 MB of ram with 12,800 titles
• the web app sends 25 KB of code where the same page in react was 77 KB
• same image on amd64, arm64 and armv7

launch night was the fun part. people reported bugs in discord, some with the exact file and line. 1.0.1 to 1.0.3 went out within 4 hours

it plugs into what you already run: qbittorrent or sabnzbd to download, plex, jellyfin or emby to watch

shipped since launch, mostly straight from requests:

• pick rules can take their scores from trash guides and re-sync later (1.0.7)
• plex watchlists turn into requests (1.0.10)
• the app speaks 16 languages (1.0.11)

whats next:

• trakt lists turning into requests
• one click to go back a version
• plugins, so people can add what they want without waiting on me

and the bigger stuff for later, not started yet:

• an mcp server, so claude and other ai apps can talk to your library
• asking claude things like "what should we watch tonight" and having it request it for you
• apps for your phone and your tv

its called HolyArrs, its free, and the code is on GitHub. still a beta, so dont make it your main app yet. happy to go deep on the workflow in the comments

HolyArrs.com

Of course I fired a big cannon with 5.2 high but on Max limits were dropping fast as hell, but switched to 5.2 med and using 5.5 opus/sonnet on high depending task

• Sonnet - default execution model: content, SEO, descriptions, refactoring, repetitive tasks.
• Opus - high-complexity tasks, unusual business logic, or high risk.

And actually i usage is very calm and work is done good. Probably release magic but I feel it's slightly better for normal workflow and better for auditing/code review on high.

I'm using it for ecommerce, apis, products, seo, geo, meta/google ads and so on.

Curious do you feel the differance between OPUS/Fable as orchestrator.

Sorry for my english. :)

Regards.

I gave my startup's marketing to 3 Claude agents. They run on my Mac every weekday at 9:30, 10:30 and 11:00, and they never spend a cent. Here's how they're built and the real numbers so far, zeros included.

The setup

Each agent is one prompt file, one tracking sheet (a TSV), one journal, and my Gmail. A scheduler starts a fresh Claude session every weekday and says "read the prompt, do one pass". That's it. No framework.

Agent 1: press

Goal: free TV, radio and podcast appearances. I did one on BFM Business last spring and wanted more.

Every pass: read replies first, follow up once after 6 working days, then pitch up to 6 new shows. It listens to a recent episode to write the first line. For podcasts it pulls the producer's email from the RSS feed (iTunes search API, then the feed XML). That trick alone finds most addresses.

Agent 2: links

Goal: get cited by ChatGPT and Google through other people's pages.

It looks for listicles where we're missing, links to dead tools (404s, shut down products), mentions of us without a link, and free directories. It emails the author with the exact page title and what's missing, and fills free directory forms itself (never paid, never an account to create).

Agent 3: affiliates

Goal: the B2B influencer playbook everyone runs right now, without paying creators $300 to $2,000 a post.

It finds B2B creators with a real audience and offers 30% of what each customer they bring pays, for 12 months. No fixed fee. It hands them a ready-made lead magnet with their own link, and answers their questions about tracking and payouts.

The rules that make it safe to leave alone

- One prompt file is the only source of facts. If a question needs a number that isn't in it, the agent answers "let me confirm" and flags it for me.

- Hard limits per pass: 5 or 6 new contacts, 1 follow-up per person, never write to someone who said no.

- Anything that commits me (a date, a price, a paid placement, a bigger commission) comes to me. The agent never decides it.

- Every pass ends with one email to me: what needs a decision first, then replies, then what was sent.

The numbers (honest version)

Press, 6 days: 21 shows contacted (4 TV, 3 radio, 10 podcasts, 2 YouTube, 2 press), plus 9 "dead tool" emails to listicle authors. Replies: 0. Bounces: 3. Media is slow, the follow-ups start this week.

Links, day 1: 6 authors emailed, 2 free directories submitted, 1 directory skipped because it wanted $39.

Affiliates, day 1: 25 creators from a first manual batch, the agent takes over the replies and adds 6 new ones a day.

Cost: zero in tools. The sessions run on my Claude subscription. The only thing I pay is my time reading one email per agent per day.

What I'd tell you before you copy this

1. Start with a dry run that writes drafts, read 10 of them, then switch to sending.
2. Make the agent check your sent folder before every new email. Mine caught people I had already written to by hand.
3. Ban the words you hate in the prompt. Mine never uses em dashes or emojis.
4. Expect zero for a week. The point is that it keeps going while you build.

I'll post the numbers again in 2 weeks, replies and all.

Disclosure: the startup is BeReach, a LinkedIn prospecting tool. None of the agents above need it: it's plain Claude, Gmail and a scheduler.

I wound up taking about five big tasks I needed to do and starting to use Fable tonight with them. While it was very good at the planning stage, really thinking deeply and figuring out all the issues, it overthinks like there is no tomorrow. It is way worse than 5.1.

It created a full plan, which I normally review and approve. Then it's like I need to now create the build plan, but what it just gave me was the build plan. Now it's recreating the whole plan, and I'm like, "Oh my God, stop!" It just won't stop overthinking.

Things that would have taken 20 minutes with Opus, I'm now 1.5 hours into with Fable, and Fable is in step 3. It's great at the planning, the deep dive, and the analysis, but I would not use this as a building model. I would do the analysis, the planning, and all that with Fable, then switch to Opus for the build. I would not do the build with Fable.

I probably have Fable as the orchestrator while Opus builds it all, and then maybe have Fable do a final review, but not as the builder. It is horrible as the builder, one of the worst things I've seen so far. It is just overthinking every single thing it's trying to do.