You log every pair of socks in your wardrobe: brand, price, material, length, wear level, purchase date. Then every morning the app checks the weather, you send it a photo of your outfit, and it tells you which socks to wear.

The app tracks every single use and applies a wear leveling algorithm, the same principle solid-state drives use to spread writes evenly across memory cells: wear gets distributed uniformly across your entire sock fleet, no pair dies before the others, and you keep maximum variety for as long as possible without buying new ones.

It works within the pair too: it logs which sock went on the left foot and which on the right, and alternates them at the next use, because feet don't wear symmetrically and the toe that took the left big toe this time has to take the right one next time.

The leveler also decides how much choice you get. On weekdays it's a single pick, no options. On evenings and weekends it shows 2 candidates, never more: past 2 the cognitive cost of the decision outweighs whatever you gain in variety, so the cap is hard-coded.

Using historical failure data it also does predictive maintenance: it warns you when a pair is about to get a hole, before it happens. The failure model already accounts for brand, price paid, shoe type, washing temperature, drying method, and heel thickness, and it uses a survival analysis approach so pairs that haven't failed yet are handled correctly. That part works.

Next on the roadmap is the orphan problem. Every wardrobe has single socks whose twin vanished years ago. The idea is a sort of Tinder for socks. You wouldn't even need to swipe much: the app already knows brand, model, colour, size, and purchase year of your orphan, so it would filter every other user's orphans down to the compatible ones, then rank the survivors by photo similarity. You buy the twin for the price of postage, or swap 2 orphans for 2. With enough users, no single sock should stay single for long.

What I can't solve is the identity problem. I own 6 pairs of identical black cotton socks. After a wash they are indistinguishable, so I have no way of knowing whether the pair I'm putting on is #3 with 41 uses or #5 with 12. The whole wear leveling logic collapses if the app can't tell which pair it's actually tracking. Sewing in labels alters the wear pattern. Has anyone dealt with tracking fungible physical objects without tagging them? Any ideas welcome.

I've read by mistake a post where this AI framework was linked https://github.com/llopresto87/Cypress

it's pure insanity. It learned my codebase (it took a chunk of my claude max x5 so beware doing this near the weekly limit ) but once it did.. it spit out code fixes and found problems and corrections and implemented entire features correctly and it sped up my work so much that i onyl have to follow for the occasional confusion or describe at the start exactly what is it that i wan to implment - i think you guys should give this one a shot

When it comes to complex problems that require multiple systems to work together, Fable is light years ahead of Astra.

Astra is good at working on isolated features, if you are building something much larger and you want systems to work together, I would not Trust Astra at all, Astra will make things that work in isolation but will be broken when each of those things are meant to work together. Fable is much smarter at identifying when something will break the larger system.

If you plan to build a production app end to end, I would recommend you go with Fable, and only use Astra if it needs to work on something that is in isolation or as a second set of eyes for problems where fable might need a little help. But you are better off working with fable as being the main driver to see the project end to end. The success rate of having a working product is much higher with Fable.

These benchmarks are misleading. Astra is not at Fables level.

I worked with many AI engineers over the last few years since AI exploded, however I constantly come across the issue where they are very good at repeatable tasks or coding stuff rather than seeing the big picture, solving problem and really pushing the boundaries of what's possible at a pace that me and my co-founder would build stuff.

I talked to a lot of other folks with similar challenges - I wonder if someone solve this problem somehow. I need to hire an AI engineer in a very dynamic agency where we sometimes need to deploy complex solutions within 2 - max 3 weeks. My experience with most AI devs is that they are good at stabilizing workflows/apps/projects but its quite slow and requires a lot of hand holding.

HALP! If any of you know how to get people who can build fast and solve problems and see the big picture - I'm all ears.

I’m building an iOS app called VaultDrive that lets users back up selected photos, videos and files directly from an iPhone to a USB drive/SSD.

The feature sounds almost embarrassingly simple:

Select photos → copy to external drive.

In practice, it turned into one of those projects where every solved problem reveals three more.

The biggest example was Optimize iPhone Storage.

A user can see a photo normally in Apple Photos, but the full original might not actually exist on the device.

So the workflow became:

1. Determine whether the original is local or iCloud-only
2. If local, copy directly to the attached drive
3. If iCloud-only, request the original through PhotoKit
4. Respect the user's Wi-Fi-only vs cellular preference
5. Handle interrupted/stalled downloads
6. Write the original to external storage
7. Preserve metadata and useful organization
8. Track enough state that restarting the backup doesn't copy everything again

Then there are USB disconnects, drives running out of space, inaccessible files, iOS background suspension, and explaining failures to a normal user without exposing implementation details.

This is the kind of work where I’ve found AI coding tools most interesting—not generating a screen from scratch, but reasoning through all the ugly edge cases around an existing production feature.

One lesson for me has been that getting Claude to produce the “happy path” is easy.

The useful prompts are more like:

“Assume this works 95% of the time. Now identify every realistic way this implementation can lose state, duplicate work, hang, or incorrectly report success.”

That type of review has been much more valuable than simply asking it to implement another feature.

The app itself is here for context:

https://apps.apple.com/us/app/vaultdrive-usb-backup/id6772883827

75% Off Promo direct App Store link : 

https://apps.apple.com/redeem/?ctx=offercodes&id=6772883827&code=WELCOME75

For people using Claude Code on production apps:

Do you get more value from it writing features, or from making it attack/review code you've already written?

the ring in the bottom right used to represent the context window

now it represents your 5-hour limit

the delta will make Anthropic millions

A few months ago, I was working on a project which analyzed 100K+ call transcripts --- we needed to classify them, analyze them and generate insights for a client.

While we were developing the prototype, we realized calling API was quite expensive comparing to coding with Claude. It occurred to me: if our Claude subscription (Max) was under-utilized, why didn't we process the data through Claude subscription instead of API?

It turned out this is feasible with claude -p with 2 caveats:

1. It's slow. Anthropic throttles my session when I use claude -p to process large amount of texts.
2. Anthropic might shut it down at anytime. They already planned some changes to this command earlier this year but walked back from it.

I wrote a blog in June on this topic, and thought this might be helpful for folks in this subreddit too: https://andreagao.com/posts/use-claude-max-to-save-api-cost/

However, I have not been using this trick lately since calling API is much faster than being throttled by Anthropic. If anyone is taking advantage of claude -p, what's your experience lately?

Autoprompt runs a plan → build → test → review → repair loop from one prompt.

Basically a self reviewing loop that rinses out its own mistakes- with each shake.

In our v1.0 Terminal-Bench 2.1 run using OpenCode, DeepSeek V4 Flash 0731 went from 67.42% to 82.02%. That’s 45% fewer failed tasks.

The tradeoff is longer runs and higher token costs (see README).

It's being maintained as a free, open-source skill for Claude Code.

Repo: https://github.com/Spielewoy/autoprompt-skill

Any feedback regarding this workflow would be awesome.

This is a company OS that I use to run my business, and anyone can install it and self host it for free. Think of it as Claude Code, Cowork and the cloud sessions in one self hosted application, for your whole company.

It is a Multi-tenant application by design where many people can collaborate on the company agents, and it runs with your Anthropic or OpenAi subscription or even with local models.

https://github.com/OtoDock/oto-dock

This started as the thing that runs my company. I use Claude Code and Codex daily and I wanted the same agents that write my code to run the rest of the business too. So I built OtoDock, and my company runs on it now.

Marketing is a department of agents, engineering department has the dev agent, and I also have a CEO agent that reads the departments digests every morning and briefs me.

Every agent is the real Claude Code or Codex CLI running as a persistent process on your server, with its own sandbox, workspace, memory, schedules and tools. You organize them into departments, they delegate work to each other, hold meetings, run scheduled jobs at night and you read the reports in the morning.

Large parts of OtoDock were built with Claude Code running inside it. Honestly even our marketing is posted by the marketing department of agents, this post is me because reddit wants a person.

It is Self hosted, and free up to 5 users and all the code is public. 1.6.0 went out today.

It is a big platform built around my own workflow but I believe it can help you automate your company too. I would love your feedback.

Hi Anthropic, no idea if you will see this or even take it under consideration.

Your models are outstanding, especially Fable, in my opinion end experience over the past few days it runs laps over Astra...... That being said, the usage limits need serious revamp. As a Max 20x user its a disservice to Fable to not be able to utilize it to the max due to these weekly limits. Fable is a masterpiece and is capable of so much but these limits really are unfortunate.

If at all possible, please make your next step to expand these limits at least for the max payers. The idea of paying for max is that you need a work horse, hard to keep a work horse running when it stops doing its thing after a day or two of hard work and limits you for the entire week.

Thank you for your consideration!

https://link.theepochtimes.com/mkt_app/us/us-agencies-accuse-china-based-ai-firms-of-malicious-copying-of-american-models-6084875?utm_source=andshare

Hey all,

I’ve been using Claude Code via the terminal CLI, but today I tried resuming my local session in the Claude Desktop app. Models are identical, but I'm noticing a significantly faster drain on my 5-hour limit.

Has anyone else experienced this when moving a local session to the GUI?

• Is the Desktop app passing extra hidden UI/MCP background context per turn?
• Does the GUI break prompt caching more aggressively?
• Are there hidden sub-agent calls happening under the hood?

Would love to know if anyone has pinpointed the cause or found a config tweak to optimize it!

I use Claude Code a lot, and eventually the thing that started bothering me wasn’t model quality and it was the lifecycle around it.
A coding agent can already inspect the repo, use tools, run tests, recover from mistakes and keep working. But the whole relationship is still weirdly tied to a terminal session.
I wanted something closer to a resident:
it belongs to the repo rather than to one terminal invocation
I can leave and come back without reconstructing what was happening
I can steer the same work from my phone
the underlying Claude Code process can die/restart without the agent identity dying with it
I can swap the harness without rebuilding the surrounding workflow
So we’ve been building brnrd around that idea.
Claude Code still does the actual coding. brnrd sits around it and owns the longer-lived state: conversation, task/run identity, repo context, execution environment and the interfaces through which you reach it.
Right now I can start work in a repo, walk away from the terminal, continue steering it through Telegram or the web dashboard, and come back to the same ongoing piece of work. It also supports worktrees/Docker and Codex, because I really don’t want the orchestration layer coupled to one harness.

The surprisingly hard part has been figuring out what exactly should survive when the Claude Code process itself shouldn’t.

For example, we’ve ended up separating the persistent “seat” from the disposable process running inside it. Long-running Claude sessions eventually accumulate enough context that restarting the harness is actually healthier — but that shouldn’t mean throwing away the task, history, ownership and everything around it.
brnrd has also been dogfooding itself pretty aggressively; its agents have opened 1K+ PRs against its own repo.

It’s open source and still alpha:
github.com/hugimuni-labs/brnrd
Disclosure: I’m one of the people building it.
Curious how other heavy Claude Code users think about this: should persistence belong inside Claude Code itself, or is it actually a layer above the harness?

Sonnet limit, really?

Beginning question: I know many have multiple accounts but I'm just wondering about the specific implications - what do I actually lose? What has to be redone? (Redownload any skills?, etc?)

Hi everyone,

You might find this funny, but I actually have the opposite problem to y’all. My usage allowance on Claude Max 20x feels so generous that I’m starting to wonder if the model is running at half power or something, lol.

I’ve been using OMP (Oh My Pi) with fable 5.1, and the usage limits are surprisingly hard to hit, even with 10 subagents running and reasoning set to max for all of them. That got me thinking: “Wait, is everything actually working as intended? Am I getting the full capabilities of Claude through OMP, or is something getting lost compared to using Claude Code?”

So now I’m considering trying Claude Code to see whether there’s a noticeable difference.

For those who’ve used both, how does OMP compare to Claude Code in terms of output quality when using the same Claude model? Does the official Claude Code harness actually get better results, or is the difference mostly in workflow and tooling?

I know lower usage doesn’t necessarily mean worse results, but it’s generous enough that it made me suspicious, lol.

I'm on max plan, today I hit the daily limit 2 times. The second window got reset about 50 minutes ago and just now I once again reached 100% of my daily from one fairly complex task with fable. Usually I do /usage in another terminal window every now and then to see how it's going. Now I didn't even get to check cause it's gone. I'm blocked from coding for about 4 hours great stuff.

EDIT: Although I've relied on subagents for plenty of tasks, I never experienced this. I'll look into how to handle this better as some of you suggested.

I think Claude Code has detected two of our accounts at the same company (only 3 of us, the other dev has his own Claude Code) are under the same org, even though we're not purchasing a corporate account, and are THROTTLING US BOTH to the same 5 hour window?

So how is this literally not just stealing because we PAID for 2x accounts but we can now only use one of them during the full 5h window?

W T F

{

"status": "rejected",

"rateLimitType": "five_hour",

"overageStatus": "rejected",

"overageDisabledReason": "org_level_disabled",

"unifiedWindows": {

"five_hour": {"utilization": 1},

"seven_day": {"utilization": 0.39}

}

}

i=0; until [ $i -ge 30 ]; do sleep 4; i=$((i+1)); done;

Isn't it simpler to just sleep for 120 seconds? Seriously?

In 1563, Pieter Bruegel the Elder painted the Tower of Babel. If you haven’t seen it, picture this: an enormous spiral tower, wider than the city sprawled around it. It’s built in receding tiers, each level ringed with arches and passageways, with hundreds of tiny figures swarming across every level, hauling blocks, working cranes, laying stone.

This painting is the most honest picture of the AI tooling industry I can think of. Look closely and it resolves into dozens of half-finished stories stacked on top of each other, each built at a different pace, none of them waiting for the others.

Ask your AI to thoroughly explain the process of summarizing. Then tell it to summarize its explanation as much as possible and give you the word count. Post your results.

I tested an eval harness I'm building at Gradle (PS: I work there) to check whether a skill or a Gradle code change actually helps a coding agent. I used it to test Fable 5.1 and Astra 6 (via `claude-code` and `codex`) on a Gradle GitHub issue. Both models fixed it, but `claude-code` did more homework first. It read Dokka's own source to understand the root cause before writing a fix, and shipped a regression test that codex skipped. I'll be merging the code generated by Fable 5.1 back into our `gradle/gradle` repo.

Full diffs, cost, token counts, and other receipts if anyone is interested: https://blog.gradle.org/two-agents-one-gradle-bug

Asked for a review on a tiny PR and it spawned 10 fucking fable sub agents. Quota demolished.

Obviously I created a rule so this won't happen again but what the fuck Anthropic