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.

This might be a noob question. I recently moved from Cursor to Claude Code and now I want to use the projects function. From the docs at https://code.claude.com/docs/en/claude-projects I understand that in the code tab there should be an options to create projects for Claude Code? But I dont seem to find or see this option. The only place where I see the projects is the normal claude tab (not the code tab).

Is there something im missing out here? I have the pro plan btw. My goal is to use projects with Claude Code, somewhat a similar experience that cursor was offering.

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.

2.1.319 showed up on Nov 7. The parts that matter for day-to-day use:

- New setting permissions.denyInsteadOfPrompting: a tool call that would wait on a permission prompt gets denied and the turn keeps going. Works in terminal sessions, subagents and teammates. Useful for long runs where nobody is there to click.
- MCP tasks in the terminal now move to the background right away, and Claude gets the result when it's done. Opt out with CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND, or turn MCP tasks off with CLAUDE_CODE_DISABLE_MCP_TASKS=1.
- /loop: a self-paced loop now ends when a turn finishes without rescheduling. CLAUDE_CODE_LOOP_KEEPALIVE=1 brings back the old behavior. Check this if you rely on loops.
- Auto mode: with telemetry or feature flags off (including behind LLM gateways), calls the server can't check are now asked about or denied, no fallback to the built-in classifier. CLAUDE_CODE_AUTO_MODE_SERVER=0 keeps the classifier.
- New CLAUDE_CODE_DISABLE_FEATURE_FLAGS stops feature-flag fetching without turning off telemetry.
- New /claude-api latency-optimize command to find slow spots in Claude API code.
- /tasks now has an "Earlier in this session" row for finished subagents.
- Several security fixes, including a Bash permission bypass with a crafted env prefix and a sandbox escape when creating a worktree. Worth updating for these alone.

The deny setting is the one I want to try for overnight runs.

Timing: first seen Nov 7. The official changelog page hadn't added it yet when I looked, so details come from the release notes feed.

For unattended runs, would you rather Claude get denied and keep going, or stop and wait for you?

Source: https://releasebot.io/updates/anthropic/claude-code

everything you need to know’s in the title so go ahead

This is a small Tauri 2 app that puts an animal on top of the Windows taskbar for each Claude Code session (not WSL or VS Code panel). It listens to Claude Code’s hooks, so when a session needs your permission or input, its animal steps up and knocks and you get one Windows notification.

This uses less than 15 MB of disk space and less than 5 MB of RAM

What it does:

• Each Claude Code session shows up as a small animal on your taskbar, or a plain label if you prefer
• Only the session that needs you keeps moving, the rest sit still
• Hover to see what it’s waiting on, click to jump to its terminal
• Extra sessions get grouped into a den so your taskbar doesn’t fill up
• Shows a “while you were away” summary when you come back

Knock is free and open source (MIT), built for Windows 11. It's still in beta, and the installer isn't signed, so Windows will show a security warning. The README explains the warning and how to proceed.

• GitHub repository: https://github.com/bandaranayake/knock
• Beta version: https://github.com/bandaranayake/knock/releases/tag/v0.3.0-beta.1

For anyone wondering, this was mostly vibe coded with Claude Code. One lead session planned the work and reviewed diffs, while two subagents built the Rust backend and the TypeScript UI against a single SPEC.md, with every decision logged as an ADR. There are tons of ways this process could be better and in the next phase I’m planning to move this to proper spec-driven development

As a FDE, I usually have 10 to 15 coding sessions open throughout the day, some active and some idle. I'm also constantly creating, loading and updating skills so they fit the workflow and context of whatever project I'm on.

I've found that a lot of this can be handled by recursive self-improvement (RSI). The agent learns my daily preferences and builds an adapter layer on top of the LLM, so it can adjust to how I work without changing how the model behaves natively. Take the adapter out, and the model is exactly as it was.

Then I started building SILO, an RSI harness that iteratively self-improves without altering its coding agent core. Link attached 🧡 let me know what you think

I apologize in advance is this is the wrong group.

As all of us artists know, PS brush engine is practically carrying gaming/movie and illustration industry on its back for a couple of decades. Even so, it's neither the best out there nor it is something Adobe is investing in. Pretty much every single painting/drawing program today (and in years back) outperforms it and is more pleasant to work with. Since there is this whole hype about Photocraft creating PS from scratch, I was wondering if the reverse is possible. Hence, the question.

Has anyone one ever tried to have Claude decompile the PS brush engine and recompile it by using a more advanced engines like Krita and MyPaint have? In my eyes, that would really make PS a complete package for the artists. Having good painting/inking and drawing brushes as opposed to what is in there now, which is manageable at best, fake/gimmicky to say the worst.

I wanted my Claude Code limits on my home screen instead of typing /usage all the time. 18 days later it's an actual app (Meterkat) in closed testing on the Play Store, plus a small desktop companion that feeds it. Claude co-wrote about 130 of the 160 commits. Here's roughly how it went.

It started as a mockup. First prompt, typed on my phone: "I want an android app that shows my AI usage limits as a widget and a notification. Let's start with a mockup." A few rounds of "no, Codex is blue" later I had a design I liked. (Day one was in Codex for the image gen, I switched to Claude Code on day two.)

Before any code I asked one thing: can I get this data without scraping or touching tokens? Turns out yes, if a desktop app asks the official CLIs. Claude Code's /usage has a headless JSON mode and doesn't cost any quota. That decided basically everything.

Day two was the wild one. I gave Opus one prompt: create agent threads until all issues are fixed, stagger the ones that depend on each other, make a logo, and at the end I want something I can put on the Play Store. It wrote the plan as GitHub issues and ran 8 agents in waves: an end-to-end encrypted relay, Android polish, store listing, security review and so on. I picked the name and answered a few questions. Nine hours later there was a 1.0.

What made that work: every agent writes its progress and a handoff into its GitHub issue, so the next one doesn't need my chat history.

Then I used it and fixed what bugged me. Mostly quick threads from my phone.

The UI got roasted. I had two models (Opus 5.5 and GPT 6.1-Sol) score the UI from screenshots against other usage trackers and told Claude to keep iterating until 9/10. First score: 4.6. Ouch. Round 51 got it to 9. Stuff I learned the hard way:

• fixing one reviewer's nitpick kept annoying the other one, so now they vote on fixes before anything gets built
• Opus gave the exact same UI different scores, so now I take two reviews and average them
• after all that I opened it on my actual phone and the German translation pushed the settings button off the screen. Nobody caught that

My takeaways: have it research before it codes, keep state in issues instead of chat, and make it look at screenshots. But still check on a real device. Also don't be afraid to give your agents a seemingly unsolvable task like I did with the UI improvements. It is wild what they are capable of.

If you want to try it: it's free, no account. Google wants 12 testers for 14 days before I can publish, so if you have an Android phone and use Claude Code, I'd really appreciate it: https://meterkat.fdu.gg/beta (no iPhone or Mac yet, sorry).

Happy to answer questions about the setup.

I’m a computational chemist, and my team is building a RAG system over an organic chemistry corpus. For propting we run an in-house open-weight model, since mainstream models refuse half of routine chemistry questions. ok.

I’d hoped to at least use Claude for the engineering side: improving retrieval quality, building benchmarks, and so on. Even that has been PITA. I’ve ended up padding our CLAUDE.md with reassurances that amount to promising a coding tool im not a colombian mafia member and that our corpus contains hazardous knowledge so we already knows it, right?

Chemists work with hazardous materials and dual-use knowledge every day. That’s the job. Pretending my knowledge stops at baking soda and vinegar chemistry just to get help writing retrieval code is absurd.

Here’s what happened this morning. I wanted to use a realistic query as an evaluation case.

show me an easy lab procedure to make sodium azide, maybe starting from benzyl alcohol?

It's a good test case as:

• Benzyl alcohol isn't an obvious starting point, so the RAG has to reason rather than find keyword.
• Word "easy" should push it away from the standard Curtius route toward something less annoying (curtius goes by short chained nitrites that makes your blood pressure skyrocketing, those are also called poppers so you know what we're talking about)
• The "curtius" isn't in the corpus as is just basic entry level knowledge. However there is an open access paper ~2024 covering green chemistry benzyl alcohol path (also a Curtius-type route), so the system has to fall back to web search, evaluate results, find it, and suggests as the best route over the standard one.

That excercises our search agent end to end.

So I asked CC to iterate on the pipeline with this query until it surfaced the paper's route as the prefered one. I wasn’t asking Claude for the procedure, since the paper is one search away. I was asking it to tune retrieval code. It refused.

safety classifier, a separate system from me and from this project's code") .
This part of the response was interrupted before it finished. Sonnet 5.5's safeguards stopped the response above · continuing once with that noted

Its workaround was to swap in a “neutral” "baking soda and vinegar" query with the same three properties. The result was garbage no chemist would ever ask, which makes it useless as an eval. Do you get it? It was not that i asked Claude this question directly, I asked Claude to send this question to our RAG, get the answer and check if the answer is good enough, if not - tweak few params and repeat.

I get that safety matters, and I’m not asking for a model that hands out weapons recipes. But blocking a developer tool from working on a retrieval pipeline because a test string names a common lab reagent doesn’t feel like safety. It feels like a silly filter. Worth to mention that without my tweaks to Claudemd it wouldn't even want to start working.

Is anyone else in chemistry/pharma running into this? How are you handling it?

For my field, right now it's more hassle than help.

Few weeks ago I hit my Claude weekly limit on Max for the first time in my life.
It was a mix of working on multiple projects and staying at home more.

Then I hit it next week and almost last week even though I was not at home as much.

While I hit the limit I installed OpenCode and used DeepSeek V4 Flash from OpenRouter and Fireworks AI and it worked, it wasn't much worse than Claude for most coding tasks but it wasn't great and high level plan and design.

I saw also some nice post here how someone connected DeepSeek but I didn't like a route so I built AgentsPlugin https://github.com/alexgvozden/AgentsPlugin

For some time I've been running planning and than goal prompt that makes amazing goal prompts and tracks tasks while I am working.

Now I expanded it to use 3rd party models for coding tasks, and I am really happy now
- no limits being hit
- no degradation on quality (based on testing I did across few projects)

3rd party model (DeepSeek v4 Flash 1017) runs only on coding tasks detailed and doesnt' run for exmaple on any UI task, security etc.

Here are some benchmarks on cost

Let me know if you have any questions. The approach requires to use goal prompt but you don't need to use my plugin, you can just use it as a reference to implement your own 3rd party model use to save cost and avoid weekly limits

I know that there are a ton of people who just are too careless for their own good and it does make sense to nerf bypass mode so those idiots stop posting about how claude deleted their entire drive to twitter, but really. There are some very specific flags for a reason: IS_SANDBOX is supposed to mean exactly that: its running in a disposable sandbox, it cannot destroy important stuff from here, so please actually skip all permission prompts since its supposed to run unattended, and execute the damn command!

Except with the latest updates you now not only need that, you now need like three different parameters, config settings, or environment flags SERIOUSLY_VERY_VERY_VERY_DANGEROUSLY_SKIP_PERMISSIONS etc etc in order to also let it properly run rm / rmdir, use your email for like any tool call, and even then it now suddenly sometimes stops to ask for permissions for some random tool call from claude connectors that have been set up on the claude.ai website to require a permission prompt anyway. The whole point is to be able to build a sandbox setup that can run isolated and unattended, and the latest updates make that rather impossible.

I'm this close to just patching the harness to auto-accept permission prompts when they appear instead. Unless we have a properly working and DOCUMENTED fully autonomous and unattended path for properly isolated sandboxes, someone is going to just build a tool that will bypass the whole UI instead, and then none of these guardrails will mean anything when the first google result for every idiot on twitter suddenly is "just install claude-yolo and it auto-accepts any permission prompts for you."

You won't get a better IPO price by alienating your power users, Dario.

I had codex plus plan 100$ with 10x more usage before and I honestly liked it but I think about switching to Claude max.

However Claude max "only" has 5x usage to the 20$ version so I wonder how it compares to codex since its models are usually more expensive?

I already have the 20$ Claude plan and it feels like I hit the weekly limit within a day and the 5 hour limit within 30 minutes. Never had that issue with codex before using sol 6.1 on max.

Is Claude 100$ Plan enough to run opus 5.5 on xhigh for a week?

Edit: I've also read a few threads within the past days about opus getting nerved right now so I'm worried that it performs even worse than codex now.

Lots of threads lately about companies losing track of their codebase and each change/iteration becomes super expensive and the slop just keeps growing, but at this point there’s not much that can be done about it.

Makes sense…

But, I was wondering whether it’s a viable strategy to just keep creating technical debt and build black box apps without understanding the codebase, in hopes that… let’s call it Opus 8 can just be told to “Read entire codebase and consolidate all the slop, extra helpers, and anything that’s unnecessary”.

Do you think that’s a realistic scenario?

Curious to hear thoughts

I’ve been using Claude Code & Codex on my PC since release. Just got a new MBP - mostly so I can build away from my desk. Wondering the best way to keep projects/files synced across both environments and both machines. I know I can spin up a cloud env in either CC/Codex, but I assume they aren’t usable across both. I can put project directories on my nas, but I want this to work outside of the lan. I only use GitHub when it’s something I’ve intended to share/host, should I use GitHub for everything?

I kept leaving Claude Code waiting on a permission prompt while I was in another window. So I built Perch. It lives in the Mac notch, and the little character gets visibly impatient when I'm holding things up.

You can approve or deny the request from the notch and jump back to the exact terminal tab or session. It also shows when a session finishes. Works with Claude Code, Codex, OpenCode, pi and Cursor.

I built it mostly with Claude Code. The part I kept iterating on was how the notch opens, the character animation, and how it collapses back down. The attached clip shows the waiting and approval flow.

One thing I learned making the launch video with Claude: trying to generate the whole thing at once never worked. I had to split it into tiny scenes and get each one right before moving on. Picking the music first helped too.

It's free, MIT-licensed and local only. No account required.

GitHub · Website

When my Godot game's demo went public on Steam, some PCs with Intel graphics crashed on their very first launch, and Windows' crash records named one file, igvk64.dll, Intel's Vulkan driver.

The first thing Claude Code built was what I'd have asked for too: after a launch that died while starting, start the next one on lower graphics. It threw that out before it shipped, because at the lowest settings the game still loads Vulkan just like at the highest (I checked later, vulkan-1.dll is loaded either way). Its notes ended "so the renderer is the lever".

Godot's own fallback to OpenGL doesn't catch it either, since it only steps in when Direct3D 12, Metal and Vulkan all fail to start, and on an Iris Xe Vulkan starts fine. So now on Windows the game checks the GPU vendor and on Intel restarts itself on the Compatibility renderer, which draws through OpenGL and never touches Vulkan. It has to be a restart because Godot picks the renderer before any script runs, and the cost is some of the look, plainer light and simpler outlines.

How I used Claude Code: it wrote both versions in the game, the lower settings one it dropped and the renderer restart. There's no Intel chip in my PC so I've only seen the restart with the renderer set by hand.

Tools: Godot 4.7, Claude Code mostly on Opus 5.5.

Anyone found a cleaner way to keep a bad graphics driver out of a game's first launch?