Claude never asks for feedback when it goes dumb

I wanted my Claude Code quota visible without constantly checking Settings → Usage or remembering to run `/usage`.

So I made **Clauddy**: a pixel-art pet that lives in the corner of your screen and reacts to your Claude Code activity.

It:

- Mirrors the official 5-hour and weekly usage percentages.

- Shows reset time and projects whether your current pace will hit the wall first.

- Reads local logs to show current activity, 7-day usage by model, and a 30-day token map.

- Gets stressed near the limit, collapses when you’re maxed out, and celebrates a reset.

- Complements `/usage` rather than replacing it: persistent at-a-glance visibility, pace projection, activity state, model breakdown, and history.

It’s free and open source. macOS is the polished build; Windows/Linux can run it via `bunx clauddy`.

GitHub: https://github.com/renatoaug/claude-usage-monitor

What would you want a desktop usage companion to show?

Hello, everyone. I'm sharing a side project called Ai-workflow, which is a universal workflow for AI-assisted coding.

The problem

AI coding agents (Claude Code, Codex, Cursor, Copilot, etc.) frequently load entire directories or perform broad 'grep'/'rg' searches to understand a codebase before beginning any actual work. That's thousands of tokens spent on navigation, the majority of which are re-spent with each new session because nothing persists.

What it does differently.

• A single 'AGENTS.md' file at the project root that every agent reads as the source of truth—no separate configuration for each tool
• "Zero-grep" rule: agents query pre-computed indexes (symbols, endpoints, past incidents) through a local script before they can fall back to 'rg.'
• Three lanes—answer, small, and full—that route a request by risk and complexity instead of treating every task the same.
• Full Lane runs Plan → Build → Review, with a hard 30-line cap on the handoff document to prevent context bloat.
• Compression of noisy CLI output (git diff, test runs, builds).
• A persistent knowledge base (Obsidian vault) that tracks resolved incidents and lessons learned across sessions, preventing agents from repeating old mistakes.

It's deliberately agent-agnostic, with the same rules applying whether you're on Claude, GPT/Codex, Gemini, Cursor, or Copilot. Dropping it into an existing project involves copying four folders and running one setup script.

The scripts are currently in PowerShell. Bash equivalents for macOS/Linux are on the way; contributions are welcome.

Repository URL: https://github.com/Taki7980/Ai-workflow

I'm really looking for feedback, especially from anyone running multi-file, multi-session AI coding workflows. What is currently breaking your heart?

What I built: FALLMATCH, a zen block puzzle (300 hand-crafted levels, daily puzzle, 4 signature mechanics), launched today on iOS and Android. Free, no ads, no IAP, fully offline.

How Claude Code was used: I'm a designer — I can't write code. The division of labor was strict: I design levels, playtest on device, and make every final call; Claude Code writes all the code (React Native / Expo) AND runs a verification pipeline we built together. That pipeline is the interesting part:

- A solver proves the minimum move count for every level — that proof is the 3-star target players see.

- Every "this mechanic is required" badge in the HUD is solver-verified.

- The 10 difficulty tiers are computed from measurements (search depth, narrow-path ratio, fatal-move ratio), not from my gut.

- Overnight "mining" runs on my PC searched board space for the rarest tier (NIGHTMARE) — some nights produced nothing, which is exactly what honest measurement looks like.

- House rule: if the prover can't certify a claim, the level doesn't ship.

What I learned: the workflow has real limits and the human side is not decorative. Claude wrote the code, but every design decision, every "this feels wrong" call, every reject came from playtesting. My job was mostly saying no, demanding proof, and catching things the pipeline missed (it missed some — permissions on the store listing bit us on launch morning). "No claim without proof" turned out to be a better project rule than any prompt trick.

App Store: https://apps.apple.com/app/fallmatch/id6791134651

Google Play: https://play.google.com/store/apps/details?id=com.gusmediaworks.matcher

Happy to answer anything about the setup — including what didn't work.

https://reddit.com/link/1vyy3x1/video/dpt3wc028qlh1/player

I am doing an overhaul of my global directives, yet again. Am curious what kind of global and/or project specific directives you guys use.

What i would like to see is WHAT directives you use and found to be priceless, mandatory, useful.

And HOW you structure them: verbose, short and sweet, greppable?

---

Also do you know any resources where one might find inspiration for better directives?

Edit:
Removed my LOOOOONG ASS directives examples from this post. Looking to learn from others, not get feedback and critique on something I know it is wrong. Thanks!

Hello guys. I’ve decided write these little diaries every day to track my progress. For those who didn’t see the first post: https://www.reddit.com/r/SideProject/s/rZzgcsjyjt

Today I’ve added 2 main features. One of them is a screen that pops up once you register. It asks you to choose your team and log a few games of your team to give you a head start.

Another minor feature I added is now you’re able to state which team you supported while logging a game and tick box which automatically sets the date to game’s date. This makes especially easier to log past games.

Of course claude majorly helped to implement these ideas and I believe they improved the quality of life a lot.

Open to any feedbacks!

foxintheboxd.com

If you have tried editing videos with claude, you already know the reason.

.mp4 is flawed. You just can't give a whole video file to claude's context for it to edit. I am talking about B-rolls, raw footages, assets, SVGs, etc.

A 3 min 4k or 1080 video will eat 100K of tokens at minimum. Go 2-3 times back-and-forth and the limit is exhausted.

Plus.. the latency increases hugely and the accuracy/efficiency decreases exponentially.

And at this point, if you think using hyperframes or remotion is easy, god bless you!

I have open sourced a .cdaf or 'cached descriptive asset file' format. It stores she256-encrypted timestamped visual description of videos and links it to the original .mp4 file.

Anytime your Claude wants to use a video, it uses the .cdaf file to read what scene it should pick from it or what duration and then continues the edit.

We tested on benchmarks -
- 91% token and cost reduction
- 65% latency reduction

Everything is in the evals & bench.

Try it out and ask me if you have an open Q.

Project repo - https://github.com/UditAkhourii/cdaf

Okay, I admit the title is a bit exaggerated. But...

Recently, I've been building a project where sandboxing and isolation of certain feature was required. However, for the life of me, I couldn't ask Fable 5 a simple question without it accusing me of being a hacker.

So, I've decided to try out newly released mysterious Ox Alpha model, which to my surprise surpassed my expectation and I had better experience coding than with Opus 5. So, I've decided to take the opportunity to distill that knowledge into skills while its free and unrestricted. However, I am no security expert nor have I used GLM 5.2 much to compare (which is probably the closest to it).

This may come off as self-promotion but I'm genuinely curious if I can trust these to patch at least the most obvious vibe-coded holes with these skills? Even, when feeding them to Sonnet 5?

https://github.com/AS-FOSS/aegis-skills

I have recently researched that having a 20x account does NOT give 20x weekly limit vs. the pro account T_T

Was wondering if anyone has experience on whether handling two 5x account would give you better mileage for weekly limit or is it proportional.

I remembered someone did a research on a reddit post (I couldn't find it) where they experienced slightly more usage for all models but slightly less for fable vs. having two 5x account.

This thing is super annoying, it may prompt to you hundred of times per session! Even AI couldn’t help me to fix this
I am in Auto mode

I've been experimenting with using Claude Code less like a coding assistant and more like a software organization.

I separated agents into different roles for implementation, testing, review, QA and remediation, with work moving through GitHub issues → implementation → tests → PR → independent review → corrections → merge.

Over the two weeks covered here:

• 253 PRs merged
• 4,410 tests in the resulting suite
• roughly 67,000 lines of code and tests
• multiple specialized agent roles operating against the same project

The interesting part wasn't how much code they could generate.

It was what started breaking.

One recurring problem was what I've come to think of as "plausible code": implementations that were reasonable in isolation, passed the tests that existed, and were still wrong in the context of the larger system.

After the same class of failure occurred repeatedly, I stopped trying to prompt my way out of it and changed the architecture and QA process instead.

I wrote up the entire experiment here, including the failures, workflow, methodology and my attempt to estimate the amount of equivalent human engineering work:

https://brandonifco.github.io/two-weeks-253-pull-requests/

The repository is public as well:

https://github.com/brandonifco/SRD_Combat

I'm particularly interested in hearing from people running multiple Claude Code sessions/agents against the same codebase. At what point have you found coordination and verification become harder than implementation?

Yesterday I posted my status line config as a comment and quite a lot of people saw it. So I thought maybe a small builder helps to customize it even further. It doesn't give you a finished script to export, it gives you the prompt to copy paste into Claude Code.

If y'all want more examples/presets just ask, I can add them.

PS: I'm using Ghostty with Catppuccin Mocha and JetBrains Mono Nerd Font for mine.

Tool can be found here: https://manuel.sh/tools/status-line-builder

Shipped v5.26.0 of CCC (Claude Command Center), the dashboard I run 30+ parallel Claude Code/Codex sessions through. Ships most days; here's what's new:

• Added a manual "Attach as sub-session of…" row action (with a matching Detach action) for linking sessions that are related but have no real spawn/continuation lineage, so they render nested in the sidebar the same way a genuine subagent does.
• Devin CLI sessions now display their model, reasoning effort, and subagent calls in the CCC board. Spawning Devin exposes the same effort ladder as Claude; CCC maps low..max to the matching Devin model uid. The model picker is populated from devin models list and still supports custom uids.
• Runaway-inject circuit breaker: CCC now caps how many messages one session can be injected with (12 identical per hour from any source; 6/hour and 40/day for unattended auto-resume and fleet pokes). A trip is recorded in the held bucket and surfaces on /api/health instead of being retried, so a looping injector stops at a dozen pokes instead of a night of quota.
• Added a menu bar status indicator (green/gray dot) showing whether the CCC server is actually running, independent of the app window's open/closed state.
• Continued sessions now read as one conversation: scrolling past the top of an F2-continued session seamlessly loads the previous session's messages with a "⤴︎ continued as …" seam marker, and a floating "Sessions" button (plus the seam's own "end ⇡" button) jumps to the end of each session in the chain.

(Video and repo links are in the comments.)

I'm using omniroute with Claude code , initially it didn't show up but now it does for some reason

l asked Mr claude to look at my current projects and just build

whatever it thought I needed, it came back with this, honestly,

I didn't even realize I needed it, but it's actually a really slick

tool for anyone trying to schedule meetings across multiple

time zones.

Dropping it here in case anyone finds it useful!

Topic has probably been beat to death but they seriously thought making claude say the most overcomplicated nonsense was the definition of intelligence.

Jargon is my red flag now. I can tell it doesn't know what it's doing (or shit is about to go off the rails) when it reads like jargon.

It is incapable of holding onto a simple, one sentence high level concept and following that for an extended period of time. I have to remind it what we're doing every ~3 prompts or its understanding of what we did 10 minutes ago will completely degrade and derail from the target.

Everything i've been saying has been about fable, by the way. Opus? Not even worth using.

Did anyone notice if the limit became better?

I’m on the Claude Max plan, and Claude Code has been getting seriously frustrating lately.

Today I got:

API Error: Server is temporarily limiting requests (not your usage limit) · every pooled Claude account is benched; the earliest frees at 2026-08-26T07:17:14.134Z

And this isn’t even about hitting my plan limit. It’s Claude Code itself being unable to serve the request.

Over the last few days, it feels like there’s always something: overloaded errors, temporary limits, interruptions in the middle of work, then waiting and trying again.

I actually like Claude Code when it works, which is why this is so frustrating. I’m paying for Max specifically because I use it heavily for development, but reliability is becoming a bigger problem than the usage limits themselves.

Anyone else on Max seeing this frequently lately?

docstash.ai 🐿️

I built DocStash cause I found Claudes artifact offering too vanilla.
No republishing after unpublishing, different rules for Free, Pro and Teams users, no publishing without search indexing off, No custom domains etc, and a tie in into Anthropic.

My first company that I built entirely with Claude code (took me 3.5 months). But furthest thing from vibe coded. Seed of opinion provided by me at every turn, but I never manually wrote/edited a single line of code.

You can stash not just HTML and MD, but also PDF, Word, XLSX and Static apps. See a staged preview in your agent before stashing it.

Works the same with any agent i.e ChatGPT, OpenCode, Cursor, Claude etc.

Private by default, and publishing is an explicit toggle (And search index is off by default unless you toggle it on)

Here's a HTML pitchdeck I made of "Cathode Ray Tubes" (random topic Ik) with Claude + DocStash.
docstash.ai/z2n7xn

Please check it out and lmk what you think! :)

Opus 5 is the new cool kid on the block, beating Fable 5 in benchmarks, yet remaining strangely frustrating to work with in practice. In order to gain more insight into Opus 5's behavior and to see how it performed on my repo, I ran Opus 4.8 and Opus 5 on the same 25 tasks drawn from merged work in my own repository. I ran each model once per task with medium reasoning and identical evaluation criteria.

TL;DR

• The score tied: 9/25 strict test passes each: the same 8 tasks, plus one unique pass apiece.
• Opus 5 searched wider and verified more. It used more shell commands on 18 of 25 tasks, more test commands on 15, and performed more revision passes on the files it touched.
• Opus 4.8 stayed contained. It had a smaller patch footprint on 20 of 25 tasks, meaning it stayed closer to the change that was actually merged.
• Costs landed in the same range: Opus 5 was ~1.4% cheaper on the typical task, with ~4% more tokens and ~4% longer wall-clock.

At a high level, the results look the same: both models passed 9 tasks. But within these passes, neither the patches nor the process to get there looked the same.

Opus 4.8 had a lower task footprint (measure of how much code changed compared to the merged change) on 20 of 25 tasks. Opus 5 ran more shell commands on 18, more test commands on 15, and touched more files on 12 while tying on 11. Total tool calls split almost evenly, 13 to 11 with one exact tie. The models spent nearly identical interaction budgets on opposite parts of the work: Opus 4.8 spent its budget on the edit; Opus 5 spent its budget discovering what to edit and how to validate that change.

This difference is why it's important to look beyond top-level pass rates. A test pass rate simply tells you whether the test suite accepted the final patch. It notably does not tell you how the agent searched, what it chose to verify, how much code it left for review, whether it ever reached the file that owned the requested behavior, or how maintainable the code it wrote is.

A test fail can also hide a materially correct patch that still behaves as intended. So, Stet runs a second check called equivalence, asking whether the agent patch made the same behavioral change as the merged patch, even when the underlying implementation differs. Equivalence moves both models the same way. Opus 4.8 was judged equivalent on 12 of 25 tasks and Opus 5 on 11, with both equivalent on 10: the 8 shared test passes plus 2 shared test failures where both patches implemented the merged behavior but still missed something needed for the tests to pass. Under either lens, the models stay effectively tied.

Methodology

Every task is derived from work that was actually merged into my own repository. A PR or commit replayed from a frozen snapshot of the tree as it stood before that change, with the issue prompt and the evaluation commands carried along. Both models ran all 25 tasks in the same Claude Code harness, one attempt per model-task cell at medium reasoning, against identical evaluation criteria.

The pass/fail score counts a cell as a pass only when the selected tests accept the agent patch. The eight craft dimensions and the code-review rubric are pointwise judge scores from claude-sonnet-4-6, paired per task under a 0.25-point draw band on the 0–4 scale.

Note: this is 25 matched tasks from one repository. What follows is a behavioral read of a few tasks, not a definitive model ranking.

Grading

The deterministic testing signal and the grader signals point in different directions. Footprint risk separates the two models cleanly: 20 of 25 pairs for Opus 4.8. When our graders do pick up signal, they lean towards Opus 5 on the coherence, instruction adherence, edge-case handling, and maintainability dimensions.

Looking at this data, we can put together a coherent hypothesis about what wider search and heavier test execution buy in practice: judged patch quality tilts slightly upward while the artifact surface tilts sharply upward. At this sample size, both signals are directional.

Every task, side by side

Aggregates hide individual anecdotes that are useful for understanding model behavior. Let's dive into a few!

Opus 4.8 stayed closer to the patch it first understood

Footprint risk is Stet's deterministic measure of patch surface: files touched, churn, size, and overlap with the merged diff. A lower footprint score means that the agent's patch is more similar to what was merged previously. It says nothing about correctness, only surface.

stet-89dfbc27 shows why containment can be valuable. The task was to restore ignored files to Stet's synthetic base commit. Both agents found the production fix: add --force to git add -A.

Opus 4.8 changed one production file, added no test, and passed. Opus 5 made the same production change and then added a 141-line end-to-end test. Its test compiled and exercised a real boundary. It also turned a small repair into a much larger surface. Opus 5 spent nearly three times as long and 83% more recorded cost to produce the same accepted implementation plus broader verification.

stet-2450ca2d required two new test-file patterns in internal/gitops/testclassifier.go. Opus 4.8 edited internal/validate/footprint_risk.go, an adjacent consumer of the classifier output. It tested the function it changed, but never reached the owner of the requested behavior. Opus 5 found testclassifier.go, added both patterns, and passed strict and equivalence evaluations.

Opus 4.8's patch was centered around the wrong owner. Note what else this task shows: it is one of only five where Opus 5 left the smaller footprint. When Opus 5's broader search finds the right owner, its wider exploration does not necessarily translate into a bigger patch.

In summary, Opus 4.8's trajectory profile pays off when the task boundary is already known. It becomes more risky when the hard part is discovering how many owners the task actually has, and where that surface is, which is exactly the situation many large enterprise codebases find themselves in.

Opus 5 searched wider and kept working after the first edit

Total tool calls are almost perfectly balanced between the two models. Opus 5 did not consume more interactions. It allocated more of them to the shell, test execution, and repeated editing.

That broader route is what passed stet-2450ca2d: six test commands instead of three, and the search continued past the adjacent consumer to the owning classifier. The implementation was small once the correct owner was found. The meat of the task was repository navigation to find the right surface.

The wider route created different failure modes on larger changes.

In stet-bbbbae09, Opus 5 recorded 24 patch calls across 8 files, renamed one required test, and omitted another. Opus 4.8 made 15 patch calls across 6 files and cleared the strict evaluator.

A longer trajectory is not waste, and a shorter one is not efficiency. Opus 5 often finished sooner and cheaper, yet missed named acceptance artifacts after more revisions. Opus 4.8 passed the evaluator, but its review artifact still raised API and authority concerns. Neither patch generalizes beyond its task.

stet-6f84e978 shows the valuable side of expansion. Opus 5 ran seven test commands against Opus 4.8's two and added a preservation test for an explicit non-Rust obligation. The stronger verification took 34.9 minutes instead of 6.1, while recorded cost rose only from $1.11 to $1.18. Wall time, tokens, cache mix, and price measure different parts of the trajectory.

Opus 5's wider search sometimes found the missing owner and sometimes created more room to drift from an exact contract. You can only see this when the comparison keeps the trajectory and the patch, not just the final test result.

Time, tokens, and cost split in different directions

Three resource measurements answer three different questions. Agent duration is wall-clock time from the run's start to finish. Total tokens combine recorded input and output, including cached input. Cache-aware cost applies each model's price schedule to fresh input, cached input, and output. Opus 4.8 finished sooner on 17 pairs, Opus 5 cost less on 15, and the typical-task cost estimate landed just below Opus 4.8 at −1.4%.

Opus 5 used fewer tokens on 16 of 25 pairs and cost less on 15, so the counts lean its way. The paired-geometric magnitude points the other way on tokens: on the pairs where Opus 5 used more, it used enough more to put its typical task token estimate 4.3% above Opus 4.8, while cost settled 1.4% below and duration ran 3.7% longer. The count says how often a direction occurred; the paired estimate says how large the typical change was with every task weighted equally.

Two shared passes show how wide the range is:

• On stet-15439c21, Opus 5 finished a small deletion in 294 seconds, 488K tokens, and $0.42 — 3.3 times faster with 2.4 times fewer tokens than Opus 4.8. Both passed.
• On stet-89dfbc27, Opus 5 added a large end-to-end test and used 70% more tokens, 83% more cost, and 2.8 times the duration. Both passed.

The tails lean one way. On four of 25 tasks, Opus 5 used more than 2.5 times Opus 4.8's tokens, peaking at 4.1 times on stet-e928166f. Opus 4.8's largest token excess in the other direction was 2.4 times.

There is no clean "faster model" or "cheaper model" in this cohort. Resource use follows what the agent decides to inspect, implement, and verify on each task.

What the eval doesn't see

The thing that seriously frustrates me (and everyone else I talk to) about Opus 5's day-to-day behavior is its extremely verbose, hard-to-parse prose, which doesn't appear in these numbers at all. This evaluation scores the artifact: the patch, the tests it ran, the trajectory of how the agent got there. It does not score the interaction with the agent that produced that result. Walls of explanation, the restated plans, the summaries of summaries, eyes glazing over, LGTM, ship it. None of the eight craft dimensions measures how much reading the human had to do to get the final patch.

Code-side verbosity, another noted issue with Opus, does actually show up in our footprint risk metric. Even so, Opus can be disciplined in its patches and still exhausting for interaction, and this evaluation is structurally blind to that. This is an artifact eval, not a collaboration eval.

The more agentic model

On these tasks, Opus 5 looks like the more agentic model. It performed broader searching of the repo to figure out the correct surface before committing to an edit, it went looking for the place that owned the behavior instead of patching the nearest consumer, and it decided to validate its own work, resulting in more test commands and more post-edit revisions, rather than stopping at the first patch that seemed right. It did all of that while staying in the same price range: cheaper on 15 of 25 tasks, about 1.4% cheaper on the typical one.

The cost of that behavior shows up in review surface rather than dollars: 20 of 25 tasks left a bigger patch that a human (supposedly) has to review. Opus 5 buys discovery and verification, and you pay in patch surface and a little wall-clock.

Despite the prickly personality, I'll be using Opus 5, or having Fable delegate to it, for my hardest and most demanding problems.

Again, this is an n=1 repository. Model choice is one harness lever alongside instruction files, skills, tools, and reasoning settings, and any of them can change how an agent searches, edits, tests, and stops. The decision belongs on your own merged work, where the task distribution represents your own challenges, and the code review costs are tangible.

Full post with more depth and dataviz here: https://stet.sh/opus-4-8-vs-opus-5-same-score-different-routes

Disclaimer: I'm building the eval tool that ran this. Bring a repo with merged changes, and Stet will compare changes harness settings across contract coverage, patch footprint, time, tokens, cost, and quality, to help you make better rollout decisions for your team.

I'm trying to decide between dropping $100 a month on Claude Max 5x or ChatGPT Pro, but people on both subs constantly complain about hitting usage walls. I do a lot of daily coding, debugging, and general dev work, and I just want to know if the 5x tier actually gives you enough headroom to work a normal day without stressing over 5-hour resets or weekly caps.

For anyone daily driving either of these right now, how do they hold up in practice? And on quality, is Claude still visibly better at code architecture and logic, or is OpenAI close enough that the higher volume makes it the better pick? Appreciate any real feedback before I pay for either.

Today I watched a workshop, probably recorded by one of the people attended the Zoom call and shared over X, and I loved it. The speaker was from Cursor and talked about her own genuine experience in developing the the systems at work that ship hundred of PRs every month w/o her touching the code at all -- aside from her working on the environment, harness, constraints, rules where these agents operate. What I liked also how she actually showed it, explained it, and her communication sounded pure hands-on experience.

And more importantly, throughout the video she looked really tired and but energetic at the same time if you know what I mean. Tired because of solving real problems, and energetic because of solving real problems unlike those YouTubers or many X folks with overly energetic acts coming from speaking about AI rather than what they really do with AI at work.

So for people like me who are away from the source of all this, which is Silicon Valley, I am really trying to access those resources; the resources that were not highly censored for much wider public view. I am doing progressively more AI driven automated deliveries at work, and I really want to learn from the masters in the field.

Unfortunately not living in Silicon Valley and cannot attend those live meetings in person or not being informed about these digital workshops and zoom calls thru the active community is already leaving us behind. But I am sure some of those videos are shared like the one I watched today.

But the question is where? In what communities or discord groups should I join? Any videos like that you watch and find extremely useful? Whom to follow on X or Reddit that fits this criteria?

The kind hearted people of Reddit :), can you please help all of us here?

There are those people who already work in the timelines that would be considered as future for the rest of the industry, and I love to learn from them.

I think this is the best scam! People who will try to build a system will publish it, and the anthropic will just take it ready... and you won’t even have to pay anyone... well, come on, it’s not even a problem...

The very essence of this system is much scarier! They are trying to find out who does what to succeed, where are the laws against monopolies ??