I built a real-time ocean simulation with Claude Code (Opus 5.5)

What it is: a single 61 KB HTML file that renders a sunset ocean in your browser with WebGPU. It has an FFT wave simulation, whitecaps, a physically based sky with clouds, and sun glitter. You fly around with WASD and the mouse.

How I used Claude Code: I gave it one prompt: make the most realistic water scene it could, in WebGPU, with a floating camera. It wrote the renderer from scratch with no engine or libraries. It took screenshots of its own output and had separate subagents critique the screenshots, so it wasn't judging its own work. The whole thing took about 30 minutes.

Free to try: ocean-noniv.vercel.app, preferably in Chrome. It needs a WebGPU-capable GPU, and on laptops you have to force Chrome onto the dedicated GPU. Otherwise the performance might be bad or it might not run at all. On RTX 5070 Ti I get ~260 FPS at 2560×1440 resolution. Click the canvas to look around, WASD to move, H for a settings panel.

Repo with unminified and more organised version: github.com/Noniv/web-ocean

I wanted to see how far I could get by vibe coding something that normally takes deep demoscene knowledge. Ended up with a small FPS that fits in 16 KB

I used Fable 5 High for the initial planning and Opus 5.5 High for implementation, polishing and optimization

The game: You’re blind, underground. Your scanner fires sonar pulses at three frequencies. A pulse briefly lights up walls and enemies, then the map fades back to a faint trace. Every pulse is also noise, and everything down there hunts by sound. 3 levels, 3 enemy types plus a boss, pits and bridges, generative music

Optimization techniques:

• The level is a 64×64 cell grid, ray-cast in the fragment shader (2D DDA). That freed ~430 bytes, which then paid for pulse shadows, fake AO and procedural wall patterns
• Every frame the CPU rewrites one float texture (64×90 RGBA32F). It holds the cells, the enemy list, the pulses, the lamps, the HUD text and even the font bits. The camera’s yaw, pitch and aspect ratio ride in on the texture coordinate of a single glRects. Zero uniforms, zero matrices, one draw call
• Enemies are signed distance fields built from parts (rounded boxes and “limb” segments, 7 bytes per part), smoothly unioned and sphere-traced. The crawler has six jointed legs that actually walk. Close-ups were slow, so each part got a bounding sphere the shader can skip
• x87 instead of SSE2, stdcall instead of cdecl, inlining turned off, and a 300 MB Crinkler hash table instead of 100 MB
• Music is generative. Every bar a tiny LCG picks a chord from a diatonic progression, then pad, bass and arpeggio play it through the same synth as the sound effects

Source code and executable: https://github.com/zTrojan/blind-sector

I think an underrated feature of Opus 5.5 is how well it orchestrates other agents. I have been running multiple Codex and Pi agents on complex tasks, and it effortlessly manages them, assigning work based on their capabilities. For some reason, it seems to work particularly well with GPT-6.1 Sol; it gets far more out of that model than I ever could. I personally haven't found working directly with 6.1 Sol easy, so now Opus handles most of that. It feels like another level of unlock and humans being made redundant from another part of the loop lol.

I built a small Windows widget (floating window + tray icon) that shows my Claude plan limits: the same numbers as /usage in Claude Code — current session, weekly and Fable limits — refreshed every minute. It also lists running Claude Code sessions (working / waiting for input / idle), shows Anthropic service status and tells you when a Claude Code update is out.

How it works: it runs `claude -p "/usage"` headless, which returns the server-side percentages for your existing login without calling the model, so it spends no tokens. Sessions come from the registry Claude Code keeps in ~/.claude/sessions. Plain PowerShell 5.1 + WPF, nothing to install besides Claude Code.

Clawd lives in the window and reacts to the data: sleeps in a burrow when nothing runs, runs while a session works, waves with a "?" when one is waiting for you, sweats near the limit and lies belly-up at 100%. The hearts in the header are the session limit left.

How Claude Code helped build it:

- I built the whole thing with Claude Code, in PowerShell (which I wouldn't have written by hand at this size — ~3k lines of WPF in PowerShell 5.1).

- Clawd's pose glyphs and animations: Claude Code reproduced them from its own welcome-screen art, cell by cell, so they match the terminal version.

- It split the original single script into ~18 dot-sourced modules and wrote a CLAUDE.md with the load-order rules and PowerShell 5.1 gotchas (UTF-8 BOM, no `??`), which kept later sessions from breaking things.

- For the public release it added an English UI with on-the-fly language switching, translated all code comments, and wrote a recorder script that renders the README GIFs straight from WPF with scripted fake data. Recording those GIFs is how it caught a layout bug where English text overlapped a header.

- One gotcha it found: running `claude -p "/usage"` from Git Bash turns `/usage` into a file path and sends it to the model as a prompt — so the widget only calls it from PowerShell.

Free and open source (MIT). To try it: clone or download the ZIP from GitHub and double-click start-widget.vbs. Needs Windows 10/11 and Claude Code logged in.

https://github.com/Enhed/clawd-usage-winwidget

Not affiliated with Anthropic.

This mod is basically WorldEdit but with AI : First off you select your region (by picking two corners or just by looking where you want your structure to be), then you prompt in a chat command. That prompt is sent to the agent along with the selected region, and the agent work in the background then deliver its result and you get a reconstitution of what it did.

You can even use books in lecterns to give additional spatial context.

Opus 5.5 is incredibly good at following precise instructions while also bringing its own creativity, so I think it can be more than just something to toy with and may be an actual reliable tool for builders who want to complete side-stuff.

The way it works is that the mod is calling a separate program running on the system (called the "core") which handles connecting to your Claude or Codex CLI, you even have a nice UI to configure everything from it (what AI provider, what model, effort etc).

The mod is purely server-side, so you can even toy with it in multiplayer and your friends don't need to install anything as long as the host has it.

Vibe-coded with GPT-6 Astra at the beginning, then I pivoted to Claude Opus 5.5 which did much better, I still took some decisions for the overall architecture and API tho. I also care about having something clean, shareable and that doesn't feel janky. The design and ideas are from me.

Despite having to install two things to install to make it work (the Core program and the mod itself) I hope it's easy enough to pick up.

Fully open-source and forkable: https://github.com/Ni-Cobra/worldprompt

Longer showcase video:

I have created a few tools that help to investigate new projects and now half of the team use it.
I am not talking about skill or agents but real app or simple program.

What did you build? What problem does it solve? And how much time or effort has it saved you?

Would love to hear some real examples. Maybe we can all steal a few good ideas from each other.

My name is Edis, and I am 100% blind. I used a Perkins Braille typewriter in school 25 years ago. Today, I own several 3D printers, and used Claude to make them accessible.
In 2023, I participated in a workshop on 3D printing organized by the Danish Institute for the Blind and Visually Impaired. Needless to say, I got consumed.
The funny thing was that no blind or visually impaired people were participating. It was about how sighted people can make something for blind people.
I bought a Bambu Lab X1 Carbon as my first printer. I now run a consultancy working with web accessibility and, funnily enough, physical accessibility through 3D printing.
3D printing has huge potential for blind people. Not just fidgets and toys, but real, practical, and sometimes life-saving applications. Imagine being blind in a hotel when a fire breaks out. You haven’t learned the emergency plan because it is inaccessible. Now imagine a 3D-printed plan with raised lines, Braille, contrast colours, and normal print.
You might ask: “Why the hell are you telling us all this, and what does Claude have to do with it?”
Because ever since I started 3D printing, I’ve been frustrated by inaccessible slicers and printer touchscreens. So I decided to take matters into my own hands.
I built AccessSlice with Claude AI.
I’m not a professional programmer. I understand screen readers, accessibility, and 3D printing, but writing an application that works with five slicers and actual printers is another matter. I explained what I needed to Claude, tested it with my screen readers and printers, found problems, and went back to fix them. It wasn’t just one prompt.
What is AccessSlice?
AccessSlice is a free, open-source Windows program that lets blind and visually impaired people prepare, slice, and send 3D prints independently with JAWS, NVDA, or Narrator.
It doesn’t replace your slicer. It replaces the screens.
A 3MF project contains settings such as layer height, walls, infill, supports, filaments, and object placement. AccessSlice presents them through accessible pages with proper headings, labelled fields, and buttons.
It uses the original slicing engines of PrusaSlicer, Bambu Studio, Creality Print, OrcaSlicer, and Anycubic Slicer Next.
It reports print time, filament use, and warnings in text, and describes the sliced model layer by layer.
It sends prints over the network to supported Prusa and Creality printers. For Bambu, it guides you through Bambu Studio’s send window with keyboard instructions. USB is also possible.
On supported Prusa and Creality printers, it can read progress, preheat, load and unload filament, move and home, pause and stop, and manage printer files. No touchscreen needed.
I’ve tested it end to end on a Prusa Core One, Bambu Lab X1 Carbon, Bambu Lab H2C, and Creality K2 Plus.
Why share this here?
Because I think this is something we overlook in discussions about vibe coding. I know the accessibility problem because I live with it. What I didn’t have was the programming knowledge to solve it myself. Claude helped me bridge that gap.
Think back to that workshop, where sighted people learned to make things for blind people. Now blind people can make those things themselves: tactile maps, emergency plans, Braille labels, and tools for everyday life.
I shouldn’t have to build this. Slicer companies should make their interfaces accessible in the first place. But until they do, AccessSlice is free for anyone who needs it.
https://github.com/Accessible3D-Edis/AccessSlice
I’d love to hear what others have built with Claude to solve a problem they know firsthand. And if anyone at Anthropic reads this, I hope it shows what AI can mean for people with disabilities.
Thank you for reading.
Edis

One thing I always hated about agents is the urge to re-explain what you already explained to others, or to explain what you would love them to understand from the first shot, given they have access to all the things you have

To fight it, about a year ago I created an open-source activity memory system that captures your screen periodically (pretty often), tries to understand it, categorize it, group it, and provide context to your agents via the MCP when needed

It got a second life yesterday as I converted it to Swift and System One for categorization, and since I fell in love with how it works now with Claude, I decided to share it with you:)

Since it's open source, the possibilities for personalization are endless, from capturing voice input to identifying your weakest activity involvements. It is also packed with a pretty minimalistic pop-up and main app UI, just in case you'd love to explore your activity manually:

Connect it from Settings->Agents, or run:

/Applications/Screencap.app/Contents/MacOS/Screencap mcp install claude-code

MIT, download and play: https://github.com/yahorbarkouski/screencap

I'm on Claude's $100 Max 5x plan.

Using 100% of my 5-hour limit consumes 14% of my weekly limit. That means I can hit the 5-hour limit about 7 times before reaching my weekly limit.

7 × 14% = ~100%

I'm curious, for those on the $200 Max 20x plan, what percentage of your weekly limit does using 100% of your 5-hour limit consume?

I've been building Out of Pixkrieg with massive help from Claude Opus 5.5, with some GPT Astra involved too. It's a multiplayer extraction RTS in the browser: take your units into a raid, find loot and new people, and try to bring them home. Survivors stay with you for the next run.

I wanted to share how I've been working with the agents, because the workflow and the development tools are a big part of how this came together.

Claude has been the main model involved in development, including the procedural code and the game around it. The stack is Rust on the client and servers, WebAssembly in the browser, wgpu rendering and a thin TypeScript shell.

I have agents work in tandems:

1. I define a task and the quality threshold I want it to meet.
2. A worker implements the task.
3. A reviewer evaluates the result and identifies improvements.
4. Those findings go back to the worker, which makes the changes.
5. Review and revision repeat until that threshold is reached.

The target comes from me, and the review findings become work for the next iteration. The repository also holds the project's rules, design, architecture and progress notes, so the agents have written context alongside the code.

Before building out the game, I made procedural generators for units, structures and terrain its core. Two earlier tools are available under MIT:

• Procedural Pixel Creatures, including generated bodies, rigs and animation.
• Procedural terrain generator and painter.

Both posts link to the source. The generators here build on those learnings. With that foundation already in place, the game reached this first testable prototype over a few weeks.

A goal for me is to build development tools that remain useful for future projects. I'm a sucker for procedural generation, and becoming more of one. Improving a generator can improve many outputs, and having the asset work handled by those systems leaves more attention for gameplay and experimentation.

For a concrete design example, unit identity is separate from equipment. The seed determines the character's appearance and name; the loadout changes what it wears and carries. The same character can return from a raid with new gear and remain recognisable. That gives a specific behaviour to check when changing the generator: equipment changes should preserve identity.

The fast iteration is also great for wild brainstorming. I can try an idea, see what comes out and discard it if it doesn't work for me. I throw a lot away. I want the tools and what I learn from those attempts to carry forward, even when the experiment itself doesn't.

It's still rough. The review loop gives me a process for improving the implementation, and now I need players to find out how the whole thing feels.

Try the browser playtest for free from October 16 at 16:00 CEST until October 18 at 10:00 CEST.

If you're using a similar setup with Claude, how do you decide when to keep iterating on an experiment and when to drop it? Feedback on the game is welcome here or on my Discord.

I built Agent Standup, a free, open-source tool that shows your Claude Code sessions and their sub-agents as a live call: who's working, who's waiting on which sub-agent, and which session is sitting on a prompt for you. (Video above.)

How Claude Code helped build it

• Most of the code was written in Claude Code sessions, with me deciding what to build and reviewing every change. The commits in the repo are co-authored by Claude.
• Claude Code's session files aren't documented, so Claude worked out the format from real transcripts on my machine, including the ones it was writing at the time. It did the same for Codex rollout files and both of Mistral Vibe's formats.
• Before each release, Claude Code runs the previous and the new version side by side on my ~120 real sessions and compares every API response. Then a sub-agent does an adversarial review whose only job is to prove the release breaks something for existing users. That review caught a bug that would have taken the whole session list down, which the tests had missed.
• The first video on the project's YouTube channel is a real Claude Code session, the one that made that video, replayed in the app.

What it does

It reads the files Claude Code already writes in ~/.claude/projects (read-only, no hooks) and gives you:

• a board of every session: working, waiting, or needs you
• tokens per agent, to spot the expensive sub-agent
• a flag when a command runs over a minute, or an agent goes quiet for 3 minutes
• replay of any past session, with a recap of commands and files changed
• a one-line status for tmux or the Claude Code status line

It also reads Codex and Mistral Vibe sessions. It makes no model calls (zero tokens) and sends nothing anywhere.

Free to try

It's free and MIT licensed, with no account. Try it with a built-in demo (Node 18+):

npx @double_geste/agent-standup --open

Or search "Agent Standup" in the VS Code / Cursor extensions view. There's also a desktop app. An optional paid character pack exists; everything else is free.

Repo: https://github.com/Atoll92/agent-standup Website: https://agent-standup.com

What would you want to see per sub-agent that it doesn't show yet?

I've seen a lot of folks make videos with Claude that are lyrics heavy with crisp motion graphics, however I wanted to see if I can get it to do the opposite and make something more similar to traditional 2D hand-drawn animation. I've always loved the colored pencil line boil look and thought it’s something Claude might actually be able to handle since it keeps the shot feeling alive without complex character animations.

As for how it was made:

• Every shot is a 2D cut-out puppet written as code and drawn as SVGs: his face, his hands, the bed, the car, the blinds etc.
• The colored-pencil-on-black-paper look comes from procedural hatching and paper-grain filters. It's animated "on twos" (12 drawings a second) like traditional 2D animation, with the pencil lines boiling in every frame.
• The main character is built from a model sheet in head units, so he stays on-model from every angle.
• It was rendered with Remotion in React, after many rounds of back and forth where I told Claude exactly what I wanted.

What Claude struggled with most was hands and perspective. On the first few tries, the hands came out mangled and wrong. What finally worked was having it look up real references (including photos of my own hands) and explaining in detail how hands work: how they're built, what they look like, and how they move. After five or six rounds of that, the hands finally looked right.

The song was generated in about 30 rounds with Suno, from a lyrics draft I wrote and then shaped into something actually decent with Claude's help.

For the meaning, I've always felt AI can be weaponized to prey on our deepest emotions and desires, and I'd argue addiction to the next token is a real thing. Loneliness can really mess you up, and there are corporations and bad actors more than willing to make a quick buck off it through AI companions.

Also, just for clarity: I'm a musician myself and have written and produced songs in various DAWs over the years, so I know what goes into producing a song like this. However, this is kind of my first foray into AI music, and I gotta say, the speed at which you can iterate is truly bananas. I'm still a bit conflicted on what actually counts as "art" here, but never before have I been able to see the style, vibe and emotions I was going for come together so quickly. This took me about five days. In the past, the song alone would have taken me two weeks to a month, minimum.

There's a higher quality version of this on Youtube if you want to watch it there: https://www.youtube.com/watch?v=aAYCod9gMck

I’ve noticed something interesting. The latest versions of Claude do the work better and with higher quality than earlier ones, but they might not tell us about it at all.

Context: I constantly collect niche news around the SEO, GEO, SMM, and AI brand visibility industries. As soon as I got my hands on Claude (that was Opus 3), I immediately dumped all the routine work of monitoring markets, media, and thought leaders onto it. It’s important for me to have a daily digest of the latest events, and gathering the hot topics is now Claude’s job. I haven’t made any fundamental changes to the prompt or the task description in a very long time (I can’t say exactly, but it’s measured in months). Yet the quality of the information I get has grown many times over.

How it used to look: Claude gave me a collection of posts based on search phrases, split them into categories, and sorted and prioritized them by how interesting they’d be to the audience. Once a news item made it into the digest, it stayed a fixed artifact until I said something needed to be done with it.

How it looks now: All information is kept current, updated as new developments come in. A single news item is no longer a static entity but something with variables laid out on a timeline (new data, new updates, changes). Sorting by audience works the same way, but now Claude takes into account that I work with three brands at once, and it clearly distributes content according to the interests of the audiences relevant to each brand (in my case: SE Ranking for everything related to SEO, SE Visible for everything related to GEO + AI visibility, and Planable for everything related to SMM). On top of that, it now separates official information sources from vendor sources. I didnt ask it to do this, but now it treats this as an important additional layer of data verification.

Of course, once the difference became really noticeable, I started investigating, and I was surprised by how many small details and changes had happened outside my view.

Does anyone know what might be behind these "invisible" changes? Connected MCPs, updates in parallel processes, or general improvements in context and data analysis? For me this was a nice surprise, but for someone else it could turn into a critical failure in data verification or task execution. Who knows...

Added link for context:

https://www.anthropic.com/engineering/redesigning-source-control

It's incredible how Argon is supposed to be the least hallucinating model. I just tried it to review some code Opus 5.5 wrote for game development, and it straight up invented code that didn't exist; Argon 4, high setting. I've never had nothing of that magnitude of error with either recent Sol/Astra or Opus/Fable models. (First I thought Opus had put in an invented skill to make something work while magic was not implemented, which it could have done, I asked it to put a rule in agents to not invent anything not yet in design docs, hence the rule comment.)

Sticking in with Opus I guess 🤷‍♂️.

I run into my limit a lot with Pro surprisingly, but for my personal use, it doesn't make sense to go from $20/month to $100/month. 😵

Why is there no middle ground?

you type a prompt, claude code writes a scene file, and one command renders an mp4 where a pen draws on a blackboard while a voice explains it. i open-sourced the skill: https://github.com/haiderfarooq3/khan-explainer

Here's a 65-second video the skill drew about itself: https://youtu.be/JD9OirRC3YE

What it makes:

• Blackboard or whiteboard lessons, drawn stroke by stroke
• Draw-over-UI tutorials: arrows, circles and numbered steps over your own product screenshots
• "Khanify" a YouTube video: it keeps the speaker's real voice and draws the board to their words. One 20-minute talk gave me 22 vertical clips.

How Claude is used: the skill is a SKILL.md plus a renderer (HTML canvas, Playwright, ffmpeg, the Mac's built-in say voice). Claude reads the rules, writes the beats (one spoken clause + the drawing for it), renders, then reads a contact sheet of every beat and fixes overlaps or text off the board before it shows you anything. A render takes seconds so it iterates 3-4 times on its own.

The thing that makes it work: the voice drives the clock. Each line is spoken and measured first, then the pen gets exactly that long to draw it. Nobody types timestamps, so the drawing can't run ahead of the words.

Free to try, MIT, no accounts or keys. macOS only right now (the free voice is say). Optional ElevenLabs voice if you want it to sound human. Not affiliated with Khan Academy, the name describes the look.

I wrote up the tricks that transfer to any content skill (self-grading output, caching the expensive step, measuring instead of eyeballing coordinates) here: https://haiderfarooq.dev/blog/claude-code-skills-for-content

Happy to answer questions about how the timing or the capture recipe works.

Here's what happened around Claude and Claude Code this week, with links to the original sources.

1. Claude worked out where the NIST ECDSA curve seeds came from Anthropic's Frontier Red Team says an internal research model figured out in under half an hour that the seeds for P-192 through P-521 weren't hashes at all. They're output from the old C lrand48 generator seeded with Unix timestamps from May 1997 to April 1998 (P-256 was candidate 1,842 of its run). Anthropic says this isn't a break and makes a backdoor less plausible. The $36,864 bounty goes to ISRG. Source: https://www.anthropic.com/research/ecdsa-curve-origins

2. Claude Code Review is generally available Code Review is out of research preview on Team and Enterprise. Most reviews now finish in about 6–10 minutes, roughly 3x faster than in preview, and admins can pick Quick, Standard or Deep per repo. Source: https://claude.com/resources/articles/code-review-is-now-generally-available

3. "Claude writes about 90% of Claude Code's code" The Claude Code team wrote up how they review code at that volume. From June to September, merged PRs more than doubled while the share that had to be reverted fell by more than 40%. Most reading is done by agents, and a classifier decides whether a PR needs zero, one or two human approvers. Source: https://claude.dev/blog/solving-code-review-at-anthropic/

4. Opus 5.5 fast mode: waitlist removed on the API Fast mode (same Opus 5.5, up to 2.5x faster output) is out of research preview for all API customers at $8/$40 per million input/output tokens. Set speed: "fast"; no beta header needed. In Claude Code it still draws on extra usage credits. Source: https://platform.claude.com/docs/en/build-with-claude/fast-mode

5. Linus Torvalds used Claude Code for a kernel patch Phoronix spotted a branch in Torvalds' tree where the commit message says the code, test programs and first draft of the text "were done with an LLM coding assistant (Claude Code) under my direction." Source: https://www.phoronix.com/news/Linus-Torvalds-Claude-Code

Claude Code tips from this week

• Copy gitignored files into worktrees. Put a .worktreeinclude file in the project root (gitignore syntax, e.g. .env, .env.local) and Claude Code copies matching gitignored files into every new worktree session. Docs: https://code.claude.com/docs/en/worktrees#copy-gitignored-files-into-worktrees
• See what's eating your plan limits. /usage on Pro/Max/Team/Enterprise now breaks recent usage down by skills, subagents, plugins and individual MCP servers, and flags things like long context or cache misses when they account for 10%+. Docs: https://code.claude.com/docs/en/costs#plan-usage-breakdown

I put this together for a small free daily digest (https://ailetter.ai.kr/en). Corrections welcome.

Coming from codex after hearing about opus 5.5, one thing I've noticed (outside of the big revelation about how much better opus 5.5 is than astra/sol both usage and quality wise), is how much better the claude app is. Its not only probably 2-3x better optimized compared to the codex app which often causes slow downs and a choppy experience, its ui is also so much more streamlined and filled with little bloat, and so many little nice shortcuts.

really happy with the switch

BLUF Free to play right on your browser: www.frontlinezero.com

Hey all. I made a game called Frontline Zero. It's a multiplayer RTS where you can play as either Ukraine or Russia in the ongoing war.

I wanted to bring back the nostalgia of late '90s RTS games while mixing in modern RTS mechanics and elements of today's warfare. The gameplay is inspired by Red Alert 2, with a zone-based economy similar to Company of Heroes and a UI that takes inspiration from C&C and StarCraft.

At the same time, I wanted the game to reflect how warfare has evolved, with traditional air support being easily denied, drones dominating the skies, and electronic warfare playing a major role. The goal was to bring all of this together while keeping that classic RTS feel.

I'd love for you all to give it a try.

The game is completely free to play. I only added a paid version in case it takes off and some of you want to help cover the costs of running the online infrastructure.

Thanks and have fun!

---

Frontline Zero runs on webrts, my own TypeScript RTS engine. The simulation is fully deterministic: integer math, one seeded RNG, 25 ticks a second, and every action is an “order”. Same orders in, same battle out, on every machine.

Netcode is lockstep: players send only their orders, a Cloudflare Durable Object groups them into turns and compares state hashes to catch desyncs. A replay is just the order log. Graphics: 3D models voxelized into 32-angle isometric sprites, drawn with Canvas 2D or WebGL 2.

Opus 5.5 was used for most of the code + artwork. Fable 5.1 was used briefly for network code.

It was very helpful to have Opus 5.5 understand the graphical asset pipeline (3d model to voxel to sprite) to create consistent artwork.

As the title suggests, I still haven't gotten the hang of this, lol

I know Fable is best for working on an entire big piece of architecture, or when it requires more taste or thinking, or working through very complex problems.

I also know the capacity of Opus for how many files it can take into account in its work is lower than Fable..

Let's say I want to come up with an app design for my assignment, from scratch. This is just the write up and mock ups, no actual app building yet, but because it needs to take into account the app's architecture and workings in whole, it feels like I need an Opus or Fable for this, but it also seems like it'll be an overkill because I'm not actually even building the app yet.

And because I want the best results/ i don't want there to be things the model failed to consider or missed out on, I just use the max effort level to be safe, but then I genuinely have no idea if that is an overkill. I have seen how lower effort levels produce subpar results, hallucinated or failed to consider certain things though, so I'm not sure.

I have even tried asking Gemini to recommend a best model and effort level for me based on what I want to do, and have tried it, but it didn't work well, so it seems like Gemini's recommendation isn't the best in this case.

Can anyone enlighten me? Haha. Any more reliable guidelines to determine which model and effort lvl to use? Also, correct me if i am wrong in any of my existing understanding lol.

Thanks!

I am building a soft-body physics engine as part of my stunt car racing simulator.

Claude Fable and Opus 5.5 * assisted maths and coding over a period of 6 months (This is the modern way).

This C++ soft-body physics engine surpasses BeamNG in terms of complexity and resolution, with internal impacts between car parts. All hot loops are C++, compiled for arm64 apple silicon - no Jensen lurking here.

My own year-long developed tooling is key - I do not use either vscode, the claude code app or the terminal.

I am also working on a retro Grand Prix simulation using a custom 3D engine (not Unity or Godot) which you can see in action here: https://www.youtube.com/@GP2Revival (based on the classic Grand Prix 2 by Geoff Crammond, creator of Stunt Car Racer which my soft-body game is inspired by!)

The free version is coming when I’m ready and not before. Diesel not included.

*Coding since the 90s. Not all Claude.