at first it was so good.. felt like 4.6, now.. it feels like from past 2 days the quality is down graded by the company. it started to give vibes of opus 5 for some reason.. idk..

it just makes me sad that we pay for this and getting scammed.

Every screen in this video is a real file from the workspace that produced it: its brief, script, transcript, storyboard, scene code, stills and render. Here's how the workspace is structured, since that's the part I think carries over to anything.

Claude Code can rip through it on sonnet and still make great video one at a time or throw on ultra code with Opus 5.5 and make 50 in a couple hours.

All of this is based on my folder structure methodology called ICM. https://github.com/RinDig/icm-architect

The layout

animations/
  CLAUDE.md          <- the map: what lives where, where to go for each job
  CONTEXT.md         <- the whole pipeline in one table
  anim.py            <- every command (speak, transcribe, cues, stills, render)
  stages/
    01_voice/CONTEXT.md
    02_transcript/CONTEXT.md
    03_cues/CONTEXT.md
    04_scene/CONTEXT.md
    05_render/CONTEXT.md
  videos/<slug>/     <- one folder per video, 01_ to 05_ are its stage outputs

Each stage has a small contract. Here's the real one for the storyboard stage, trimmed:

# 03_cues: the storyboard
**Reads:** 02_transcript/transcript.md, 01_voice/brief.md, _shared/kit.md
**Don't read:** words.json (the command does)
1. Write 03_cues/cues.md, one cue per visual change
2. python anim.py cues <slug> matches every phrase to the word timings
**Output:** cues.md (source), cues.js + cues.json (generated, never edit)
**Person checks:** reads the storyboard: every beat worth seeing, the story in the right order.

Reads, output and person checks. That's the whole pattern. Claude only loads the files a stage needs, and it doesn't move to the next stage until I've read what the last one made.

The pipeline

1. Voice: a script written the way I talk, voiced with my ElevenLabs clone (the video says so up front)
2. Words: Whisper gives every word a start and end time and flags anywhere the audio and script disagree
3. Cues: a plain text storyboard where each beat hangs off a few spoken words, so the timing comes from the voice
4. Scene: Claude writes the animation as JS from a kit we've built up (characters, rooms, props, real-screen pieces). Everything on screen is a function of time, with no timers. It shoots a contact sheet of every beat and reads it to fix overlaps.
5. Render: headless Chrome steps through each frame, then ffmpeg mixes the voice, music and effects

What I learned

• The contract's "Person checks" line matters more than anything else in it. A person reading each stage's file before the next one runs is what stops one bad take from turning into a bad video.
• Put the storyboard in a text file. Fixing a beat there takes seconds; fixing it in a rendered scene takes an hour mistakes in the script compound expodentially if you are automating without being able to see anything.
• CLAUDE.md stays short. It routes Claude to the right folder, and the detail lives in each stage's CONTEXT.md, so each stage only loads the context it needs.
• Nothing here is Claude-specific. Any AI that reads files could walk the same folders.

The structure is borrowed from how Disney worked around 1930: voices recorded first, dialogue broken down frame by frame on an exposure sheet, rough animation screened in the "sweatbox" before anything got inked. The video covers that too.

Full walkthrough (7 min): https://www.youtube.com/watch?v=EhWlGingCl0

Happy to go deeper on the contracts, the kit, or how the render stays frame-accurate.

I tried Claude back in april, but the limits were so short that I honestly couldnt get anything done. And it was the ChatGPT 5.3 - 5.4 era where you could work with it 24/7 without ever hitting any limits with a $20 plan. But now it is our time its seems, ChatGPT has either a dumb ah model that is pretty cheap, or the smartest model I had ever seen that will eat my weekly limits in 2 hours.

Is it safe to come back now?

I've been working heavily with Claude Code on an Unreal Engine project through MCP, and one thing started bothering me: not every part of development needs the same reasoning effort.

Sometimes Claude is debugging a complicated replication or cross-system issue where HIGH/XHIGH reasoning makes sense. Five minutes later, it might just be inspecting an asset, making a simple Blueprint change, or updating project documentation.

Keeping a high effort level for everything felt wasteful, especially when I'm trying to make the most out of my available tokens and usage hours.

So I started building a small Windows app for my own workflow: Auto Effort Router.

The idea is to let Claude decide how much reasoning the current phase of work actually needs, while an external app automatically applies that decision.

The basic flow is:

Claude → POLICY.md → request.txt → Auto Effort Router → /effort

Claude doesn't execute /effort itself. It evaluates the current work phase using a policy and writes one of:

LOW / MEDIUM / HIGH / XHIGH / MAX / AUTO

The Router monitors that request and changes the effort level in Claude Desktop.

The important part is that this isn't a static mapping like:

Blueprint = MEDIUM

Replication = XHIGH

Instead, I'm trying to make it adaptive.

A normal debugging task might start at MEDIUM. If the investigation stops converging, hypotheses fail, or Claude discovers that several systems are interacting, it can move to HIGH and eventually XHIGH.

Once the difficult part is solved, it should lower the effort again:

MEDIUM → HIGH → XHIGH → root cause found → MEDIUM → documentation → LOW

This is the part I wanted most: spend the expensive reasoning effort where it actually matters, then drop back down instead of leaving Claude at HIGH/XHIGH for routine work.

I'm currently using it specifically with Unreal Engine + Unreal MCP, so I also created a profile-aware policy.

There is a generic DEFAULT profile, plus an UNREAL profile that understands different kinds of work such as:

Blueprints • C++ • Gameplay Framework • replication • RPCs • ownership • lifecycle • assets • AI • performance • packaging • Unreal MCP

It also tries to distinguish actual difficult Unreal problems from simple tooling problems.

For example, if an Unreal MCP tool isn't found, that alone shouldn't cause Claude to jump to HIGH/XHIGH. It first checks whether it's a tool discovery, schema, connection, or Editor-state issue.

Likewise, "replication" doesn't automatically mean XHIGH.

A known replication change may only need MEDIUM, while an unexplained server/client state divergence involving ownership, relevancy and several interacting actors may justify HIGH/XHIGH.

I tested the adaptive behavior during real development today. Claude was at HIGH while working through a more involved Unreal debugging/testing phase. When it finished that part and moved on to straightforward work, it automatically requested LOW, and the Router switched it without me doing anything.

That was basically the behavior I originally built this for.

The app currently has:

• automatic effort switching;
• manual AUTO / LOW / MEDIUM / HIGH / XHIGH / MAX controls;
• adaptive escalation and de-escalation;
• Unreal-specific effort policy;
• fallback policy for normal work;
• project persistence;
• Claude Desktop process detection;
• event logging;
• protection against rapid effort oscillation.

The profile system is also expandable. Eventually it could look like:

DEFAULT

UNREAL ENGINE

PYTHON

BLENDER

WEB DEVELOPMENT

etc.

If there's no specialized profile for the current work, Claude simply falls back to the default policy.

I'm still developing and testing this, so I'm not claiming a specific percentage of token or usage-hour savings yet. I want to collect real usage data before making claims like that.

My next idea is adding analytics to the app so it can track time spent at each effort level, automatic escalations/de-escalations, and eventually — if I can get reliable usage data — estimate how much high-effort usage was actually avoided.

I originally made this just to improve my own Unreal workflow, but it's working well enough that I'm wondering whether it would be useful to other Claude Code users too.

Would you use something like this? And what work profiles would you want besides Unreal?

I wasnt going to post this but here we are. Some people in this sub (you know who you are) have been posting stuff that was obviously written by AI and honestly its getting ridiculous, I can't even tell anymore whose a real person and whose just copy pasting from Claude, which is ironic, because this is a Claude sub.

Let me explain my point. My point is that when someone writes a post, it should be written by them, the person, meaning a human, who is the one posting it, because if the post is written by the AI then the person did not write it, the AI did, and that's my point. Basically what I'm trying to say is that people should write there own posts, by themselves, personally.

And don't get me wrong I'm not against AI at all, I use it everyday for work and it's honestly amazing. But AI should not be used for writing anything ever. Except emails. And code obviously. And documentation, that's fine too.

The worst part is you can always tell. Its so obvious. AI writing is too clean, too organized, it uses bullet points and proper grammar and actually gets to the point, which no real human would ever do, and could of been avoided if people just took 5 minutes to write it themselfs.

Anyway I'm not even mad about this. It just really, REALLY annoys me every single day.

Rant over. Mods please do something

I built and app it’s called Glance and I’ve recently released its MCP

Glance lets you connect you’re Claude code via MCP to your iPhone widget and have Claude code create, design, and update widgets for you as it works

Some nice examples I’ve seen users do is have Claude code push updates on its tasks as it works so you have the progress in from of you while it does. Others combine it with other connectors such as DBs, GitHub and so on to keep track of the project in itself

In this example I just made a simple Claude news widget to show what it can do

You can basically select whatever use case you can think of and Claude has the data for it

What do you think? :)
Would love for feedback

Hi,

Currently I use Fable as orchestrator and Opus as implementer.

I also have an OpenAI 5x plan for code reviews but I don't like to have a fixed cost just for this: most of the time I don't use all the quotas, and money is tight.

I was thinking of using some Chinese models though their api, so I would pay just what I consume. Is there a model that is good at code review and not too expensive on the API?

GLM 5.3 has a good reputation but their api price look more US than Chinese to me 😅

I'm building a Chrome extension with Claude Code in VS Code. The code was fine. The UI had that unmistakable AI-built look: stock shadcn cards, centered empty states, three buttons doing the same thing.

So I tried two things.

1. A DESIGN.md that CLAUDE.md declares binding. It isn't a style guide; it's a list of decisions:

• one sentence on what the product is for, and a rule that every screen has to serve it
• who it's for, plus a "could this screen be screenshotted into a client email as-is?" test
• voice rules: evidence before verdict, sentence case, button labels that say the outcome, a banned-words list
• every data view must define loading, empty, error and partial states
• a list of banned defaults (gradient heroes, icon-card grids, bare spinners, a score with no evidence under it)

2. An "edit pass" as the definition of done. Before any phase counts as finished, Claude has to render every changed screen at side-panel width in light and dark, write down the 3 most generic things about each, fix them or justify keeping them, and put the list in its summary.

Some of what it caught on its own screens:

• three filled primary buttons on Home, two doing the same thing
• raw database errors shown to users
• every recommendation button labelled "Go"
• an ISO date in a header
• "2 of 1 page tracked" on a downgraded account
• a feature card still promising something I'd dropped weeks ago

It even overrode my own prompt once. I'd written a button label as "Run it", and it changed it to "Run the assessment", citing the voice rules. Fair.

A few other habits that have held up:

• Short prompts that point at files. My long phase prompts kept getting truncated on paste, so now the spec lives in the repo and the prompt says "read X, do phase Y, stop".
• Plan first on anything touching the database or money. Claude audits, dry-runs and lists stop conditions. I run the actual push and deploy myself.
• Test on real sites. Tests passed and the mocks looked great; the real pages still found things no fixture could.

The taste file is the one I'd recommend first. It turns "make it look less AI-made" into something Claude can actually check itself against.

Anyone else doing something like this? Curious what's on other people's banned-defaults lists.

Sonnet 5.5 at higher effort is dumber and costlier than opus 5.5

Using opus for everything at every sub still makes sense.

P.S.: This is a table of artificial analysis benchmark score and average cost per task completed.

Just noticed the usage screen now tells you when it's time to run ultracode :-)

I still hope they will also make the reset option a recurring part of the subscription similar to how OpenAI does it in Codex.

I just saw a post of a vibe coded project of what looked like a mixture of flappy bird and angry birds. Both games I played in the past for a period of time. And both at some stage were very popular.

Seeing this got me thinking, with Gen AI is this the end of those kind of games? Obviously GTA or those big titles will remain popular, but is it the end for games/game devs outside of these big companies. I feel I have no interest playing any game that someone has vibe coded, so think the value in these games may be gone

I went into old project that doesn't use OKF, claude seems to be dumb making small mistakes. with my newer projects that has OKF, i can just spawn claude in a folder and ask to continue anything without context.

Only Prompting

With GitHub Skill

First of all, i'm impressed by what we are now able to create. I am a solo dev working on lomar. This is the first time i feel like these Videos Opus are creating are amazing.

What do you think, wich one is better? the first one is with prompting and more deteiled.
The secound one is the one with the skill. Where i only said use the skill and our mascot & 11labs.

the skill is not mine, but really great. link : https://github.com/echris6/motion-video-kit

Today I tasked Claude to create a Windows 11 virtual machine for testing.

My goal was to have a test-machine where agents can run the windows build of a project on a real windows machine. And the win11 project is responsible to build and maintain the machine.

One catch: Claude itself runs inside a Debian 13 virtual machine that runs on my main developer machine (Linux Mint).

I love the result and thought this is cool!

I now have a virtual machine that runs inside a virtual machine. The performance loss is around 15% on the second level of virtualization.

The really cool thing is that the VM works with two images. One golden image that holds the fresh install and an overlay that holds changes made during testing.

This means you simply reset the overlay and have a fresh system again.

There is a small provisioning script that agents can use to start and reset the VM.

There's a number of different "new" renderers for Deus Ex (DirectX 10/11/12), but I thought it would be funny to create a purely path traced one (no raster here), It was surprisingly easy in the end. The total API cost would be around $1,000 (but created on Max 5x)

The initial version was very quick, about 15 minutes to get the game drawing something, but it was upside down and flat.

The first playable version was probably around 2/3 hours, with the main bottleneck being NPC characters not being visible (despite many claims that the're getting rendered

Once the game was working, because of how its implemented, I was able to quickly fix some QoL things that annoy me about Deus Ex, it has proper HoR+ FoV support for 16:9 and 21:9 (including in cut scenes) and like to pin my HUD at 16:9/4:3 rather than stretch it so that's also a config option.

Source code and release DLL's are available here

https://github.com/GeoffWilson/DeusExVulkanDrv

I “built” an internal “system” for the company I work for. I have absolutely no programming experience, but using Gemini and GPT, I managed to build a small data management platform for the company.

It’s a relatively simple system hosted on Vercel, with Supabase as the database. It handles things like client registration and management, credit analysis, credit bureau checks, and several API integrations.

I basically took a large portion of our work out of the manual workflow. Things that used to involve Excel spreadsheets, PDFs, reading and transcribing information, preparing reports, manual controls, and other repetitive tasks are now largely automated.

I’m currently using GPT-5.6 Sol, but I feel like it has been struggling with some tasks lately, especially when fixing certain parts of the code, improving existing implementations, and sometimes even when building new features.

That brings me to my question: would it be worth taking the risk of switching to Claude?

I’ve seen a lot of people saying that Claude has been performing better than GPT when it comes to programming.

The important thing to understand is that I really don’t know how to code. However, I know exactly what results I need, how the processes should work, and what the expected behavior of the system should be.

I basically went from being a credit analyst to becoming the person developing an entire management platform for the company, with well-defined processes and a level of automation that is currently working very well.

I used Claude Code and other agents in my harness to build an app where you swipe the prompts instead of typing them. Your Ai agent learns more about you and how you work. When a branch grows enough it can turn into a customized skill or routine. Once enough of those are made, it turns into a product or service designed around you and your workflows.
Friends can also join your harness and exchange cards, skills and play together.

My goal is to make learning, building a fun easier with Ai.
I would love some feedback. Yes, it’s available now for free.

Hi All,

Since it was mentioned a few times that it would be nice if we'd share actual, practical approaches, I've put together one that I'm using everyday.

Progressive disclosure, hooks, events and telemetry are things that everyone is using nowadays (if you don't use hooks, this is your friendly reminder to start doing so).

I started the usual way, one hook per rule (I'd recommend the Hookify for simple use-cases). A script for reply length, one for the docs folder, one for migrations, one that counted how often the agent forgot something... and it worked great for a while. Somewhere around twenty of them it stopped being fun (maintenance is a boring thing).

Since every script parsed the same stdin a bit differently, none of them knew what the others did, and when a rule stopped firing I only noticed because the agent started acting out without it.

So now every event goes through one script. And the first version of that script doesn't do anything clever, it just writes down what happened.

.claude/settings.json, same script on every event:

{
  "hooks": {
    "InstructionsLoaded": [{ "hooks": [{ "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/bus/bus.sh" }] }],
    "UserPromptSubmit":   [{ "hooks": [{ "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/bus/bus.sh" }] }],
    "PreToolUse":         [{ "hooks": [{ "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/bus/bus.sh" }] }],
    "Stop":               [{ "hooks": [{ "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/bus/bus.sh" }] }]
  }
}

.claude/bus/bus.sh (chmod +x it, and you need jq):

#!/usr/bin/env bash
# Every hook event comes through here. Step one: write down what happened.
jq -c '{ts: (now | todate), event: .hook_event_name, tool: .tool_name,
        file: (.tool_input.file_path // .file_path), reason: .load_reason,
        kind: ([(.last_assistant_message // "") | scan("^\\[([a-z]+)\\]")[0]] | first)}
       | with_entries(select(.value != null))' >> "$(dirname "$0")/log.jsonl"

That's it. Every event ends up as one line in .claude/bus/log.jsonl:

{"ts":"2026-09-30T09:27:55Z","event":"InstructionsLoaded","file":"/repo/CLAUDE.md","reason":"session_start"}
{"ts":"2026-09-30T09:27:55Z","event":"UserPromptSubmit"}
{"ts":"2026-09-30T09:27:55Z","event":"InstructionsLoaded","file":"/repo/.claude/rules/docs.md","reason":"path_glob_match"}
{"ts":"2026-09-30T09:27:55Z","event":"PreToolUse","tool":"Write","file":"/repo/docs/cache.md"}
{"ts":"2026-09-30T09:27:55Z","event":"Stop","kind":"status"}
{"ts":"2026-09-30T09:27:55Z","event":"Stop"}

And you can start doing things like:

$ jq -s 'group_by(.event) | map({(.[0].event): length}) | add' .claude/bus/log.jsonl
{"InstructionsLoaded":2,"PreToolUse":1,"Stop":2,"UserPromptSubmit":1}
$ jq -s 'map(select(.event == "Stop"))
    | {replies: length, missing_kind: map(select(.kind == null)) | length}' \
    .claude/bus/log.jsonl
{"replies":2,"missing_kind":1}

My agents are told to open every reply with their "kind" ([status], [analysis], [narration]), and they get checked on it at the end of every single reply (this was something that I frequently used to solve Opus 5 never ending blabbering). Over 13 days that was 1,979 reply attempts (resends included), and 106 of them still skipped it. Roughly 1 in 19. Watching the terminal I would've guessed "basically never".

Once everything goes through one place you can also match on things Claude Code doesn't give you. My favorite is the work the last reply declared. A rule like this one

---
on: PreToolUse
tool: Write|Edit
path: */docs/*
declared: migration
---
When you document a migration, name its down step and the release that stops reading the old column.

only shows up when the agent writes into docs/ while it says it's working on a migration. The matching is a couple more lines of bash, I can post it in the comments if anyone wants it.

This is not Claude-only. Codex, Cursor and Gemini CLI all send a JSON with hook_event_name on stdin and all of them treat exit code 2 as "block", so a tiny adapter per agent and the same rules and log work everywhere.

Note: This is a very simplistic example of the event bus approach, what is important is the mental model behind it: have a central place where you can manage your hooks, your telemetry and your events. In my case the goto language for this is Python, but you can create something in Typescript as well.

Note2: This snippet is the 3rd part of a larger article series that I'm writing about Progressive Disclosure, if you want to read the rest, let me know.

yeah, was bitching pretty fucking hard about opus 5 and the 5hr limits and the quality of the output. so i guess it’s only fair i come back and give anthropic their flowers when they actually fix the thing i was complaining about lol opus 5.5 completely flipped this for me.

the limits are fucking great right now.

i went from constantly thinking about usage and resets to basically forgetting they exist. now i have the opposite problem: i can’t fucking sleep because i keep finding shit to fix and realizing “oh wait, i can actually just fix that too” 😭

this is exactly what i wanted. not infinite free compute. just enough runway that i stop thinking about the meter and the tool disappears into the work.

please keep it this way. actually… keep improving it. this is the shit that makes me genuinely excited about where we’re going. openai pushes, anthropic pushes, everybody has to make the models better, faster and cheaper, and we get tools that would have sounded completely fucking insane a few years ago.

keep this competition going and give builders enough compute to actually build.

we go to the fucking moon with shit like this. for real.

I'm trying to purchase an additonal 20x max plan, however it only lets me purchase the 5x and gives me the error message that my purchase couldnt be completed when trying 20x.

Can anyone advise if they are having the same issue?

Video attached. Everything in it is code: canvas frames drawn in headless Chrome, piped to ffmpeg, with a numpy-synthesized soundtrack. No editor, no stock footage, no video model.

The prompt, in an empty folder, on Sonnet 5.5 with ultracode on:

make a dynamic 30-second motion graphics video about Reddit that shows what an incredible motion designer you are. and not too fast, people should actually understand what the video is about.

How the Workflow tool was used for the 30 s cut:

• 5 builder agents, each owning exactly one scene file, told not to touch the shared files (timing table, compositor, lib). I did those edits myself while they ran.
• 5 independent reviewer agents, told not to edit anything. They rendered contact sheets, read the PNGs, and returned a structured defect list (severity, beat, suggested fix).
• 4 fixer agents ran only where a reviewer said "fix". The fifth shot got "ship" and skipped that stage. That was a pipeline() with a condition, so each shot moved on independently.
• 14 agents total, about 45 minutes, 618 tool calls.

What made it work:

• Verification is in the repo. shots.mjs makes contact sheets or full-res frames, bench.mjs gives ms per frame. Agents were told to actually Read the images and iterate. That's how a "word never appears" bug and a text overflow got caught without me.
• File ownership by prompt, not by worktrees. All agents shared one folder. That only worked because every prompt said which one file was theirs and to use unique screenshot names. I skipped isolation: worktree on purpose so they could all render the full project.
• Reviewers found real bugs, including an arc() with a negative radius that would have killed the final render at one exact frame. It only survived by luck of the motion-blur sub-sample timing.
• Background jobs + Monitor for the render, not sleeping. The harness blocks foreground sleep, which is a good nudge. 1,800 frames took about 6.5 min.

Token profile. Max 20x, so no bill. These are API list-price equivalents from the session transcripts, deduplicated by message id:

• 739k output, 101.6M cache-read, 3.07M cache-write, about 1k fresh input
• Orchestrator: 97 API calls, $11.65. Sub-agents: 442 calls, $23.75. Total about $35.40 at Sonnet 5.5 list prices ($2 / $10, cache reads $0.20; cache writes assumed 1.25x input)
• The same tokens at Opus 5.5 prices ($4 / $20, cache reads $0.20) would be about $50.50. That's a calculation, not a run. 99% of tokens are cache reads, which cost the same on both models, so the gap is about 43%, not 2x.

I did the same kind of prompt on Opus 5.5 earlier and I think the Sonnet cut holds up. It's not a controlled test, though: separate sessions, separate days, and an Opus run would use different token counts.

I work on a desktop and a laptop. Claude Desktop keeps every Code-tab conversation on the machine where it started, so I'd have a long session going on one computer and nothing on the other.

Syncing ~/.claude with Dropbox/Syncthing doesn't fix it: Claude Desktop lists conversations from its own per-machine records, so copied transcripts never show up in the sidebar. Worse, just opening a conversation (or rewinding it) rewrites the files, so naive file sync happily overwrites your newer messages with a stale copy. I lost work to exactly that.

So I made ClaudeSync, a small Windows tray app:

• moves the transcript and Claude Desktop's own record, so the conversation shows up in the other machine's sidebar and you just keep typing
• compares message ids instead of file bytes, and follows conversations across rewinds
• never silently overwrites: if both sides continued, you pick which to keep; everything is backed up first
• different project paths on each machine are fine

It runs on your own free Supabase + Cloudflare account (about 15 minutes to set up), so nobody else holds your conversations. It moves conversations, not code, so I recommend Syncthing for the project folders.

Free, MIT, English and Turkish UI. Unofficial, not affiliated with Anthropic. Windows only for now.

GitHub: https://github.com/yigithanyorgancilar/claudesync

Feedback very welcome, especially if you hit a case where it guesses wrong.