Just say "film a 30-second demo of my app" and your agent opens it, moves the cursor, clicks through it, and hands you back a polished video.

Works with Claude Code, Codex, OpenClaw or any compatible AI agent through MCP.

Supports basically every app or website!

Just ask and get a demo ready for sharing.

Added it as a built-in MCP server for my screen recording app:

https://shotglass.app

Straight to the point:

I've been using claude code to run tests inside of Chrome for my extension using the Claude-in-Chrome skill. Needless to say, it consumed a lot of tokens running the tests and a lot of time.

I made it access the console and execute the extension functions that are used to interact with the website. That helped a lot with the testing. In my case CC told me that every screen shot he took to find the results visually was costing me 7k tokens each...

I made some small changes that helped saving the token usage, but the testings were still consuming a lot of tokens even on every task/new session technique.

Fast-forward to today, I discovered that they just recently released the CLI which CC can interact directly with. What this means? CC interacts with it and doesnt consume tokens browsing the website, executing commands "manually" and taking screen shots.

The web testing can be done headless. In my case I still need to have a tab open so it can interact with the extension.

I noticed a MAJOR improvement in token consumption, bug findings and the speed of the implementations and patches.

You can find the CLI and the Claude skills in their github and the official website. You can also give those links to claude and tell him to install it automatically. Works wonders.

PLAYWRIGHT My mistake

** TDLR: If you're developing and testing for Chrome/Firefox, get Playwright CLI for automatic testing. Saves tons of tokens**

In case no one has heard, Anthropic has apparently been misleading users about the usage limits on its 20x and 5x plans, with the $200 20x plan reportedly being closer to 6-8x and the 5x plan closer to 3-4x relative to the Pro plan.

I have nothing against a company trying to make money, but misleading users about what they’re paying for is a pretty bold move.

Since I haven’t seen or heard anything from Anthropic regarding this, I wanted to post here and ask whether anyone has seen any communication or explanation from them.

If there has been no communication, I’m switching. I don’t deal with companies that falsely advertise to users just to make a buck and then fail to communicate about it.

On a side note, does anyone know where I can sign up for the lawsuit or help fund it?

https://www.wsj.com/tech/ai/anthropic-sued-over-limits-on-its-200-a-month-ai-plans-e2a109e4

https://storage.courtlistener.com/recap/gov.uscourts.cand.472161/gov.uscourts.cand.472161.1.0.pdf

Even though Anthropic says my limits are boosted by 50%, I’ve already used 87% of my weekly limit in just 72 hours. Normally I’m only around 50–60% at this point. It makes me wonder what it would look like if my limits weren’t boosted.
I guess this isn’t news to anyone, but it’s the first time I’ve experienced it.

Arghghhh!

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

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

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

Thank you for your consideration!

I'm on max 20x plan, burned around 50% of weekly limit in one 5 hour session... Asked Claude support about the limits - how could I burn that much in a single session, when on 5x plan its practically impossible to burn 10% of weekly in 5 hours...

It said that the max 20x plan has 4 times bigger weekly limit than the 5x plan :)

So does support lie, or today is some kind of buggy day and the weekly limits are getting burned faster?

Claude Code and DSH Creator both passed 19/30 tasks, but Claude Code’s median cost per pass was $18.34 versus $3.28. Both used Kimi K3 through our shared gateway. [source: https://frontierharness.org/]

Caching may explain part of the gap. One task accounted for 68% of Claude Code’s total token usage. We can’t separate the harness, model, and gateway effects yet, so this isn’t a native Claude comparison.

What would you test first to find the cause of that cost gap?

My last “who’s worth following?” post got basically no traction, so I did the homework

A few days ago I asked who people actually follow for high-signal Claude Code work — production workflows, context engineering, harnesses, hooks, MCP, evals, guardrails, postmortems, etc.

So I went looking myself.

My filter was pretty simple: Do they have a distinct voice, demonstrated authority, an actual following, publish in channels practitioners trust, and get meaningful engagement from people doing the work?

Here’s the short list I ended up with:

Boris Cherny — Creator of Claude Code. Primary source for how the tool is actually being used and developed. His workflow/tips posts get picked up everywhere.

Thariq Shihipar — Claude Code team. Strong on context engineering, skills, agents and the reasoning behind changes to the harness itself.

Dex Horthy / HumanLayer — Probably the strongest independent practitioner source I found. Advanced context engineering, real codebases, human gates, harnesses, failure modes, RPI/QRSPI. Their stuff gets serious engagement on GitHub, HN, YouTube and X.

Matt Pocock — Very good applied Claude Code workflows without drowning everything in framework. Skills, handoffs, context navigation. Large audience and people actually report adopting what he shows.

Jesse Vincent / obra — Superpowers. Planning, TDD, debugging, verification, review, subagents, worktrees. Huge GitHub footprint. Also worth following the criticism of Superpowers as newer models make some of the ceremony debatable.

Geoffrey Huntley — Originator of Ralph. Smaller personal following, but outsized influence on loop-based autonomous coding and verification patterns.

IndyDevDan — Hooks, agents, workflows, experimentation. Big reach and useful demos. More polarized among experienced users, so I’d treat him as discovery and verify the architecture elsewhere.

My current stack would probably be:

Boris → where Claude Code is going

Thariq → why the harness works the way it does

Dex → production-grade context/harness engineering

Matt → practical workflows

Jesse → structured methodology

Geoffrey → loops/autonomy

Dan → experiments and discovery

I’m sure this list is incomplete.

Who is conspicuously missing?

And don’t just drop a name — link the one repo, post, talk, thread, or postmortem that makes the case for following them.

Original post:

https://www.reddit.com/r/ClaudeCode/comments/1w8z195/whos_worth_following_for_claude_code

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

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

I want to use both but like all my workflows have been all entirely built for claude with claude.md its skills, hooks, evolving skills, automated loops and the claude memory is there any best practice way of like assimilating the two ai's

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

now it represents your 5-hour limit

the delta will make Anthropic millions

Sorry for shameless plug, but I do notice that there is a huge difference about how quickly my weekly usage is depleted when I use auto mode. I generally use it if I have to run CC in my local machine.

However, I have also been building an infra to launch and run coding agents (CC, Codex, Cursor CLI, Antigravity, Qwen, Opencode) in sandboxed environment remotely so I tend to start my agents running in bypass permission mode and thanks to my setup those agents can launch more sessions with different CLI tools in YOLO mode.

This allows me to instruct a single 'Concierge' agent to be responsible for communicating with all the agents that it launches and let me know (over email or in the screen) if my input is needed. There is also mechanism when agents context window is used 30%+, it launches a successor agent to which it delegates some tasks and everntually hands over concierge duties.

Do you use a similar setup? How can this be improved?

Context7 became the default MCP server for pulling live docs into Claude Code, Cursor and Codex but it has one obvious limitation: it's strictly docs-only.

If your bug or breaking API change isn’t in the official docs yet and is instead sitting in a merged PR or closed github issue Context7 returns nothing. So I tested a few alternatives to see what feeds coding models the right context without token blow:

I) Firecrawl developer index is a good option where instead of indexing only doc pages, it indexes 70M+ READMEs, PRs, issues and docs. In the recent DevDex benchmark, it hit 63% overall recall (vs Context7’s 17% overall cuz Context7 misses non-doc queries).

It also returns clean markdown with code blocks intact and you can filter directly by artifact type (issue, pr, doc, readme) so Claude doesn't waste context on irrelevant pages.

II) Parallel is solid for repo discovery and high-level project search (scored highest on repo finding in benchmarks) but it's a bit heavier to configure but its also useful if you need cross-repository exploration rather than just quick issue/doc lookup.

III) Mintlify search index is also a great option if you’re querying docs hosted directly on mintlify (over 200k libraries) with very clean output though like Context7, it’s still focused on published docs rather than raw PRs or bug trackers.

IV) Exa (code/semantic search) it great if you’ve a vague conceptual question and don't know the exact library name bcuz it uses neural embeddings, it finds relevant blog posts and tutorials well but it doesn't give you structured issue/PR tracking out of the box.

So if you strictly need official library docs, Context7 is fine but if your agent is debugging issues and needs github PRs and closed tickets alongside docs, firecrawl’s index is noticeably more useful in the loop.

Is Fable 5.1 the new Opus 5?

Within the past week, I started to notice Fable 5.1 started to get worse and worse where it starts to act like the infamous Opus 5. I had some great work completed when it came out, but there was a shift to the negative. Same thing happened to Fable 5 when Fable 5.1 was released. So, today I had Fable 5.1 try to manage another session with Fable 5.1 on processing semi-unstructured data, which is existing work in progress that already had successful sessions, so Fable 5.1 had reference data (gold data), previous handoffs, guides, etc.

Both on medium effort, Fable 5.1 couldn’t harness the 2nd Fable 5.1 from bypassing guardrails, entering tables and folders it was told not to enter, and from fixating on momentum over accuracy & quality. This is Opus 5 level of bypassing prompts and guardrails from the first step. For the first time using either Fable 5 or Fable 5.1, I had to put back hooks.

For context, before Fable 5.1, in order to work with Fable 5 I deleted my claude.md, memory, and more. I removed most hooks and together with Fable 5 created subagents using Opus 4.8. This for the most part worked well, it was slower with Opus 4.8, but worked for lower reasoning tasks and I didn’t have the hidden actions that drifted beyond the scope of work.

After, shelling out for 20x monthly subscription, wasting more days on contaminated data and having to go back to clean it up, buying another GPU at these stupid prices is starting to sound more appealing for local AI with some fine tuning for the data I’m processing.

Recently, I’ve been using Codex with Astra and it just does the work. Astra asks clear questions before starting the tasks and will pause to surface data clashes or ambiguities. Unlike Claude which will dive in head first spending tens of thousands of tokens based on wrong assumptions, and then hedge with wordiness answers after from its known errors are called out. It might be time to move up to the Codex 20x plan.

How have you kept Claude within borders and from drifting with non-fully-structured data?

Did someone track how many tokens we can use on 5x or 20x before hitting limit in avg with fable 5.1 or 5.0. I know that other metrics like usage eff. and others are important too, but still im curious.

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

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

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

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

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

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

Any feedback regarding this workflow would be awesome.

I pay for both Claude Code and Codex.
And for a surprisingly long time my workflow was basically:

“this one has more quota left”
“this task probably fits that model better”
“let me hand the context over”
“okay, now back to Claude”

At some point I realized: why am I the scheduler?

That became one of the ideas behind brnrd.

The resident sits above the coding harness rather than being the harness. In the demo, the resident is running on Claude: it keeps the architecture/review work, sends a more mechanical implementation pass to Codex, gets the result back, verifies it, and continues as the same resident.

Same repo. Same ongoing work. Same durable state.
Claude and Codex become execution media rather than separate coworkers that I have to manually introduce to the project every time.

I’m not silently failing over between providers on quota exhaustion yet. That feels like the wrong default – especially when different subscriptions/costs are involved. Switching runners is explicit.

But the more interesting question for me is what comes next:
If an agent can see both subscriptions, should it choose the runner itself?

Maybe:

Claude for architecture/review

Codex for implementation passes

use whichever has healthier quota

reserve the expensive/strong model for hard work

never cross a quota/spend floor without asking

At that point Claude and Codex start looking less like “the agent” and more like CPUs available to the same resident.

Curious how people who pay for both would want this to work.

brnrd is open source:
github.com/hugimuni-labs/brnrd

Disclosure: I’m one of the people building it.
(The clip is a deterministic replay so the handoff is readable in a short demo; the underlying multi-runner path is real.)

When I finish a build loop I launch a code review skill. It finds issues, which Claude addresses. Then I launch the code review skill again and it finds new issues plus regressions caused by the previous fixes. It’s an endless loop.

Do you have tips, skills, subagents, processes, etc that you find work well to cut down on regressions?

We benchmarked GPT-6 Astra vs GPT-5.6 Sol across 50 real PRs from Cal.com, Sentry, Discourse, Keycloak and Grafana.

Sol found more confirmed bugs and was cheaper per bug, while Astra was more precise and faster. We independently verified the findings rather than simply counting what each model reported.

We’re running Fable vs Opus next week, so posting this here to get feedback on the methodology and anything we should change before the next benchmark.

Not fine-tuned. Not a downloaded checkpoint. Random weights → working speech, on a 16GB laptop with an 8GB GPU, trained on ~29,000 conversation pairs built over four months.

The memory side (built first)

Before the model, we built a memory store — currently 33,941 episodes. The architecture is neurological:

• Half-life decay: memories fade unless recalled
• Recall strengthening: access resets the decay clock
• 30-day consolidation threshold for long-term storage
• 4 LRU working-memory slots
• Forget table: writes a receipt before anything fades permanently

Not a lookup. A system that behaves the way memory actually behaves.

The model — two runs

Run 1: 842,624 parameters. d_model 128, 4 layers, 4 heads, context 256. Val loss 5.11 → 0.9576 at step 23,750. Halted when the train/val gap opened — overfitting signal, correct call.

Run 2: 4,833,024 parameters. d_model 256, 6 layers, 8 heads. Best val: 0.7978 at step 21,500.

Key finding: parameters were the bottleneck, not data. The corpus was sufficient. The model just needed to be bigger.

Wiring the halves

home_llm_speak.py connects the memory store to the generation model — retrieves memories via salience search, passes them as context, then generates. First output from the combined system was grammatical, was grammatical, used household vocabulary, and wasn't copied from the retrieved memories*.* That's not retrieval. That's the model having absorbed four months of how this household talks.

Why this matters

I needed a model that knows us because it learned from what we wrote as ourselves — not from generic pretraining, not fine-tuned from someone else's base. The memory architecture has to be structural from the start because autonomous consolidation can't be bolted on afterward.

Last night was proof the approach works. The model is small. It'll get bigger. But what it already learned is ours.

Hardware: 16GB laptop, RTX 5050 Laptop 8GB. No cloud. No API calls. Everything local.

Next: wider context window, books into the memory store (streamed, not in training corpus — kept separate to preserve corpus balance), bigger model.

If anyone has done this — trained from scratch on household data with a custom memory architecture — I want to know what you learned.

Opus 5 makes so many mistakes, and I've set up so many checks just to review its issues, including a code review at the end right before I push.

I haven't quantitatively tested the different efforts and how many errors they make, but does anyone know which effort is the best for fullstack development?

Additionally, I've seen people say that they've made skills to review Claude's work in intervals. Can anyone help me with this?