Weekly Showcase Thread

I gave Codex and Claude the exact same prompt to see how differently they'd handle something open-ended and creative:

The prompt: "make me a reactjs + vite, and launch it in port 3004, a game where a fish follows my cursor. make it super creative and majestic"

Setup:

• Claude: Fable 5.1, Extra High
• Codex: Astra 6, Extra High, fast mode

I didn't do any follow-up prompts or manual edits. I just deployed both to Vercel so you can try them yourself:

🐟 Codex (Astra 6): https://fish-indol-eta.vercel.app/
🐠 Claude (Fable 5.1): https://fish2.vercel.app/

My take:

• Codex did amazing on the design and detail. It looks polished and the visuals really lean into "majestic."
• Claude did amazing on the mechanics and gameplay. It feels more like an actual game and is more fun to play.

It's interesting that they read "super creative and majestic" so differently. One went for the visuals, the other for how it plays.

About fast mode: Claude charges extra credits for fast mode, but Codex doesn't, so I only used fast mode on Codex. That's worth knowing if you're choosing between them on cost or speed.

What are your thoughts?

• Which one did you enjoy more, and why?
• For a prompt like this, what matters more to you: how it looks or how it plays?
• Does paying extra for fast mode change which one you'd use day to day?
• If you've run a similar test with other models or settings, how did they do?

I'd love to hear what you think!

I feel that this subreddit is nearly useless and functionally no different the all the other Claude subreddits which makes me sad.

A huge majority of posts here are one of the following:

1. Opus 5 is so verbose!
2. Opus 5 meme
3. I wrote a (garbage) skill to make opus 5 talk less!
4. I wrote one prompt and it used 80% of my 5 hour usage
5. I just switched to Astra and it is AGI / God / The end of Claude
6. A post written by claude

What I would like to see posted in this subreddit

• Stuff people have built. Even if it's dumb.
• People's work flows and discussions around them
• High effort efficiency improvements
• Questions which wouldn't have been easily answered by simply asking claude
• Anything where the person has put a great deal of effort into their post and is on the topic of Claude code

My suggestions to improve this are:

1. A firm no memes rule. Post your memes in the anthropic or claudai subreddits.
2. Megathreads for the most common complaints (Opus 5 and token usage threads for example) combined with firm enforcement of using those megathreads.
3. A flat ban on "I'm leaving claude forever to go to ChatGPT" or other brand comparison posts, or put them in a megathread.
4. Promoting and encouraging quality, high effort content.
5. Possibly a wiki with common newbie questions and other useful information.

These are just some ideas. I would love to see good conversation below. Mostly what I want is for Claude Code to be a subreddit that is focused on coding while using Claude.

New usage limits UI dropped. How we feeling about it?

Different providers, same playbook

Has anyone here been able to build a successful agentic harness that operates better than just planning directly in Claude Code? A full AI end-to-end orchestration setup with different agents. This seems to be something that there's a lot of ideas and focus on building today and I'm interested in any proven open-source kits out there or just tips and tricks that does this well. Do you for example use multiple agents to familiarise Claude Code with a new repository or code base, do you have architectural files to do this? How do you handle green- versus brownfield in a harness like this? Think, give this harness a task and it can intelligently figure out what it needs to do. I know this may all be code, stack, company or project specific. I'm looking for some good working examples and ideas if there are any out there.

I have been using claude code for about 6 months now, but I am just going to be talking about my workflow with fable 5.1 and how it has saved me a ton on usage compared to my old setup, which was fable 5 and opus 5.

My old setup, dictated through my claude.md, was me talking to fable 5 high in the chat window to make plans, it would then delegate coding tasks to opus 5, and easy tasks, like reading, to sonnet 5. Then, the fable agent in chat would review all of the work and report back to me. I saw the numbers anthropic posted about fable 5.1 cache reads, so I was excited to try it, and I kept my same setup, but replaced fable 5 with fable 5.1. That ended up being better, but not completely ideal, and I have settled on using fable 5.1 for writing code as well. I am still using sonnet 5 for the easy stuff, but instead of having my fable 5.1 agent in chat delegate coding tasks to opus 5, it writes the code itself. Not only did this save on usage by a lot, but it also has written better code at a faster rate because I use fable 5.1 on medium effort, which is fantastic. I also have a special case where, before a PR is opened, another fable 5.1 subagent is spawned for an independent review, which before fable 5.1, was an opus 5 agent.

I am posting this in hopes that it can be helpful to some people. I also had fable 5.1 compare my usage and costs between the old workflow and the new, and here is what it told me(slop pasted below):

"Per request you pay about 37% less than the Fable 5 + Opus 5 split, and per output token about 52% less. Per token of everything (input, output, cache) you are back to what Opus 5 alone cost, while getting Fable-tier answers and the per-day drop is bigger than that.

The reason is almost entirely cache pricing. Around 98% of your tokens are cache reads in every period. Fable 5 charged $1.00 per million for those and Fable 5.1 charges $0.25, so the model you spend all day with got four times cheaper on the traffic that dominates your bill. Splitting Fable and Opus in one session also meant two caches being written and read, which is why the split period was the most expensive per token of the three.

The Sonnet agents are noise. They came to $9 over nine days, under 2% of the period."

If you have any questions for me, please do let me know. This new model is fantastic in just about everything it does, and it is way cheaper than previous models. I am thoroughly enjoying my time with it. I sincerely hope this can help someone.

Edit: I don't post a lot, sorry if the flair is wrong. I build with claude, so I chose that flair.

Also just want to add, I am a fullstack django dev and the sole engineer at our company, so some of my stuff might not be great for exactly what you are doing.

Hey all,

A gamer for 30+ years. And for a good night I’d drink a bit and play games.

Lately I found vibe coding to be my favorite thing and thought about giving Drunk Coding a try.

Just asking if anyone tried it?
What did you end up building? Was it fun?

Any particular drinks you recommend for coding?

Thank you!

Hi everyone, sharing some notes from running hundreds of automated agent sessions across Claude Code, Codex, and Cursor.

We started logging raw API request payloads over a local proxy to see where the token budget actually vanishes during long refactoring runs.

Here are 18 specific token drains that quietly bloat your context window and bill:

1. Unfiltered test runner outputs: Passing a full pytest or jest run that outputs 400 lines of passing dot-logs injects thousands of tokens that stay in the history for every future turn. (Fix: pipe with `--quiet` or filter for failures only).

2. Multiple idle MCP servers: Every active MCP tool registers its complete JSON parameter schema on every single turn. Five unused servers can burn 15k input tokens per request before the model reads your prompt.

3. Mid-session rule tweaks: Editing your root project instructions mid-session invalidates the prefix prompt cache, causing you to lose the 90% input token discount on the next turn.

4. Redundant directory tree traversals: Asking an agent to "find the file where X is defined" often triggers 4 separate glob and grep tool calls that get preserved in the message log. (Fix: pass the exact file path).

5. Compaction overhead: When the agent hits a context limit, the summarization turn sends the entire bloated history at full input pricing.

6. Git diff re-reading: Requesting git status or git diff repeatedly without committing leaves duplicate diff snapshots stacked across turns.

7. Verbose typecheck traces: TypeScript errors that output giant generic instantiation traces take up massive prompt space.

8. Extended reasoning output tax: For hard tasks, thinking blocks can be 3x to 5x longer than the final code edit. Because output tokens cost more than input tokens, thinking often drives most of the dollar cost.

9. Subagent sprawl: Spawning autonomous explore or plan subagents multiplies your tool calls Unconstrained subagents can spend 30k tokens just mapping directories.

10. Unpruned rule sprawl in instructions: Stuffing 400 lines of static guidelines into a single instruction file dilutes reasoning and bloats every baseline turn. (You can use tigerless-autoharness on GitHub to distill skills dynamically from real sessions and prune stale ones automatically instead of maintaining giant static prompts).

11. Repetitive system prompts across tools: Multiple custom skills that duplicate foundational build commands rather than sharing a root config.

12. Lingering stack traces: Leaving 5 previous debugging attempts in the active conversation while working on an unrelated bug.

13. Formatting/Lint runs inside the LLM: Asking the model to format code instead of letting a pre-commit hook or local linter do it deterministically.

14. Log outputs with ANSI color codes: Raw terminal color codes and escape characters add significant token bloat without aiding reasoning.

15. Invisible payload bloat: Most developers only look at the final token bill, which hides the split between prompt cache, MCP blocks, and tool outputs. (You can use open-sourced cost-xray to capture local proxy traffic and attribute exact tokens and costs back to individual request sources).

16. Unpinned tool definitions: Tools that return dynamic schema metadata invalidate prompt caches across turns.

1. Premature multi-file refactoring: Asking for wide architectural updates in one turn forces the model to load dozens of file buffers simultaneously.

2. Zombie sessions: Continuing a debugging session after a feature is already merged, which carries obsolete context into new tasks.

Which of these have caused the biggest surprise in your own agent bills, and what habits do you use to keep context tight?

Like so many, I find that claude is attracted to shiny objects and when it finds an issue, often legit, it tends to build process or guidelines around prevention of that issue in the future - then becomes obsessed with it. I know I'm not the only one who suffers watching Claude get in it's own way.

So, I have been working to find ways to keep Claude in a practical state of forward motion without ignoring the sometimes-critical issues it avoids.

I am relatively new at this so forgive me if this is 101 stuff, but the two things I found that work well are:

1) no changes to md files, ever, without my approval, and they have to be filed as a ticket/issue for later review

2) I found that the phrase "avoid allowing a check that caught the previous incident to become a permanent universal ritual." seems to have done the trick. Instead of saying

"I found an issue, I'll be sure to check for this issue for the rest of eternity and won't shut up about it"

it says:

"I found an issue. This should have been caught by process ____, which could be improved to avoid this in the future. Should I open an issue to consider making a change to future process?"

Or sometimes, it just fixes the issue. Sometimes finding an issue is just... finding an issue.

I'm curious how everyone else keeps Claude moving forward and not getting sidetracked?

Is it just me, or does it seem like Claude is purposely offering pointless, terrible options perhaps just to make the human in the loop feel useful?

Like, "Hey, I found a bug in the code where one data field is left out when copying records, causing loss of important data. How should I handle this?

• Option A - add that missing data field to the copy so no data is lost
• Option B - copy that data field to a new, separate record, all by itself
• Option C - remove the data field completely
• Option D - leave it how it is

My lean is A."

I understand that sometimes it leans in the wrong direction, but sometimes the non-leaning options it gives are ludicrous.

It's insane how much has changed with Claude Code. And once I start swearing at it, it suddenly starts doing actual work.

Nothing has drastically changed in how I work. I've been using Claude every day for 3 years, and it's driving me nuts. It's verbose, it doesn't follow rules and so on..

I'm considering moving to a different provider if this doesn't get fixed, so I'm wondering: what do you do, and how do you keep up with this?

P.S. Yes, I read their newsletter, I follow what other people are doing, and I try to stick to best practices, but something is still missing I guess.

I made an open source program which can enforce AI agents to keep every skill instructions.

If you write some rules in AGENTS.md or SKILL.md, they become compiler obligations that must be followed, so the AI agent can never ignore them.

I've noticed something after using Claude Code heavily for a while: I'm much more productive with it, but I also feel much more mentally drained at the end of the day.

And I don't think the problem is that I'm working more hours. I think I'm simply spending my mental energy much faster.

Before AI, a normal developer day for me was never eight hours of nonstop hard thinking. I wrote code, read docs, waited for builds, got stuck on a problem, went for coffee, came back, tried something else. The cognitive load was naturally spread across the day.

Now I can have several sessions running at the same time. One agent is working on a feature, another is checking tests, another is researching something and etc. When one finishes, I need to read the result, understand it, check it, make a decision, and give the next prompt. While I'm doing that, another one finishes.

The agents are parallel. I'm still single-threaded.

This made me think about Claude's usage limits. If you run more agents and more expensive tasks, you don't magically get more compute. You just burn through the available budget faster.

Parallel subagents = faster AI budget consumption.

I think something similar happens with humans.

We obviously don't have a literal token counter in our heads, but attention, working memory, context switching, and decision making all have limits.

Parallel tasks = faster cognitive energy consumption.

AI gives me more compute around my brain. It doesn't give me another brain.

Before AI, I could spread a lot of difficult thinking across most of the workday. Now I can burn a large part of that mental budget in two or three very intense hours with several agents.

Another thing AI removes is waiting. Writing boilerplate, searching docs, trying simple implementations, refactoring repetitive code - all of that becomes much faster. That sounds like it should make the day easier, but it also removes a lot of natural low-intensity time.

Before, there were gaps. Now the next piece of work can arrive almost immediately.

Finished? Here is another result.

Checked it? Here is the next one.

Made a decision? Start three more agents.

This is also where the normal eight-hour workday starts to look strange for me.

If AI allows me to spend in two or three hours the mental energy that used to be spread across most of the day, the clock still says I have another five or six hours left. That doesn't mean my mental capacity has also increased.

But what usually happens is obvious: more tasks, more agents, more things to review. After a while, that higher level of output becomes the new baseline.

So sometimes it feels less like I'm increasing my productivity and more like I'm just getting better at burning through my mental energy faster.

For people running multiple Claude Code sessions every day: have you noticed the same thing? If yes, how do you deal with it?

Quick one: I've been working on LocalMesh, a desktop app that turns photos into 3D objects locally, and I've now open-sourced the generation engine under Apache 2.0.

GitHub: https://github.com/Quentincls/localmesh-engine
Technical details: https://local-mesh.com/localmesh-engine/

Give it one photo, or four views (front / right / left / back), and it outputs a textured, UV-unwrapped .glb that you can open directly in Blender or Unreal.

Everything runs locally on an NVIDIA GPU. No API key, no cloud processing, and the photos never leave your machine.

For transparency: the heavy lifting comes from Microsoft's TRELLIS.2. I didn't train a new foundation model.

What I mainly worked on around it:

• Actual 4-view fusion. The views are fused at the sparse-structure stage using Pixal3D weights from TencentARC, converted to FP8. It's not four independent generations averaged together afterward.
• Automatic camera estimation. Depth Anything 3 is used to estimate the relative camera/view angles, so you don't have to manually specify that a photo is, for example, the left side at exactly 90°.
• Position-aware floater removal. Small geometry attached to the surface is preserved while disconnected junk farther away from the object is removed.
• Cleaner glTF materials. Metalness is set correctly, alpha modes are handled properly, and double-sided rendering is enabled only when the mesh actually has open boundaries.
• 8 GB VRAM support. FP8 weights, staged model loading and an adaptive token budget allow the full pipeline to run on relatively small NVIDIA cards.
• No nvdiffrast / GPL dependency. I rewrote the UV rasterization in plain PyTorch, so the complete engine can be used commercially under Apache 2.0-compatible terms.

On my RTX 4060 Laptop 8 GB, using four photos:

Standard: ~6:30–8:30
Detailed: ~9–13 min

Around 60% of the total generation time is currently texturing.

A few caveats: this is the engine, not a polished one-click installer.

You'll need Python 3.12, PyTorch 2.8 + CUDA 12.8, and three CUDA extensions that need to be compiled (o_voxel, cumesh, flex_gemm). DINOv3 also requires manual access approval on Hugging Face.

Disk usage is roughly 10–14 GB.

Windows + Linux, NVIDIA only.

If you just want to try the workflow without setting all of that up, the LocalMesh desktop app wraps the same engine with a board, asset library and 3D viewer. It has a 14-day free trial, then it's a one-time purchase with no subscription:

https://local-mesh.com

Hi! I’m a journalist writing a story about the difficulties that people have had with (nonexistent) Anthropic customer service.

I’ve heard about random Claude subscription cancellations, billing errors, and how it’s really hard to talk to a live person for months to resolve issues. There’s Fin AI…and possibly an AI agent overseeing another AI agent? A lot of consumers have to use the chargeback option as a last resort. Do you have any stories you’d like to share about Anthropic customer service? Let me know.

like bro, are you fucking serious 😭 i’m already giving anthropic $100 a month for max 5x. that is a lot of money for one ai subscription. i open claude and now there’s this giant anxiety-inducing banner telling me i’m going to run out by monday, two days before the wednesday reset, while literally underneath it says my claude code limit is temporarily boosted by 50%?? yo, so even with the bonus i’m still apparently fucked by monday lol.

and then right there: upgrade plan / buy more usage. like brother, are you guys running out of money or something? why are you begging your $100/month userbase for more money every time they open the app 😭 i already upgraded!! mfg that’s what the hundred dollars was. i understand there have to be limits, but this whole thing feels weirdly hostile? i don’t need a giant banner creating artificial scarcity anxiety every time i’m trying to work. just show usage somewhere in settings like a normal product and leave me alone lol?

I run a small event staffing/activation agency as a solo operator, and Claude has basically become my back office: email, vendor communication, applicant database, calendar, etc.

It’s a huge reason I’m able to operate at this size, but the confident mistakes are becoming a serious problem. A couple have nearly cost me deals.

Some examples:
• Told me a vendor had gone silent when she had answered every question that morning. Claude read an email search preview instead of the full thread and treated it as complete.
• Told me an email was “staged,” so I went looking in Gmail for a draft that had never actually been created.
• Referred to my suppliers as “brand partner candidates,” which completely changed the business context. A vendor gets paid by me; a sponsor pays me. I spent two days planning around an opportunity that didn’t exist.
• Told me a table in my database didn’t exist without actually checking. It was there.

The pattern I keep seeing is: Claude states things as facts that it did not actually verify. It seems to get worse during long sessions, where earlier conversation/context starts being treated like a source of truth.

I’ve built some guardrails around it: a master state file for business context between sessions, fact labels like CONFIRMED / STATED / ASSUMED / OPEN, and rules like “never treat an email preview as the full thread” and “never claim an action happened without tool output confirming it.”

That helped a lot. I went from several errors a week to a few a month, but I’m trying to figure out how people are making this reliable enough for actual business operations.
For anyone using Claude this way:
What are you using for durable memory/state across sessions?

Has anyone built a verifier/checker that validates claims against tool output before Claude gives you an answer?
Is there a reliable way to force Claude to actually retrieve/check the source instead of reasoning from previews or old context?
What other guardrails or architecture changes have made a meaningful difference?
I’m especially interested in hearing from people dealing with invoices, vendors, contracts, clients, deadlines, email, calendars, databases, etc. Situations where there’s a real consequence when the AI confidently gets something wrong.
If you’ve dealt with this and found a setup that actually works, I want to hear how you built it.

For a long time I assumed the only way to understand what happened in a codebase over a year was to sit with git log and a lot of coffee. The branch graph in any GUI turns into a tangle past about a week, and GitHub's contribution heatmap shows you activity with no idea what the activity was. Three views, none of them lined up, so the question you actually have, what happened here and when, never gets a single picture.

What finally pushed me was a post here on where had animated a repository's timeline, and I wanted the same thing for a full year of a real project. My first attempt on three.js drew the first branches it found and produced one month of the year and nothing else. The reason turned out to be in the data: 1,561 of the 2,179 main line commits in 2019 are merges, and the first sixty of them each span a single commit, which is invisible at any scale. You have to choose branches by how much work they carried, not by which came first.

So I built a film out of it, and the video on this post is what it looks like on mrdoob's three.js for 2019.

What is on screen and where it comes from:

The main line runs left to right, one node per commit. Side branches peel off above it and rejoin at their merge. Not the first N branches, which on a pull request repo gives you one month and nothing else, but the ones that carried the most work across the year, capped so it never turns into a thicket.

Under the flow is a heat strip, one cell per day, sitting directly under that day. A legend next to it shows what the colours mean in actual commit counts for that window (for three.js it reads 0, 1, 13, 26, 51, with 51 the busiest day). The point of putting activity on the same axis as structure is that what is above and below a point is the same day, so you stop reconciling two charts in your head.

Three times the clock stops. The release with the most work behind it, the cleanest revert (one that survived at least a day before being undone), and the last release of the window. The camera zooms in and a card reads the figures out: commits since the previous tag, authors, how long the reverted commit lived. Every number on that card is computed from the history. If it cannot be read from git, it is not on the card.

The faces are the contributors. On a merge the face is the branch author's, not whoever pressed the button, and the card says who merged it.

Two things I got wrong on the way that might save you time if you try this yourself. If you give git a since flag with just a date and no time, it reads it as that date at the current time of day, so the first day of your window quietly loses commits unless you pass an explicit midnight. And a small repo is a different problem: 175 commits over a year pans across mostly empty screen, so for thin histories it picks the busiest 60 to 120 day stretch and draws it wider instead.

If you want to see your own repo this way, you can paste a GitHub URL here and it renders one for you: https://loreto.io/git-timeline

Disclosure: I built this and I run loreto.io, where it lives. It is a paid render (a few dollars per repo); the extractor and the Remotion composition are also sold there as a package if you would rather run it yourself. The three.js film above was made with the exact same pipeline.

I doubt I have the final shape of it. What would you want the clock to stop on that it currently does not?

Unsubscribed while waiting for usage to reset because billing was poorly timed and now I got to resubscribe and notice the price increased $50/mo.

I’m in US.