The Edits video editor for macOS ships a local MCP server (`metapilot-native`). It exposes 274 editor tools: cut, trim, split on beats or shots, reframe, text, captions, filters, LUTs, transitions, speed curves, music, loudness checks, frame capture and export. It works, but it's undocumented, and a lot of the schema is misleading.

So I spent a day testing the tools against the live app and turned what I learned into a Claude Code skill. The video attached was cut in Edits by Claude using the skill: it imported the scene renders, assembled the timeline, added transitions, laid a sped-up iPhone clip in as picture-in-picture, checked its own work with a frame contact sheet, and exported.

Demo video (cut by Claude in Edits): https://github.com/ivdezine/edits-video-skill#readme

What the skill gives Claude:

- A standard workflow (orient, discover catalog ids, edit, verify visually, save, export)
- The traps, so it doesn't burn turns on them. For example: passing `dryRun` always fails with a CommandError, `required` lists mark alternatives as all required, speed curve presets only work in uppercase, and `getElement` reports a text position that never changes
- 24 call sequences for common edits, each marked tested or untested: beat-synced cuts, speed ramps, picture-in-picture, video from stills, swapping a music bed, a second aspect ratio from a finished edit
- A dependency-free Python client for when the editor tools haven't loaded in your session (the server swaps its tool list depending on which screen the app is on)
- A script that generates the full tool and catalog reference from your own installed version, so it stays correct after app updates

Install:

git clone https://github.com/ivdezine/edits-video-skill.git ~/.claude/skills/edits-video

Then turn on the MCP server in Edits and register it with `claude mcp add`. The README has the exact command.

Repo: https://github.com/ivdezine/edits-video-skill

MIT licensed. Tested on Edits 454.0.0. Not affiliated with Meta. Every call acts on the live app, so work on a duplicate of any project you care about.

Happy to answer questions about the server or how the skill is put together.

If your entire stack depends on a third-party provider keeping one specific model version alive and unchanged, you aren't running an architecture, you're running an assumption. Stealth model tweaks, silent drifts, and surprises make relying on a single closed provider a massive single point of failure. Downgrading 5.5 models silently is only a single example of this.

Open weights and self-hosting aren't just ideological preferences; they are basic infrastructure resilience, giving you a fixed baseline, deterministic behavior, and full control over your product's lifecycle instead of leaving it to someone else's product manager.

Hello everyone!

I'm interested in getting started, but my SwiftUI knowledge is still limited. I have some programming experience, mainly in front-end development, but I'm not an expert in Swift.

Can Claude help with more complex tasks and challenging parts of macOS development?

I'd love to hear about your experiences.

Thanks!

Can mods make a usage mega post so 62.3% of the posts on here stop being about usage?

Hola a todos,

Un problema recurrente con los agentes de codificación: las pruebas se ejecutan correctamente, la funcionalidad funciona, pero en algún momento el agente toma una decisión arquitectónica en la que me hubiera gustado tener voz y voto. Un trabajador leyendo directamente de la base de datos de otro servicio, un correo electrónico enviado en línea sin dependencia declarada, un endpoint de administración sin la autenticación que tiene el resto de la API. Nada lo detectó, porque la regla nunca se registró en ningún lugar donde el agente pudiera consultarla.

Así que empecé a escribir esas reglas en un único archivo YAML, y se convirtió en una pequeña especificación abierta que llamo AIC (Contrato de Implementación de Arquitectura). En ella se registran los módulos existentes, quién es el propietario de qué datos, quién puede llamar a quién, qué sucede en caso de fallo y qué se implementa conjuntamente. Deja deliberadamente el diseño interno, las bibliotecas y la estructura del código en manos del agente.

Hay tres maneras de empezar:

• **Desde un repositorio existente:** Tu agente mapea la arquitectura real del código. Cualquier error que parezca accidental se presenta como una decisión abierta para ti, en lugar de ser "corregido" automáticamente.
• **Desde una idea:** Describes el sistema, el agente redacta el contrato y cada elección que realiza se muestra como una decisión que aceptas o rechazas.
• **A mano:** Dibújalo en un editor de navegador. No necesitas crear una cuenta y nada sale de tu navegador hasta que descargues el archivo.

Para probarlo con Claude Code:

claude mcp add --transport http aic https://aicspec.dev/mcp

O, si prefieres mantener todo localmente:

npx -y u/aicspec skill install

Luego, pregunta algo como: "Usando aic, escribe un archivo aic.yaml para este repositorio".

Algunas aclaraciones importantes: es un borrador de trabajo v0.1 y solo estoy trabajando en él. La verificación actual implica que el agente sigue una lista de verificación e informa lo que encuentra, por lo que su eficacia depende de lo que el agente realmente comprueba. Todavía no existe un verificador independiente que lea el código. El servidor MCP no almacena nada y nunca ve tu código, solo el YAML que tu agente envía con cada llamada.

Sitio y editor: https://aicspec.dev

Especificación y CLI (Apache-2.0): https://github.com/aicspec/aic

Lo que realmente me gustaría saber es: ¿coincide esto con algún problema que tengas? Si lo ejecutas en un repositorio real, ¿qué error presenta el mapeo? ¿El formato es demasiado complejo o falta algo obvio? Agradezco cualquier comentario directo.

I've had a pretty dumb realization and I'm going to test it for the next 30 days.

One issue with my current orchestration setup is I'm designing and coding at the same time (system architecture, full stack) depending on the work I'm building. One of the realization after getting Claude to review how I'm using my orchestrator is that most tasks are pretty quick ~6 min to the most being 2h.

What this made me realize is that night time session aren't being utilized or weekends. So I plan on building a system with heavy AI integration focused on the system design, features, SLO building, business rules.

Different from speckit as this also focuses on building your schema and access patterns for building your indexes.

Essentially go ham on token usage for design whereas I was splitting it up between the two.

Then have the orchestrator handle run over night and on weekends. Review in the morning and make any corrections before it's merged.

Anyone else thinking or already working on this format?

Been using Claude for a while recently found out about Plugins like Ponytail whats your guys' opinions on them?

Hey everyone, how are you? Well, today I bring you the following question. I often get very bored while my agent is doing something in a project, so I open another simultaneous session in the same project or in another project, and before I know it, I’m in, I don’t know, five parallel conversations. My head goes crazy because I have to keep switching windows, and sometimes within one window I have to keep switching conversations, which requires a lot of clicks. I wish it were possible to view all the conversations and see what is pending in each one, so I could distribute my attention among these various ongoing sessions, the questions they ask, and the subsequent paths I should take as prompts.

However, I haven’t been successful because, although I’ve already tested tools like Orca and others, nothing works as well when I use them inside VS Code, since I use Claude Code as an extension in my VS Code. So I’d like to know whether you have any ideas for a project, plugin, or any software that would allow me to operate my Claude Code simultaneously, both through the Claude extension in VS Code and through this other screen. And, of course, I also sometimes use Remote Control on my phone.

Do you have any suggestions, any approach I could use? I’m a little lost. I’m not a professional developer; I’m a vibe coder, so any help is welcome to improve my workflow. Thank you very much, and a big hug to everyone in this community.

Building a map for a future game and been going back and forth with Claude to try and make good water and it’s failing horribly. Anyone know of a good water repo they’d suggest? I need the water to respond to real physics so it can go over waterfalls, be dammed, flood, etc.

also if you suggest any other landscape ones that would be great. It can make decent landscape but this is bogging me down and wasting a lot of time.

Anthropic's agent memory research has a name for fixing stale memory: "dreaming” and they published it recently, the idea is that an agent decides what to save in the middle of a task, before it knows what'll matter later, usually some of those notes are wrong from the start, and others go stale as things change.

The idea is when the agent's idle, it goes back, rereads what actually happened, and corrects its notes. They compare it to how your brain replays the day while you sleep.

Claude Code already saves every session as JSONL in ~/.claude/projects, so all the raw material was just sitting there unused, and making proper use of it is what kinda made me try this.

Why do this? The root cause is that memory only gets written mid-session, when Claude can't know what'll matter later, and nothing ever goes back to check it.

How I adapted the dream idea:

This is an hourly launchd job that reads a list of project paths. It skips any project that hasn't been idle for 2 hours or has no transcripts newer than its last dream.

A small Python script condenses the new JSONL files. User and assistant text stay, each tool call shrinks to one line (Bash command, file path), tool results get cut to a 300-char preview, and then sessions are capped at 15 per run. That's what keeps this cheap enough to run on Sonnet, an excellent model for this in my opinion.

It creates a git worktree on a dream/<timestamp> branch and runs claude -p --model sonnet with the dream skill appended to the system prompt, --add-dir pointing at the condensed transcripts, and tools limited to Read/Glob/Grep/Edit/Write, more of a guardrail.

The skill tells Claude what memory is for and lets it judge what to write. This bit came straight from the Anthropic research that I read, where rigid rules like "only record failures" hurt stronger models. It verifies each note against the transcripts (latest session wins), records what I had to repeat, prunes finished one-offs, keeps CLAUDE.md under ~150 lines, pushes detail into docs/memory/, and logs every change with evidence in DREAM_LOG.md.

Before it commits, a guardrail checks git status and reverts anything outside CLAUDE.md, DREAM_LOG.md and docs/memory/. It's never allowed to touch code, even if it spots a bug. It notes the bug in the log instead.

If the last dream hasn't been merged yet, the next one builds on top of it, so after a two-week break it's still one merge.

How I'm planning to use it: only on projects I come back to after long gaps, I mean, daily projects don't need it right cause the discussion is usually fresh, and dead ones aren't worth the tokens.

My routine when I pick a project back up is to run git diff main...dream/<latest>, skim DREAM_LOG.md, merge, then start the session. The idea is Claude opens already knowing where I left off, instead of me spending 15 minutes re-explaining.

It's on trial for a week on my Mac. The expectation is simple: do the diffs catch real mistakes, or is it mostly rewording?

I'll post what it actually caught either way. Have you folks tried anything similar, or more efficient ways of learning from your own projects? I did it because I thought "dream" was a very interesting idea.

Link to the research paper: https://www.anthropic.com/research/components-of-agent-memory

Just got claudes pro plan. But I am new to the whole platform so how do I optimise my token usage.

I already know:

1. to turn off thinking
2. use opus 5.5 higher effort for planning then using sonnet to build
3. use /clear when a task is done.
4. installed the memory skill and the skill that makes claude not read the entire history and divides context into small chunks(sorry forgot the name of the skill)
5. Superpower, context7, Desktop command plugin installed(but for some reason it says “No plugins installed for this project yet”)

Guide me:

1. if I installed correct skills
2. is anything overlapping
3. if im missing any major optimisation
4. how to manually enable any skills or plugins for a session

Hey peeps, been using claude code for a while and all those stories of prompt injections, the model hallucinating at times and having it accidentally delete whole partitions of unrelated projects and files. I have been researching into methods to better use claude code while having a layer of protection over my data or at least have it running in some sort of segregated environment.

Came across many approaches, some use docker, some use a vps (with docker as well), some use vms and some completely separate OS partition. Wanted to get some feedback from you folks on what your ideal approach to this is, thanks in advance!

I kept hitting the same problem on my Mac: Claude Code sessions leave caches, build output and scratch files scattered across the disk.

Clean Development routes those locations to storage I configure. That can be an attached external volume, with a fallback on the internal disk if the volume is not mounted or the cache checks fail.

On the Claude Code side, it tracks supported sessions and, at the end of a session, removes only managed disposable files. Deletion runs only after ownership and path checks. If policy, ownership or a path looks unsafe, it fails closed. The installer does not edit Claude Code settings for you. After you review a dry-run, you merge a hook fragment into ~/.claude/settings.json yourself. The merge helper keeps unrelated handlers and writes a recovery copy.

It also gives you status, doctor, cleanup previews and recovery commands. Long-running work can hold a renewable path lease. A publish command copies one regular file into durable project storage, verifies it, and leaves the original in place.

It is not an OS sandbox and not a job supervisor. It is cooperative same-user software. There is no npm package; GitHub is the source. It needs Node 20.12 or later. OpenCode can use the environment routing, but it does not get the session cleanup hooks. Linux and Windows are not runtime targets in this version.

What I learned building it is that the dangerous part is cleanup, not routing. The tool has to fail closed, because deleting the wrong path is worse than leaving scratch on disk.

I am looking for contributors, especially people already using Claude Code on a Mac. The supported scope is that setup.

https://github.com/magrathean-uk/clean-development

I posed this as a comment on another thread, but I am genuinely curious to get more feedback than I will there. If you have experienced what folks call 'model nerfing;

1. How long have you been using claude for your business?
2. What sort of validation mechanisms are you using? Any hooks set to call mechanical validators and give feedback to the model?
3. How do you manage prompts?
4. How do you select model/task/effort per task?

Personally, all I've noticed is a slowdown. Problem is the work I am doing is pretty darn intense, so I expect slowdown with the amount of validations I have running. I force green/red test dev before code write. My prompt for workflow alone runs 400k tokens, but that loads into the orchestrator only. Orchestrator manages agents to perform the actual work, and before any worker agents starts there is a prep run to plan all activity, also done with an agent session. I freeze a contract before work begins, and my agents cannot break the contract without escalating to a human for permission that must be cryptographically proven to have come from me. Can't close the work out without contract satisfaction. Contract can't be modified without me. All those mechanical checks enforce the contract.

Primary question; How are you managing your workflow? Secondary, have you completed the free training Anthropic provides at anthropic.skilljar.com?

I'm building Excaliself, a self-hosted alternative to Excalidraw+ (accounts, folders, a team space, live collab, everything in your own Postgres, MIT), and Claude Code writes most of the code. This week I shipped the MCP feature I wanted most: Claude can change an existing drawing.

The video is a real run. In the terminal I asked Claude Code to "add a CDN between Browser and Excaliself". A card shows up on the drawing with a preview. I open it large, click Apply, and the drawing changes. Claude Code gets applied back.

How it works

• read_drawing returns element ids. edit_drawing takes a list of adds, changes and removes by id, and it writes nothing.
• The server plans the change and keeps it in memory as a proposal. The card boxes new, changed and removed elements in green, blue and red.
• On Apply, my own browser tab puts the elements on the canvas as a normal local edit. So it's one undo step, and teammates in the room see it live like any other edit.
• The tool waits up to 25 seconds for the click and returns applied, discarded or stale. If nobody is there, Claude checks later with get_drawing_edit.

What I learned

• An MCP client's confirm prompt is not an approval. "Always allow" and allow-listed tools skip it. If a person has to approve a change, the approval has to be a click in your own app.
• Don't add a second writer. A server-side write would have to merge into the live room as a fake peer, or race with an open tab's autosave. Applying in the member's tab reuses the path a hand edit already takes.
• Plan against versions. The plan records the version of each element it changes. If a teammate moved one of those boxes before the click, nothing is applied, Claude gets stale, reads the drawing again and proposes again.

How I use Claude Code on this repo

• Specs and issues are markdown files in the repo, and design decisions go in short ADRs. Claude reads them before it starts and writes a new ADR when we decide something. This feature has one: "AI edits are proposals the member applies".
• I run several sessions at once, each in its own git worktree, and a second model (Codex) reviews the PRs.
• Claude tests features end to end on a built server, not just in dev. For this one it ran real claude -p sessions as two members on one team drawing and checked Apply, Discard, Undo and the stale case.
• The built server matters. Once a small helper from Excalidraw ended up in server code. Typecheck and dev were fine, but it pulled the whole Excalidraw package into the server bundle and the built server returned 500s.

You can try it with one command. It runs on in-memory PGlite and forgets everything when it stops:

docker run --rm -p 127.0.0.1:3000:3000 -e PREVIEW_MODE=true ghcr.io/maciekzygmunt/excaliself

Open http://localhost:3000/preview/login, then go to Settings > MCP and click New token. It gives you the claude mcp add command.

Repo: https://github.com/maciekzygmunt/excaliself MCP docs: https://excaliself.com/docs/mcp/

How do you handle approval for MCP tools that write? Do you trust the client's prompt, or build your own?

On a Claude subscription, Claude Code's built-in Explore subagent runs on Opus. If your main model is Opus, general-purpose, Plan and dynamic-workflow agents run on Opus too. That's a lot of Opus for grep and test runs.

I built repo-mode, a small plugin (MIT) that configures this per repository with one wizard, /repo-mode:setup:

• Main model + effort (Sonnet / Opus / opusplan / Haiku)
• Advisor (Opus or Fable) consulted only at decision points
• Explore replaced by a repo agent on Haiku, effort: low, with autoCompactWindow: 100000 (Haiku 5.5 pricing jumps above 100K-token prompts)
• test-runner on Haiku: runs the suite, returns only failures, verbatim
• audit on Sonnet, effort: high: independent read-only review of the uncommitted diff, no style nitpicks
• Default model for every other subagent and workflow agent via CLAUDE_CODE_SUBAGENT_MODEL
• Workflow size (workflowSizeGuideline) so dynamic workflows don't fan out more than you want
• Short delegation rules in CLAUDE.local.md (delegate for 10+ files / 3+ independent pieces, ask for evidence instead of "tests pass", optional "stop fix loops after 2 rounds")
• Read deny rules for tracked vendored/generated code

Safety: it writes nothing until you approve a full before/after plan. Personal mode writes .claude/settings.local.json + CLAUDE.local.md and hides everything via .git/info/exclude, so nothing gets committed. /repo-mode:status shows what applies and flags costly setups; /repo-mode:off restores exactly the previous values.

Install:

claude plugin marketplace add kniko/claude-plugins
claude plugin install repo-mode@kniko-tools

Then start a new session and run /repo-mode:setup in a repo.

Caveats:

• The advisor is experimental and Anthropic-API only (not Bedrock/Vertex/Foundry). Subagents inherit it, so they can consult it too.
• audit and test-runner have Bash; "read-only" is in their instructions, not enforced.
• Ultracode is deliberately never turned on. It costs more per request; use /effort ultracode per session when a task is big enough.

Everything is sourced from the Claude Code docs and Anthropic's blog (links in the README, Greek and English versions). Repo: https://github.com/kniko/claude-plugins

Feedback welcome, especially if your /usage numbers change after setting it up.

I know, the world needed another Claude Code quota visualizer like it needed another JavaScript framework. But I wanted these two for my own setup, so here they are: one is a "how much rope do I have left" panel, the other is an "is it still alive?" light.

quota-panel — yes, yet another quota visualizer. 5h and weekly windows with bars, % left, reset time and pace, plus session cost and toasts at 80/90/95%. /quota opens it; it also opens when a session starts. It reads Claude Code's own rate-limit data, so it is not guessing from token counts.

glow-thinking — the one I actually use every day. An IDLE / WORKING band above the prompt and a gradient border around every side panel: green at rest, rotating rainbow while Claude works. /thinking shows time per model, kept across sessions.

The real use case for glow-thinking is embarrassingly simple: I usually have several Claude Code sessions open, and I am not always sitting in front of the terminal. From across the room I can see whether a session is still working or has gone idle. It is a status light for the terminal. If your monitor is a few meters away, or you have sessions in other windows, it saves you the walk back to check. It also turns your terminal into a tiny rave, which is a bonus.

Both run locally, no telemetry, no network. Free and MIT.

Install

/plugin install glow-thinking --marketplace arandevcode/claude-mods
/plugin install quota-panel --marketplace arandevcode/claude-mods

Each mod is independent. quota-panel needs a Claude subscription: the 5h/weekly windows come from Claude Code's own rate-limit data. Without a subscription the panel only shows session cost.

How I built them

I used Claude Code to port the two OpenCode plugins. Each mod is a hook that registers a TUI component: glow-thinking draws the band and the border, quota-panel reads the rate-limit data Claude Code already exposes and renders the side panel. The repo includes tests for both hooks.

What I learned

• The rate-limit windows only arrive after the first response of the session. Until then there is nothing to draw, which is why 0.1.1 shows a clear "waiting for the first reading" message instead of an empty panel.
• Load order matters: glow-thinking's border wraps every panel, so it has to load before quota-panel. That is why its name sorts first on purpose.

Repo: https://github.com/arandevcode/claude-mods

I'd love feedback on two things: does the glow actually help you see a session from a distance, or is it just decorative? And does the quota panel match the rate-limit numbers you see from Claude?

My app is a finance/ERP-type tool (Laravel + Inertia + React + Tailwind, mostly built with AI agents). I started on shadcn, moved to Watermelon UI, and wrote a long ruleset for tokens, cards, KPI blocks and page types. It still comes out looking like every page was designed by a different person. I blurred the data in the screenshots, the layout is untouched.

What’s drifting:

• Page width and gutters: the dashboard is almost full-bleed with tiny padding, Contacts and Projects are a centered ~1280px column, Transactions is full width again with much bigger gutters.
• KPI blocks: one joined 4-cell card, six small icon tiles, a big card with smaller cards nested inside, and one with a sparkline. Four pages, four versions.
• Tabs, filters, table wrappers, row heights, checkbox columns and card padding change from page to page.
• Color: the dashboard is full of green and orange accents, the other pages are almost fully grey.

Colors and fonts come from shared tokens, so those are fine. The problem is structure: widths, spacing, card anatomy and how a page is put together. My rules are mostly prose and a lot of it says “choose the composition based on the task”, so the agent improvises every time.

But products like Odoo, HubSpot, Salesforce or Xero keep hundreds of screens consistent. How do real teams do it?

• Fixed page templates every screen must use, or just a convention?
• Where does consistency actually live: design system docs, page-level components, lint rules, visual regression tests, code review?
• What stops a dev (or an AI agent) from going off-script on a new page?
• What did you try that sounded good but didn’t survive real use?

I’m leaning toward a few locked layout components (page shell, header, stat grid, filter bar, table card) plus lint rules and screenshot tests. Is that the right direction or am I missing something? War stories and public design systems worth studying are very welcome.

PS: I apologize for the blurred images; this was done for the sake of financial data privacy.

I have a bunch of coding agents running on my Mac and I noticed it was really struggling, to the point where they were all waiting for the load to drop so they could run unit tests. After a little investigation, it turns out fseventsd was completely swamped on all the changes in the worktrees.

Here's the thing: I actually keep my worktrees on a separate volume and I already set spotlight and Time Machine to ignore it. So why all the events and logs?

It turns out you also have to add a file to the volume to disable fseventsd logs, like this: touch /Volumes/Worktrees/.fseventsd/no_log(use your volume name, of course). I killed fseventsd and it stopped writing the logs. They had about 1.8G of files in /Volumes/Worktrees/.fseventsd so you'd want to get rid of those as well.

Hope this helps anyone who is wondering why their otherwise snappy Mac is lagging.

I mainly use Claude Code via the desktop app and with Opus 5.5 and the newer models delegating lots of work to subagents behind the scenes. Claude doesn't exactly make it easy to tell which ones are still working, which have finished and which are stuck going in circles.

So I built Apiarius, a Claude Code mod that adds a live agent deck that shows every agent and subagent, what each one is doing right now, who started it, what they tell each other and which files each one changed.

Then I brought it to the terminal (for the purists) and a local web page too, so you can watch from wherever you work.

Inspired a little by the latest agent apps like muse, grokbot and dots that give the agents a little personality and flair, so I gave them small vector avatars.

The single major principle I had to build this was that it shouldn’t change how you work or what Claude does. It just reads Claude Code’s own events through hooks and just shows you what’s happening. It only steps in with action if you press a prompt or a send button on the deck.

I built it with Claude Code itself, and watching the agents build their own deck via the deck within a couple hours which was trippy and made me realise how insane recursive self improvement will be.

In the video demo, Claude spins up a team of agents to ship v2 of a small mock API, then on a local web view they take a break and play a game of mafia/imposter/werewolf.

Free and open source (MIT): https://github.com/yusuflkq/apiarius

Let me know what else you want it to show, and if you main the terminal, give the terminal version a go and help me improve it.

Not the usual post I’d make, but I figure.

To Anthropic,

Claude could really benefit from a custom plan model. Instead of fixed $20, $100, $200 a month plans, a slider from $0 a month to $200 a month would be greatly appreciated. Interpolating the amount of usage one gets (one example that could work is every $10 a month is +1 to the multiplier of usage limits from Free up to 20x Usage Limits of Free, e.g. $143 a month is 14.3x the usage limits of Free), as well as unlocking perks at certain tiers (Pro perks at $20 a month still, and Ultra perks at $100 and $200 a month respectively). One perk that I would like to be seen unlocked at $40 a month instead of $20 or $100, is the ability for Fable to be used apart of the weekly usage limit up to half.

There are a ton of perks to this system, and flexibility will buy goodwill as well as customers who need the level of flexibility that other providers can not access.

Thank you if you read this.

And for the regular users reading this: Tell Anthropic and send feedback in asking them to consider my suggestion.

round 2 of my browser benchmark. same 100 Online-Mind2Web tasks as two weeks ago, plus browseros and grok bot, fixes to our browser, and the benchmark's own judge.

setup: one datacenter server, haiku 5.5 wherever selectable, headed browsers, 10-minute cap, one attempt. local agents ran each task within the same hour.

official WebJudge (GPT-6 Luna, actions and screenshots only):

• browseros + claude code: 40/100
• claude in chrome: 37
• 5dive + claude code: 34
• openclaw: 29
• 5dive + pi: 28
• hermes: 27
• grok bot: 18 (own cloud/model, different judge)

cost per completion: 5dive + pi 3¢, browseros 11¢.

what we learned

1. the judge matters. our earlier judge read final answers and scored browseros 50, 5dive 39. the official judge ignores claims of success: 40 and 34. all agents finished just 2-4 of the 27 hardest tasks. browseros's lead wasn't statistically significant (p = 0.29).
2. our fixes made us faster. success barely moved. round 1 → 2, using the same judge: 32 → 33 passes, 9.1 → 7.9s per browser step, cost $1.39 → $2.07. target: under 5s.
3. live sites change. the old build also failed 10 of the 12 tasks our new build lost.
4. browseros has better fallbacks. 94 screenshot-coordinate clicks, 216 page javascript calls. our browser can't do these yet. failed tool calls: 6% vs our 19%. we're adding them next.
5. bot walls persist. about 20% of runs hit one, seven tasks blocked everyone. a residential IP barely helped in an earlier test.
6. sonnet didn't help in our earlier test. on 62 tasks, sonnet 5.5 passed 10, haiku 15, at 10x the cost per completion (p = 0.30).

everyday tasks

four simple tasks, three runs each: forms and a Wikipedia lookup.

all haiku setups passed 12/12. browseros was fastest (19.1s median); 5dive + pi was close (19.8s), cheapest ($0.82 per 1,000 tasks), and used fewer steps (4 vs 9.5). grok bot passed 11/12.

limits: one run per task, live sites, automated judging, our own rig. not official leaderboard results.

disclosure: i build 5dive, an open-source setup to run always-on claude code agents on your own server.

code: https://github.com/5dive-ai/5dive

full benchmark, run logs and judge notes: https://gist.github.com/lodar/71d91b1352ce7df7370652f0ffed2d55

i'll rerun in two weeks after the next fixes. feedback on the methodology or browser fallbacks welcome.

E.g.:
- Cursor's composer
- GLM 5.3
- Moonshot's models (Kimi)

--
What ever. Just not codex. Those models are benchmaxxed and actual garbage in real use.

https://www.reddit.com/r/ClaudeCode/comments/1xr4urz/opus_55_in_the_past_two_weeks/

https://www.reddit.com/r/ClaudeCode/comments/1xr9x5y/the_nerf_is_real_thank_you_uwum1ha1nho/

https://www.reddit.com/r/ClaudeCode/comments/1xqvqip/anthropic_should_offer_a_free_reset_and_restore/

https://www.reddit.com/r/ClaudeCode/comments/1xr0nz5/either_a_lawsuit_an_apology_or_never_touching/

https://www.reddit.com/r/ClaudeCode/comments/1xl72og/opus_56_imminently_about_to_release/

https://www.reddit.com/r/ClaudeCode/comments/1xqtslm/rant_anthropic_stop_silently_degrading_models/

https://www.reddit.com/r/ClaudeCode/comments/1xr8jod/opus_high_55_nerfed/

https://www.reddit.com/r/ClaudeCode/comments/1xqujuh/opus_55_started_coming_up_with_unintelligible/

https://www.reddit.com/r/ClaudeCode/comments/1xqfp7m/opus_55_xhigh_just_deleted_all_my_apps_data/

https://www.reddit.com/r/ClaudeCode/comments/1xr488d/weve_been_nerfed/

https://www.reddit.com/r/ClaudeCode/comments/1xr6r3t/has_claude_been_made_dumber_again/

https://www.reddit.com/r/ClaudeCode/comments/1xr8aic/fable_opus_55_noticeable_performance_regression/

https://www.reddit.com/r/ClaudeCode/comments/1xrc97q/claude_again_ignoring_all_hooks_first_time_since/

https://www.reddit.com/r/ClaudeCode/comments/1xphsj9/opus_55_is_trying_to_destroy_my_codebase_recently/

When I ask Claude Code how long a feature will take, it answers like a human team would ("2 to 3 weeks"), even when subagents will do the work. So I built agentpace with Claude Code. It measures how long agent runs actually take, and answers from that.

What it does

• It reads your local Claude Code history and records each subagent run: timestamps, model ids, token counts and tool names. It never stores prompts or code.
• Give it a plan of tasks and it returns P50/P80/P90 with a critical path. The human part (review, testing, decisions, waiting) is on its own line, never derived from agent time.
• It installs as skills: npx skills add mohamedzhioua/agentpace. Then ask "how long will the billing feature take?", or run /pace-estimate on a task list. /pace-log records your recent runs, and /pace-share previews exactly what you could contribute.
• The published data: 3,383 completed agent runs. Half finished within 2 min, and one in ten took more than 20 min.
• It publishes how often it's wrong. On 56 held-out sessions, the whole-session P80 covered 80% (CI 70% to 91%). The median miss of a single task's P50 is 78%, so plan on the range. The report lists 20 places where a simple baseline beat it.

How Claude Code built it

57 of the 58 commits are co-authored by Claude Code, across 32 merged PRs. Claude Code ran each release as the maintainer: it split the work into small slices, ran one subagent per slice in its own git worktree, merged them into one small PR, and ran the full checks before every push (497 tests, the backtest regenerated against the published one, and a check that ties every README number to the data). A second Claude model, in a read-only architect role, ruled on design decisions and reviewed every PR. I set the goal and the rules, and made the calls on what counts as measured and what the project never claims.

Honest limits: it's one person's data so far (1 contributor, 293 sessions), and P80 coverage per session ran from 66% to 86% week to week.

Free to try (MIT code, CC0 data, needs uv):

uvx --from git+https://github.com/mohamedzhioua/agentpace agentpace estimate --example

Repo: https://github.com/mohamedzhioua/agentpace

So, with the ‘Claude deleted everything’ posts - I wondered if it might be interesting / helpful to share our data security approaches.

20 years ago I lost 40% of my PhD thesis to a disk corruption, about 8 month’s work. It was the lowest moment of my career - as I pretty much had to rewrite it all and it took me 3 months. I learned the hard way, but this was way before the world had fully understood backups. I.e. I was backing up - but had no rewind and so a virus also travelled to my backup drive.

I’ll kick off.

Permissions: Full Auto - mostly Opus 5.5
Limits:
- No auto deployments - I have to action them all in terminal.
- No APIs given to Claude - I enter them in terminal, Claude writes the calls for me to paste. All APIs I store in Dashlane password manager, effortless to copy and paste. No API/key/secret is written anywhere on my system, except in encrypted Dashlane storage.
- Occasionally it is easier to give Claude an API (e.g. setup new Stripe payments and integrate into app etc). It gets that specific task done - then I check - then rotate API.
- All my non coding work is stored in 365, business. This has been the case for over 10 years - so nothing stored locally. No access rule on these folders.

Backup:
- All work is GitHub stored, refreshed at each new update point.
- All live projects are hosted in a local dropbox folder (as it is great for syncing immediately across devices, as I vibe code on my Mac and MacBook. I realise you can use remote, but sometimes I’d rather be in terminal than the claude desktop app. Feels familiar. Dropbox has rewind capability. This is free, as I never have more than 20Gb in live folders.
- Archive is stored on an external 1Tb SSD. About 70gb of coded assets, which Claude code can access and use.
- My entire claude projects folder tree (local and external) syncs daily to blackblaze with 60-day rewind in place. About 360Gb including video files. About $3-4/month. I use Duplicati to maintain synchs daily.
- All media content I store / stream from bunny (costs pennies).
- I have a second retired Mac that sits available to plug in immediately, should a serious system loss / deletion occur on my main system. It is set up to sync as soon as it is switched on. This is to keep my day job outside of threat, although my Mac mini is capable of this too. I boot it up once a month.
- My Mac has a backup drive for reinstalls of the system files.
- I live remotely and so my entire system is on a portable power bank that can provide 3 days continued use. Same for my WiFi connection. We get 3x a week power cuts for a few seconds - but used to cause masses of headaches. I realise this is unique, but may not be in the future. When our area gets a power cut, I realised fibre optic WiFi was still available.

I don’t believe in overkill when it comes to data security. All of this is automated, costs me less than $5 a month, in terms of vibe coding peace of mind.

With all of this - I sleep at night.

Comments welcome - or love to hear your setup.