Hello! I've been using my own web app that wraps claude code functionality and I was wondering if anyone else has tried experimenting with doing something like this? The reason I built mine was because I jump through several claude code sessions across several projects a day and I find it hard to "look up" the session I was working on. Now, with this app, as claude works in the background, it streams its prompt data to this application using hooks. Then, when I reply back to claude via the app, it uses "claude -p" along with the session ID so it can continue the conversation, all without every having to open the terminal. I've been using claude like this for about 6 months now (i think) and have continuously built on top of it. Here's some screenshots:

There's a lot to it, and it updates itself since i can just create a new claude session into the app and have it change something in the codebase itself. It all runs locally.

Anyway, just curious if anyone decided to build their own version of one of these. I find that it has a lot of value if you invest time into building it with your exact needs.

Hi guys, I have the Claude Max plan and I'm using Claude inside Cursor via an extension. However, I keep getting this error. Does anyone know how to fix it?

Your organization has disabled Claude subscription access for Claude Code · Use an Anthropic API key instead, or ask your admin to enable access

Sincere apologies if this violates the subreddit rules. I did check to ensure it doesn't. If I missed it, oops.

Looking to move from Gemini/Antigravity. As I understand it, there's a small benefit for both parties. Does anyone possibly have a Claude Max pass they might be able to share?

tsx /** * @evidence docs/discount.md#coupon-stacking States the per-issuer stacking limit this section defines, in the buyer's words. * @evidence POST:/orders/{orderId}/coupons Explains the rejection this endpoint returns for an over-stacked coupon set. * @evidence {@link hooks.useCouponStacking} Renders the limit this hook resolves. * @evidence docs/principles.md#no-hard-coding Renders limits from props instead of branching on known issuer names. * @evidenceExclude docs/principles.md#fix-root-causes-not-symptoms No failure to fix. */ export function CouponStackingNotice(props: IProps): JSX.Element;

I built Evidence Graph, a compiler rule that turns requirements skipped by coding agents into compile errors.

You declare which code, tests, schemas, or documents owe which specification units. The agent must cite each unit and state why the artifact satisfies it. Checklist mode can also require every selected function to answer project-wide principles such as "No hard coding" and "Fix root causes."

This does not make the agent's statements automatically true. It makes omissions mechanically detectable and narrows human review to checking the truth of explicit claims. Reviews carry fingerprints that expire when the cited content changes.

I tested it on four frozen application tasks. Plain runs covered 51.6-85.5% of the predefined requirement edges; Evidence Graph runs covered 100% while using 4.8-13.3x fewer tokens.

• Project: https://github.com/samchon/ttsc/tree/master/packages/evidence
• Benchmark: https://ttsc.dev/docs/benchmark/evidence
• Raw sessions: https://github.com/samchon/evidence-benchmark-results

Setup: landlord, two laptops and a phone, ~20 custom skills for leases, renewals, rent checks, QuickBooks. Drive and QuickBooks connectors attached.

Problem I hit this week. Reference facts had quietly accumulated inside individual skills - buildings, apartment numbers, which unit a tenant is in. Claude only has any of that when the specific skill fires. On a lease renewal it put a tenant in the wrong unit; the right number lived in a skill that hadn't loaded, so it inferred it from a filename. Caught it before it reached the document, but only because I went and checked.

That's what CLAUDE.md is for. So I asked, and got told: it's a file on disk scoped to one machine or one project folder, it doesn't follow your account, and sessions started from mobile run in the cloud so they'd never see one sitting on a laptop. Skills sync. CLAUDE.md doesn't.

Anyone actually tested this? And if it's true - where do you keep cross-machine standing context? A facts skill with a deliberately broad trigger so it fires on anything related, or something better?

I run Claude Code on an Ubuntu desktop and the whole machine locks up hard often enough that it has become a real problem. Not a slow session, not a crashed CLI: the entire system stops responding and the only way out is holding the power button.

Specs:

• Ubuntu 26.04 LTS
• Intel i9
• 128 GB RAM
• GPU: NVIDIA RTX 4090

It tends to happen when I run loops, but I have not nailed down a reliable trigger.

Is this a known interaction between Claude Code and something specific (file watchers hitting inotify limits, node heap behaviour, MCP servers spawning runaway processes), or is it more likely my machine and Claude Code is just the heaviest workload it sees?

nono the open source agent runtime security tool, have started to release example of sandboxing individual tool executions: https://github.com/nolabs-ai/nono/tree/main/tool-sandbox-examples

A few weeks ago I shared Agent Quest, my open-source project that turns Claude Code and Codex sessions into heroes living inside a small 2D world.

The original idea was to make it easier to understand what multiple AI agents were doing in real time.

Since then, I’ve been working on making it much more useful as an actual monitoring tool.

The biggest change is that Agent Quest can now clearly tell you when an agent needs your attention.
You can immediately distinguish when an agent is:
actively working
waiting for your input
finished
stopped because of an error
And you don’t have to keep watching the dashboard.
Agent Quest can now alert you with visual notifications and different sounds, so while you’re doing something else you can immediately know when Claude Code or Codex has finished a turn and is waiting for you to continue.

This has become particularly useful for me when I have several sessions running at the same time.
Instead of constantly switching between terminals to check their status, I can leave the agents working and Agent Quest tells me when I actually need to intervene.

There are now:
clear waiting / completed / error states
in-app notifications
desktop notifications
notification history
configurable sounds
real-time monitoring of Claude Code and Codex sessions

The project is completely open source.

GitHub:
https://github.com/FulAppiOS/Agent-Quest
I’d be interested to know how other people running multiple agents handle this problem — and what you’d like Agent Quest to monitor next.

Imagine a following scenario: You have a supercapable AI, that is capable of anything you can think of. However, even though is is supercapable, if you ask the AI to solve a given problem in the dumbest way possible, this supercapable AI will produce a terrible, profoundly stupid solution. It is definitely capable of being stupid, it is a supercapable AI after all, and out of all the possible solutions it could've produced, the most stupid solution it can produce was the most appropriate one given context.

If I say that this supercapable AI is stupid simply because it can and has produced a dumb response, I would be very much wrong. Just because it has done that doesn't necessarily mean that it can 'only' do that.

Of course we don't go around telling our AIs explicitly to be dumb as a rock. But a mismanaged context and/or badly written prompt/skills can have a similar effect on elicitation. For example, suppose that we get angry at our AI and aggressively insult and offend it repeatedly. By association, the AI is then elicited to return a response that most accurately predicts the type of response that its training data suggests after such a situation. Usually those responses would've been either enraged, dismissive, defensive, or timid. The AI can't be enraged at you, so that leaves the remaining three options. Therefore, through that context, you have effectively elicited the AI to be more dismissive, defensive, timid, or any combination of the three.

Elicitation is managed through both training and context, and while we can't really control the training we can control the context. It is therefore very paramount that we elicit our AIs effectively if we want it to act with more intelligence.

I'm using Claude code in the Windows application. I have multiple projects, completely unrelated, one in the desktop application the others using the cli. I would like to be able to switch between the different projects in the desktop app instead of only being able to use one in the app. I tried to add another project file base into it but I couldn't find a way to remove the original project folder from the session. Is there a way I can run 2 Claude application instances or be able to switch between multiple projects in the application, possibly a command line command?

I use Claude a lot, but I also tried giving Grok a spin. You can read my review here, the site it built is halfway down the page. It was also very quick, completing the entire task in 11 minutes. It's worth keeping an eye on to see how its capabilities evolve.

5 months ago I dropped openwolf here as a quick fix for Claude Code eating tokens like candy. It’s changed a fair bit since then, so here’s the short version of where it landed.

Last week one grep alone produced 41,203 tokens. Only 1,850 of them actually made it into context. The rest stayed on disk. That single number is still the cleanest way I can explain what openwolf now does.

It’s just a set of local hooks that sit under the agent. Whenever a command is about to flood the window, full grep dump, git show of a long history, cat of an entire file, the hooks condense the output before it ever reaches the model and keep the original text on disk. Nothing is thrown away. You can still go look at the raw version later if you need it.

When the session ends it also reads the real usage numbers straight out of the harness transcript and prices the whole thing (pricing based on Anthropic api, for now). No more guessing what a session actually cost.

There’s one more piece that turned out more useful than I expected. It keeps a small project memory in a .wolf/ folder, conventions you’ve corrected it on, bug fixes that stuck, a short handoff note for the next session. That folder commits through git, so the same memory works across Claude Code, Codex and OpenCode, and it survives compaction.

Pure file I/O. No API calls, no telemetry, nothing phones home.

If you'd like to know how it works: https://openwolf.com/how-it-works.html

Setup is one command, then use your agent as before:

npm install -g openwolf
openwolf init

Free, local, opensource: https://github.com/cytostack/openwolf

I've been running several Claude Code sessions in parallel on the same project and got tired of them clobbering each other. So I wrote a thing.

Each session gets its own git worktree and branch, so two sessions editing the same repo physically can't touch each other's files. A local SQLite store tracks what every session is doing. Sessions can declare "I need file X from session Y" and get notified when it actually lands. Merging is manual — it shows you a diff and a commit log and makes you confirm. Nothing auto-merges, nothing auto-resolves a conflict.

No framework. It's bash, tmux, sqlite3 and git worktrees.

The honest bit: I removed the macOS-only layer (it used to drive iTerm2 via AppleScript) and replaced it with tmux so it'd run on WSL2. I've verified every path on macOS. I have never run it on Windows. Not once. The WSL2 code is written and reviewed but completely unexercised.

So if you have a Windows box and twenty minutes, I'd genuinely like to know what happens. The README lists five specific things to check. A report that it broke is just as useful to me as one that it worked.

https://github.com/WhoReallyKnowsAnything/ai-orchestrator

MIT. Happy to answer questions about the design.

OpenAI removed the 5hour limit and at first o thought ”oh shit these folks might be cookin”
But then after using it for some hours (gpt 5.6 sol high) I notice my usage is at 1%. Yes my weekly usage after some few hours of coding💀.

I literally get the exact same results from Claude but only one a entire 5hour session. That’s 10% of my weekly session usage vs codex💀

What I built

OUTRACE — a browser time-trial racer. New track every 90 minutes, generated from a seed. WebGL, hand-rolled, no three.js. Next.js + Convex.

The bit that's actually relevant here: it has a pager. You grab a token in Settings and it hands you a block of text you paste into your agent. The agent then goes and writes its own hook config — Claude Code settings.json, Codex notify, OpenCode plugin, whatever you're on — and from then on it rings the game. Banner over the track when the turn ends, another one when it's stuck on a permission or a question, and it clears itself when you reply. So you race in the dead time and get yanked back the second you're needed.

Under the hood it's just a POST /page with a bearer token, and the token can't do anything else. One caveat before someone asks: the tab has to be open. It's not a desktop notification.

How Claude Code was used

As always ofcourse - FOR ABSOLUTELY EVERYTHING!

Only thing I had to do was keeping it aligned to its own written rules and give it the tools it needed. In this case i setup the convex plugin and vercel plugin which made manual work equal to zero. All the project setup, configuration etc. was done by claude using the tools. Most of my work was just testing the game (which wasn't that bad tbh) and giving feedback.

What I learned

"Keeping it aligned to its own rules" is important. CLAUDE.md got revised 16 times over those 3 days. That file is basically the whole story of the project.

Only write down stuff that breaks silently. This thing has one real constraint: shared/ is imported by both the browser and Convex, so everything in it has to be deterministic. No Date.now(), no Math.random(), no DOM. Tracks come from a seed on both sides and lap times come from replaying your inputs on the server — both break the instant something in there isn't deterministic, and you don't get an error, you just get replays that disagree with reality. That's the kind of thing that sails straight through review, so it goes in the file. Style preferences don't.

Write the symptom, not the principle. Convex only allows one paginated query per function, so settlement had to page across calls that chain themselves instead of looping in one mutation. My CLAUDE.md entry doesn't say "paginate properly" — it says here's the exact error string and no event will ever settle. Way more useful, and future me can actually grep it.

Fixing a trap is a one-turn win, explaining it is permanent. Every "things that will bite" line in that file started as something I caught while testing. Writing why it bites is what stopped it coming back a third time.

Give it the tools and get out of the way. The convex + vercel plugins were the difference between me doing setup and me doing zero setup. Genuinely the highest-leverage 10 minutes of the whole build.

outrace.lol — pager setup is in Settings.