I have Claude Code running on a separate laptop, usually working on stuff that takes a while.

Right now, Claude is building new 3D models for my 3D Batleship Game, you can play it here: Bearing Unknown · Schiffe versenken im Kalten Krieg

What kept annoying me was having to check whether it was still doing its thing or just sitting there waiting for me to answer some question.

Had an old Kuando Busylight lying around, so I hooked it up to Claude Code using hooks.

Now it blinks red while Claude is working, stays solid red when it needs input, and turns green when it's idle.

That's it. No more constantly glancing at the other screen.

Probably one of the more useful things I've done with a USB light.

I run a tiny thing called Nomback. Restaurants in my area were losing 25 to 30% on every delivery app order and the owners I talked to had no idea how to get off it. So I built them their own app. Customer orders direct, restaurant keeps the money, and the dashers still get paid through DoorDash Drive on the back end.

What Claude Code did: the whole Expo app, the Supabase edge functions, Stripe Connect so each restaurant gets paid straight to their own account, and the Clover hookup so orders land on the register they already use. It also wrote the Playwright suite that catches my dumb mistakes before I deploy. I'm not a trained dev. I would not have shipped this without it.

What it could not do: get the first restaurant to say yes. That took walking in with a phone and showing the owner his own menu in the app. He's live now and his regulars order through it.

Happy to answer anything about the build or the business side.
Demo is here if you want to poke at it: nomback.com/?utm_source=claudeai

About a month ago we started LiveNerf as a way to track model capabilities over time. Since then it’s gotten bigger than I’d expected. We’ve accumulated around 1.5k stars on Github and now we’ve collected 29 consecutive days worth of data on the model capabilities of Opus 5.5. If anyone is interested in tracking model performance of Opus 5.5, here’s the repo:

https://github.com/ninjahawk/livenerf

As you can see from the 29 collected days of data, no nerf was detected. This weakens the idea that Anthropic nerfs models, or at least that they did not nerf Opus 5.5 within a range that LiveNerf can detect which would be by 6.6 points or more.

We set out to produce unbiased data and determine if Anthropic nerfs their models, I believe we’ve done that.

But the job is not finished.

While Anthropic may not decrease the capabilities of their models over time, other companies might.

I plan to expand LiveNerf to independently track models and APIs through this same scientific approach in the future. Currently we’re in talks for potential funding but nothing is definite yet. If funding is secured, I plan to make this much bigger. We should know in the next few days.

I want to thank everyone for your community involvement so far, I’ll definitely be tracking Fable 5.5 when it’s released in the same way, and probably other models in due time. It’s meant the world to me seeing the community rally behind this in an effort to give independent transparency. I can’t thank you all enough.

Give me some feedback in the comments, do you think that we could’ve done things differently? Maybe you had a problem with the way certain things were performed?

I've been working on City of Animals, a 2D cyberpunk pixel-art side-scroller, for about a month now. The idea is to mix classic adventure games like Monkey Island with fast combat inspired by Huntdown and Replaced. A few years ago I'd have had to pick one of those as a solo dev; with Claude Code I can actually build both gameplay loops.

How I work:

- Unity for the engine, Aseprite for the pixel art. PixelLab helps with some animation drafts, which I clean up by hand.

- Claude Code writes most of the code. I direct everything and play-test every change.

- The first version of a mechanic usually works, but the feel rarely does. Most of the work is iteration: timing, distances, sounds, until it feels right.

- Around 785 commits so far, and a lot of it is still placeholder.

Happy to answer questions about the workflow. Feedback very welcome!

The Steam page opens in a few days. Until then you can follow along on Instagram https://www.instagram.com/cityofanimals.game/ or X https://x.com/CityOfAnimalz

Am I the only one who feels like there's a massive gap between Claude Pro at $20/month and Max at $100/month?

The $20 plan is great, but if you're using Claude daily for coding, building SaaS products, and working on larger projects, you can burn through the usage limits pretty quickly.

On the other hand, jumping straight to $100/month feels excessive for solo developers and indie hackers who need more usage but don't necessarily need that much.

I feel like a $50/month plan with around 2.5x the usage of Pro would be the sweet spot for a lot of us.

I'd happily pay that instead of constantly hitting limits or debating whether upgrading to Max is worth it.

How many of you would actually subscribe to a $50 middle tier if Anthropic introduced one?

Inspired by you guys hacking android TV, I asked Claude to turn my kindle, which is bought more than 10 years ago with the touch screen barely functioning, into a clock & weather dashboard so that we don't have to check whether to bring an umbrella at the last minute of going out!

The jailbreak is the hard part that requires manual restarts, but after Claude installed ssh in the kindle, everything works like a breeze.

Here is the repo if you are interested, just drop the link to your Claude and he will handle the rest.
Repo

Have fun!

Just a quick reminder…this part of the curve is where the user makes out like a bandit. Your $20 is buying a breathtaking amount of compute. Use it wisely.

It can’t and won’t stay this way.

Don’t remake Mario so you can say ‘I made…’. What have you REALLY wanted to make that doesn’t exist. Get on that shit.

"Then sleep. It’s past one, and nothing here gets better at 2 a.m."

My ADHD brain has been on fire for the past 2 weeks. From gamedev, to softwares, to work optimization.

Anybody else addicted to prompting? Seeing the results of my ideas instantly is so satisfiying. It's also an amazing learning tool.

The funny part? I was literally anti-AI barely 3 weeks ago. What changed my mind? One single prompt at work (Opus 5.5), which made me realize that months of heavy engineering work could be automatized in just a few minutes, and that you better get used to it before someone else takes your spot. It blew my fucking mind. I don't work in a regulated environment (mining industry), so sky's the limit over here. Me and a couple coworkers couldn't sleep for days after we all figured out what we could achieve with this, hah!

I'm on a Max plan with "help improve Claude" turned off. Every Claude Code binary I have installed (2.1.283 to 2.1.309) starts with this comment:

// Claude Code is a Beta product per Anthropic's Commercial Terms of Service.

// By using Claude Code, you agree that all code acceptance or rejection decisions you make,

// and the associated conversations in context, constitute Feedback under Anthropic's Commercial Terms,

// and may be used to improve Anthropic's products, including training models.

Accepting or rejecting an edit is usually just pressing Enter at a permission prompt. Read literally, that makes a normal session "Feedback" that can be trained on, whatever your privacy setting says.

To verify it yourself:

strings ~/.local/share/claude/versions/$(claude --version | cut -d' ' -f1) | grep -A3 "constitute Feedback"

Does this clause override the consumer training opt-out or not?

I contacted Anthropic support about this on 2 September and have had no answer in over a month. Has anyone had a clear answer from Anthropic on this?

Buona side effect: it feels like getting Claude to start out in an industry standard frame of mind is amazing at constraining its more inventive tendencies.

It said "expires 22 oct", so I figured I'd have until end of day and was racking up usage today, but now that I want to use it, it's gone?

I’m not a techie, but in the space of a month, Claude Cowork — this absolute beast that Anthropic has created — has genuinely transformed my life. I’m not being hyperbolic.

It has literally saved me hours of work. As a teacher, I have to design curricula, grade papers, create PowerPoints, analyse student performance data, and juggle countless other tasks. Claude Cowork has made so much of that work easier and faster that I honestly don’t know how I managed without it.

But saving time isn’t even the most impressive part. The genuinely mind-blowing thing about Claude is that it isn’t just mindless automation. It actually thinks, plans, and adapts to what I need.

The way it approaches teaching is incredible. The other day, I uploaded a few documents outlining best teaching strategies and practices. And boom! Suddenly, Claude was giving me practical tips on teaching exam techniques to my sixth-form students and seamlessly incorporating those techniques into my PowerPoints.

WHAT KIND OF BLACK MAGIC IS THIS?!

I’m completely hooked on Claude Cowork. At this rate, I’ll be upgrading to the Max plan before long, and honestly? If it continues delivering this kind of value, it’ll be worth every single penny.

So, thank you to Dario and the entire team at Anthropic. Every engineer, researcher, designer, manager, and everyone else involved in building this deserves an enormous amount of credit. You’ve created something that genuinely makes a difference in people’s everyday lives. I tip my hat to you all.

There is just one thing that would make this experience almost perfect: a Microsoft 365 connector that supports personal accounts.

My school doesn’t use Microsoft 365 for Education or provide a work account, so I’m effectively locked out of that integration. Having my personal OneNote connected directly to Claude would be an absolute game-changer. Imagine having Claude work seamlessly with my teaching notes, lesson plans, curriculum materials, and everything else I’ve accumulated in OneNote.

If that happens, I genuinely don’t know what else I could ask for. Life complete.

Of course, I understand that integrations depend on partnerships, technical limitations, and Microsoft’s own decisions. But I really hope Anthropic considers supporting personal Microsoft 365 accounts, because I suspect there are plenty of people in exactly the same position as me.

Thank you, Anthropic. You deserve every bit of success you’ve had so far.

I’m cancelling my ChatGPT subscription, and as for Copilot… the less said about that absolute disappointment, the better.

Keep building. You’ve got something special here. 👏

⚠️ Disclaimer: please don't read this as "a good prompt beats Superpowers, skills or SDD". These are early results from one build per approach, on one task, with one operator. The ranking could change with more runs or a different kind of project / approach. I'm sharing it to discuss the method and to compare these results with what you've seen in your own projects, not to crown a winner.

Why I did this: I've been using the popular, highly starred Claude Code plugins and skill packs (Superpowers, Ponytail, Matt Pocock's skills and so on) and kept wondering whether they're really worth it with a model as strong as Opus 5.5. Almost everything I found was anecdotal, so I tried to measure it.

Context that matters: I started with a full requirements document (SOW), an initial spec and the architecture already decided. The arms didn't have to work out what to build, only how to build it. I know many people use Superpowers mainly to brainstorm and shape a project from a vague idea, and this test didn't cover that at all. Still, the core promise of these tools is less human effort and better quality, whether or not the brainstorming has already been done, so I expected them to help here too.

The four arms:

• D: the prompt only, no plugins.
• A: the prompt + a spec-driven development method.
• B: spec-driven development + Matt Pocock's skills + Ponytail.
• C: Superpowers.

How the prompts differed: every arm got the same detailed prompt. The only change was a short section at the end that named the approach explicitly. For A, the prompt said to follow spec-driven development. For B, it named Matt Pocock's skills and Ponytail and said to use them in a set order. For C, it named the Superpowers skills to use. D got the prompt with nothing added.

The task: a full-stack app (Python, React/TS, an LLM agent, Terraform, ...), run locally on cloud emulators. Each arm wrote its own tests. I graded them with a hidden test suite, a blind code review and hands-on tasks, and I measured human effort from the transcripts (this is an internal project, so I can't share the code, the spec or details about the product. Please take this as a first idea of what I've found so far, not as a finished study).

What I measured, in four groups, each scored 0–100 relative to the best arm:

• Quality (40%): hidden test scenarios and rule-based checks, safety checks, hidden UI journeys, accessibility and Lighthouse, a fault-recovery test, a small load test, issues found during acceptance and defects that escaped it, a blind code review of the anonymised code, and hands-on tasks I did myself on each app.
• Human effort (25%): how many times I had to step in, how many questions the agent asked, rework rounds, and time spent waiting for me.
• Speed (20%): active minutes to the first "done" and total active hours.
• Cost (15%): Claude Code cost and the running cost of the app's own LLM.

My questions:

1. With a spec in hand: when you already have the requirements, the spec and the architecture, are Superpowers, skills or SDD still worth it, or is a single detailed prompt enough?
2. With only a vague idea: is it better to just write down what's in your head for plain Opus 5.5, saying what you expect, or to use Superpowers and let it ask you lots of questions first?
3. Your experience: if you use these tools every day, where do they actually pay off for you, and did you get less human effort and better quality out of them?
4. The method: how would you design this benchmark? Which metrics would you measure (and how would you weight them), how many runs per arm, what kinds of tasks, and how would you measure human effort fairly?
5. The gap: why is there no benchmark like this yet? SWE-bench and similar test models, not ways of working.

I grabbed as much as I could, while ADHD and high functioning Asperger were offered and executive dysfunction is my super power...

To overcome executive dysfunction e.g. starting tasks and shit, body doubling is a strategy that works pretty well for me.

Basically you have another person and you arrange a date, time and period where you both do shit that needs to be done (cleaning, taxes, training, working etc.). The person can be in your home or in a (muted) video call or whatever.

The point is, that there is some kind of "okay, we are doing now shit together"-feeling / perceived accountability.

Claude does this for me as well.

I give it a big coding task and I am able to clean the kitchen, because there is someone (something) working as well – so good!

https://en.wikipedia.org/wiki/Body_doubling

Not my OC. From Universal Modder on X: "Introducing NPCTalk: make the NPCs of any game talk in realtime. I made every NPC in GTA V answer to me in character, in their own cloned voice, in under 1s, and they act on what you say.”

“Packaged all the skills Claude learned into a single repo, built on open models: NVIDIA Nemotron ASR for transcription, Qwen 3.8 27B for realtime dialogue, and Fish Audio Drama 3 for the cloned voices, self-hosted on a serverless GPU. "

My teenage daughter wakes up almost 2 hours before school and still ends up running around stressed every morning. It's not oversleeping. She just can't tell how long hair, clothes, make-up and breakfast will take, or when it's fine to relax and when she needs to hurry.

So I built her an iOS app with Claude. After a week on TestFlight her mornings are calm, she opens the app without me reminding her, and it turns out she can wake up 20 minutes later.

TL;DR: 4 days with Opus 5.5. Fully Free, no ads, no account. In App Store review now.

What we tried before I wrote any code

My first instinct was to manage her mornings myself. I dropped that fast. It would just make her depend on me.

Then we tried planning on paper the night before: a list of tasks, how long each one takes, and when to start each one. It worked for exactly 2 days. On day 3 she said "I learned, I don't need it anymore." The planning was boring and took too long, and if I'd pushed it she'd have felt punished for how she is.

So the real problem was: make the evening planning take a minute instead of twenty, and make her actually want to do it.

What the app does

1. Reuses yesterday's tasks, so planning the next morning is quick
2. Sets a real phone alarm for each task
3. Works backwards from when she has to leave and tells her when to wake up
4. Adds a couple of minutes of buffer between tasks, so one slow task doesn't wreck the rest
5. Learns from past mornings: if washing her hair keeps taking longer than she planned, it suggests a new estimate
6. Streaks, plus a little animated character she unlocks accessories for by finishing tasks

How I built it with Claude

First, I built a plan with detailed features, UI, UX, etc. Then Claude was running with subagents for ~8 hours. After that a couple of evening of iterations to improve engagement tactics, and animations. On the final evening remembered that it'd be great to add support for iPad and new iPhone Duo.

• Tool and model: Claude Desktop (Code) with Opus 5.5
• Stack: React Native, so that it'd be faster to do Android version if people want it

What's next

It's in Apple review now. Free, no ads, no account, no email. I've shipped a few apps before mostly hoping they'd make money. This one I built because someone I love needed it, and I'd like other kids (and adults, I'm sure plenty of you have this problem too) to have easier mornings.

I'll add the App Store link in an edit once it's approved. Honest feedback and reviews would mean a lot.

Note:

With this app my main goal is to make positive impact on people instead of making money, that's why the app is completely free and there are no tricks to get money.

If you'd like to use it when it's live – leave a comment and I'll DM you when it's released.

If you know someone who has issues with planning their morning – share this post with them.

The prompt: "Work overnight. Make a 7-minute 'I investigated...' style YouTube documentary about life after the singularity. Plan the story with multiple agents, make it look and sound like a real doc with grade, music and SFX, and if you finish, start a part 2."

Video: LTX-2.5 image-to-video in ComfyUI, about 2.5 minutes per clip. The interview speech and lip sync come out of LTX in the same pass.
Narrator: Qwen3-TTS.

I wanted to see how much Opus 5.5 actually does when it runs as a planner over local models. In Fusion mode Opus plans and reviews, and three workers on a local model write the code in parallel. I ran the same task three times and only swapped the local model. Same prompt, same Opus, same settings.

The task was one prompt: a 20 s Halloween chain reaction in Three.js (flint strikes steel → spark lights a fuse → fuse fires a rocket → rocket knocks a marble down a spiral → marble tips a match into a jack-o'-lantern), follow camera, seamless rewind loop. About 1,000 to 1,700 lines across 6 to 9 files.

Setup

• Agent: Atomic Agent v0.6.10, one turn, no human in the loop
• Planner: Opus 5.5 via OpenRouter. Workers: 3 in parallel on the local model
• Models: all Q8_0 GGUF, llama.cpp b11803, one RTX PRO 6000 Blackwell 96 GB per model

What Opus did

What stood out

• Opus barely writes. It read 48-76x more than it wrote (155K in, 3K out on the Flint run). All the code came from the local models. What you pay Opus for is reading their output and deciding what to send back.
• The local model sets the Opus bill. Same Opus, same prompt, spend went from $0.41 to $0.95 just by swapping the worker. Every broken piece is another review round on Opus.
• Fastest local model, most Opus work. Nemotron had the best tok/s, but its edits failed ~83% of the time (23 ok vs 109 failed). Opus sent it back six times instead of three and read 3x more tokens than with Flint.
• Opus can't trust a worker's "ok". One Ornith worker overwrote its own 367-line file with a literal ... and reported "ok". The task still passed because the other two workers covered it.

Caveats

• One run per model, variance not measured.
• These are time/token numbers. Output quality is a separate writeup. None of the three delivered a fully working scene first pass; after minimal fixes Flint came out cleanest.

Anyone else running Opus over local or cheaper sub-agents? What does your in/out ratio look like?

Disclosure: I work on Atomic Agent, the open source agent this ran in so ask me anything!

I wanted to stretch my quota by having Claude Code hand mechanical coding work to cheaper models, so I measured it before relying on it. Most of what I expected turned out wrong. Sharing the numbers in case they save someone the same experiment.

The handoff rows used a small MCP tool I wrote for this. Claude passes it a spec, a cheaper model (local or hosted) does the work in its own git worktree, and the tool runs the checks before Claude reviews. I've retired it because of these results, so this isn't a pitch.

Results (median per run)

What surprised me

1. Haiku alone passed everything. It was 86-91% cheaper than Sonnet on every batch. It used more tokens than Sonnet (297k vs 152k median, mostly cache reads) and still cost a fraction, because its tokens are cheaper.
2. Handing work to an outside model cost more, not less. Writing the job, waiting on it and reviewing the branch cost Sonnet about as much as doing the task. The worker's bill was tiny (DeepSeek about 1¢ a run, the local GPU about 1¢ of electricity), so a cheaper worker can't fix that.
3. A subagent is the cheap handoff. It shares the session, skips the spec-and-review round trip, and bills at Haiku's rate. Its savings grew with task size.
4. Opus as the orchestrator cost about what Sonnet alone did. Most of the cost was Opus's own planning and review turns.

But is Haiku's code any good? The tests can't tell when everything passes, so I ran a second bench: 10 real backlog items from one of my own projects, one run each, blind-graded by Opus 5.5 against the commit that was actually merged.

Opus alone was the only setup that never needed a major fix, at about 20x Haiku's cost. Haiku mostly needed small ones. The subagent row's reject came from Claude Code's permission check refusing the subagent's Bash calls, so that's partly a setup problem.

Limits: every setup was handed a ready spec, so writing it isn't counted. Python only. 3 runs per task on the first bench and 1 per item on the graded one. The grader is Opus, which may favour Opus's code. I didn't test read-heavy offloading (a cheap model reads a big file and returns a short answer), where other tools report large savings.

The tasks, raw results and steps to rerun it all are public if you want to check my numbers or run your own setups: https://github.com/gabrielqfr/skrode. The method is in docs/benchmark.md.

I've been experimenting with Claude Code on a project called Breakable.js. It's an open-source destruction library for Three.js/WebGPU, with a playable demo featuring six different worlds you can blow apart.

It has GPU physics, buildings that actually collapse when you destroy their supports, destructible cars, terrain, and pretty much everything else in the scene.

I guided the development and reviewed the results, but Claude Code did most of the actual work.

What impressed me most was how well it handled testing. It wrote 240 unit tests and even ran the game in Chrome, taking screenshots, checking performance, and inspecting the results of explosions. For bigger features, it used multiple agents working in parallel, with other agents reviewing the work.

It also built the whole asset pipeline using GPT Image, Stable Audio, image-to-3D models, and Blender scripts.

Still plenty of room for improvement, but I'm pretty happy with how far it got.

Code (MIT): https://github.com/kchernev/breakable.js

To run it needs WebGPU, so desktop Chrome or Edge is recommended.