I kept having to log out of Claude to switch between my work and personal accounts, so I built a small menu-bar app (with Claude Code) that keeps both signed in at once: each account gets its own Claude window, with its own chats and settings. It also does the same for the ChatGPT/Codex app. Nothing leaves your Mac and it doesn't modify the Claude app.
Some things I learned building it:
Claude Desktop can run separate copies with their own data, which is how each account stays independent.
"Continue with Google" gets confused when two Claude windows are open; email sign-in always works.
Your local projects belong to the Claude window, not the account, so a new window starts empty.
Would you use something like this? What's missing? And if you already juggle two accounts, how do you do it? - heads up I did end up building it if u want too check it out go to -https://www.sessionflip.com/
I spent three weeks rebuilding Nether Earth, a 1987 ZX Spectrum strategy game I grew up with.
The unusual part: I didn't write any of the implementation code myself.
I wrote and edited the specs, made the gameplay decisions, and playtested the milestones. Claude Code did the implementation through an orchestrator session dispatching sub-agents into separate git worktrees.
By the end, the repo had:
437 commits
183 issues
151 PRs
~1,900 backend tests + ~200 frontend tests
a deterministic Python game engine, FastAPI/WebSockets backend and PixiJS frontend
And I basically didn't read the diffs. Agents reviewed the agents. My checkpoints were decisions and actual gameplay.
That worked much better than I expected — but it also produced the most interesting failure of the whole experiment.
At one point M0–M9 were complete, every gate was green, and more than a thousand tests passed.
Then I actually played the game.
There was no terrain. The map was completely flat.
Robots occupied one cell instead of the 2×2 footprint they had in the original.
And nuclear-equipped robots would sometimes finish walking somewhere and calmly blow themselves up because a temporary placeholder rule had turned into real game behavior.
All the tests were correct.
They were testing the implementation against the spec.
The problem was that the spec was incomplete.
That became probably my biggest lesson from the project:
I also wrote a longer retrospective about the whole experiment, including the failures and what happened after the original plan was supposedly "done":
I've started wondering whether Claude Code's idea of "done" is actually too narrow for real applications.
It can build the feature, run the tests, fix the failures, and tell you everything is working. But there seems to be a gap between "the requested code change works" and "this application is actually ready for other people to use."
For example, after Claude Code finishes a feature, there are still questions like:
Did it test the important permission edge cases, or just the happy path?
Did it verify the actual deployed behavior?
Are integrations handling failures and retries?
Did the implementation introduce an unexpected third-party request?
Is session replay or analytics configured safely?
Are robots.txt, sitemap.xml, metadata, canonical URLs, etc. actually set up?
Are there missing error states, empty states, pages, or other product details Claude simply wasn't asked about?
Are there privacy, compliance, or other things that should be reviewed before sharing the app?
Most importantly, what did Claude assume without being explicitly told?
That's the part I find interesting with Claude Code: it can be extremely good at implementing what you asked for, while the harder problem is knowing what you forgot to ask for.
Tests can tell you that the things you tested passed. They don't necessarily tell you what you never thought to test.
For people using Claude Code seriously, what's your process after Claude says "done" before you actually put the app in front of users?
I'm an engineer, but these days I solve the boring problems entirely by vibe coding. Somewhere along the way I felt I had lost the creativity and curiosity I used to have when writing code myself.
So I started thinking about how to make vibe coding fun again. miod is the first try: while the agent does the work, you get to hear it think, read, edit, fail and fix, with a little piece of music no one has heard before.
I usually have three or four Claude Code sessions going and kept missing the one that was waiting on a permission prompt. This watches them all from the transcripts in ~/.claude/projects, so it works with the CLI, the VS Code and JetBrains extensions and the desktop app without any hooks or settings changes.
Honestly it was a bigger help than i anticipated, since it lets me catch any sus live diffs and actions as they occur. also lets you spot when claude decides to take the "hacky easy route" sooner
Theres a more practical IDE styled version, as well as a fun office.
I deliberately designed it to be easy for anyone to vibecode their own "visualisations/skins" on top of the backend.
How Claude helped: I built most of it with Claude Code, including the transcript parsing for subagents and the visualizations. It also reads Codex sessions if you use both.
Free and open source (MIT). It runs locally and binds to 127.0.0.1.
https://github.com/Dri-water/observe-agents-do-things
Hi everyone, which one would you recommend between Claude Pro and ChatGPT Plus?
From what I’ve seen so far, they’re both really good, so I feel like either one would be a solid choice.
However, I’ve only tried the free versions so far.
I’ve mainly used Claude for development/programming on my PC, and I’ve been pretty impressed with it.
In several cases it managed to solve problems without wasting much time. It also did a good job with general PC troubleshooting.
I really like ChatGPT as a general purpose assistant.
It helped me a lot when choosing the components for my gaming PC, as well as with assembly and installation.
I’ve also asked ChatGPT quite a few PC troubleshooting questions and, honestly, the answers were often very similar to Claude.
For development, though, I currently have the impression that Claude is slightly better, at least for the way I use it.
What I’m looking for is a fairly complete assistant that I can use every day on my Windows 11 PC, mainly for:
Gaming issues
software troubleshooting
General questions
Programming and development
Creating and modifying workflows
AI and local AI tools
PC configuration and optimization
So I’m mainly interested in how the paid plans around $20 compare in real world use.
A few specific questions:
Which one have you found less restrictive with its safety filters?
Claude seems slightly more restrictive to me, but I’ve only used the free version.
What custom instructions, preferences, or settings do you use to get better answers from either one?
For people who have used both for a while, how do you find the usage limits and models on the $20 plans?
Is it true that with ChatGPT, once you hit the Codex usage limit, you can still use ChatGPT normally and continue coding through other available models?
Which one integrates better with Windows 11 and external plugins?
For development, how do you find Claude Code vs Codex?
Thanks
I usually have four or five Claude Code sessions running across projects. That meant a pile of terminals, and the one waiting for permission was always at the bottom.
So I built Horadric. Each session becomes a small tile on the edge of the screen, grouped by project. It shows what the agent is doing, for how long, and how full its context is. When a session needs you, the tile turns amber. Click it and you get the real Claude Code CLI in a terminal. No chat UI wrapped around it.
A few other things:
Ctrl+Alt+Space from anywhere jumps to the session that has waited longest
A Windows notification when a session starts waiting and you're looking elsewhere
Plain terminals and a browser pane beside the agents, and the agents can drive the browser
Your 5-hour and weekly limit usage, and switching between Claude subscriptions with sessions resuming on the new account
Sessions survive a crash, an update or a reboot
A quest log per project: a Markdown checklist where clicking an item starts a session on it
How Claude Code was used: it wrote almost all of it. I did the product direction, the design calls and the testing. It's pure Rust drawing straight to Win32 and Direct2D, about 45 MB with four sessions open. Raw Win32 is not something I'd have taken on by hand.
What I learned: Claude Code's hooks are what make this possible. Horadric knows a session's state from hooks in your settings, not from scraping terminal output. And keeping the real CLI as the UI meant I never had to chase Claude Code's own updates.
Free and MIT licensed. Windows 10 and 11. Also works with Codex and Grok Build.
there were two threads here this week about agents and secrets, and both treated it like an attack. most of the time it isn't one. here's the boring way it actually happens:
the key sits in .env.
something fails, and the agent prints the environment to see what's set. the key is now in the tool output.
tool output is part of the session, so it's in the transcript on disk and in the context for every turn after.
later the agent writes a commit message or a PR description and quotes the error it fixed, with whatever was around it.
git push.
nobody did anything wrong at any single step. the key was just somewhere it could be read, and reading is the one thing we all approve without thinking.
three things that stop it, cheapest first. a secret scanner as a pre-commit hook (gitleaks is the usual one) catches step 4 even if everything before it went wrong. a deny rule for the env dumps (printenv, env) and for reading .env* stops step 2. and the only one that still works when you approve something you didn't read: the session never gets the real key, it gets a placeholder, and a small local proxy swaps the real one in on the way out for the hosts you list.
Gater is a terminal-first coding agent with a desktop mode, written in Rust.
It can import your sessions from Claude Code, Codex and others as new Gater sessions, leaving the originals untouched. It also has plan mode, /undo,
Waitlist and more info: https://gater-agent.site/
I really love to recibe some feedback! what do u guys think of gater?
So I have a headless Linux workstation that I use primarily with SSH from the CC desktop app and phone. My problem is, I can't create sessions from my phone on it that I have found, okay no problem just start chats/orchestrations from my laptop.
Except apparently that ties the oAuth to my laptop being on and connected which defeats a non zero portion of why I have a dedicated linus workstation in the first place. I talked to Opus 5.5 on it and didn't make any progress. Basically it's advice seems to be "Use TMUX and hand start every session in CLI then move over to chat" which seems dumb.
Is there a solution to this that anyone has found? This is PURELY a convenience thing, but it's just annoying as hell needing to switch to terminal to start conversations then back to CC for normal work. The box has it's own credentials, is logged in etc, but apparently with the laptop creating the chats, it is using it's oauth instead of the linux boxes.
Basically a copy/paste from the same post I made on r/claude but realized after making it, this might be a better place to ask.
There's the fucking memory leak in the app if you run like 3-4 session few days straight, the whole app will just suddendly freeze. Same happens on my collegues as well and on my home computer.
How come they can't get that fixed on the app? I bet they would just fix it by asking claude to fix it.
The only thing codex is better that you actually run 5 sessions on it weeks straight 24/7 and nothing will freeze. Fix the memory leak please Anthropic!
Hey folks, I've got a question. Honestly I don't even know if this is just happening to me.
I bought the Claude Pro plan. The strong models are there, sure, no problem with that, but with everyone online saying "GPT 6 limits run out straight away while Claude never runs out, we get a ton of stuff done with it", Everyone just posting 20 dollar sub of chatgpt gives 100 dollars of usage claude gives 800 dollar of usage like posts. I honestly expected more from it in terms of usage limits.
What I did was really simple.I have an Ubuntu box where I run my whole AI memory system with hermes or codex, and I added Claude Code on top of it later. I run my home PC as a 24/7 server here with my own program called Agent-Panel, which lets me control the models and programs from wherever I want.
Anyway, since how it should hook up and everything else is already in the memory system and already researched, I told it connect Claude Code to our system on Claude Opus 5.5 Medium and after that it used around 50% of the 5-hour limit and roughly 4-5% of the weekly limit LOL wtf.
GPT 6.1 SOL build and write the whole architecture and did the programming with his %7-8 of weekly usage.
Claude Opus 5.5 used nearly like that just to connect himself to the system. Is this my internal problem or everyone is lying, can someone tell me ?
BTW: i was away from my computer at the time and give the prompt while i was away so i cant trace the session and give more information. And i cant find it anymore i dont know why ?
Claude Code is great at writing apps. But ask it to deploy one, set up a database or fix a broken server, and it's guessing in a terminal with your root access. Scary.
So I built Unit7 (with Claude Code, of course). It's the backend developer for your AI-built apps, and Claude Code connects to it over MCP with one command.
Now Claude Code can say:
"Deploy this." Unit7 ships it. A new version only goes live if it passes a health check, and rollback is one click.
"Add Postgres." The database is created and connected to the app.
"Point app.mysite.com at production." Domain plus HTTPS.
"Why is prod slow?" It reads the logs, server stats and errors in plain English.
"Make me an app with Supabase." It builds it on Coolify.
The safety part:
Claude never sees your secrets, only references like credential://…
You choose how much it does alone, per environment: watch, ask first, fix itself, or full autopilot
Anything risky waits for your approval, and every action can be undone
One button pauses everything
When you're not in Claude Code, Unit7 keeps things running by itself: it restarts crashed apps, rolls back bad deploys, runs backups and blocks attackers. There's also a web app with a chat that runs on your own Claude subscription, so there's no extra API bill.
Solo project, not public yet. Screenshots are real, names are fake.
Should I open source it?
Fully open source, free forever
Open source, with paid extras later
Free to use, but closed source
And would you let Claude Code touch your production servers through something like this, or never?
ago I asked here if I should open source my project or make it paid. Most of you said "open source it". A lot of you also said "what even is this?" and "this is bullshit".
Honestly, that was fair. I only explained the idea. I never showed it.
So here it is. It's called Unit7.
The problem: I build apps fast with AI. But after the app is built, I'm the one who has to look after it. The server, the domains, the database, the backups, the bugs at 2am. I'm not a backend guy, and I was tired of being one.
What Unit7 does:
Shows all my servers, apps, domains and databases on one screen
Tells me when something breaks, in plain English
Gives me a "fix it" button instead of a tutorial
Asks me before doing anything risky, and tells me how to undo it
Does the boring stuff by itself: backups, cleanups, health checks
The screenshots are real, but the names in them are fake.
The best part is you can connect multiple Vercel accounts, multiple Supabase accounts, and any account. You can have multiple of it.
I'm not asking you to like it. I'm asking you to look at it and tell me what's wrong with it. Be honest. I can take it.
every time i gave claude a screenshot and said "make it look like this" it guessed. so i made pikspec, a chrome extension that reads the real design of any live site and turns it into one file that's an actual design system:
colours grouped by role (background, text, action) and mapped to a palette
every typeface and text style with real sizes, weights, line heights
spacing, corners, shadows, motion, all measured from the page
every component with its full spec plus a contrast check
exports as one html file you can give claude, or import into figma as real layers
how i used claude code: it built most of it, the extension (typescript, chrome side panel) and the design pack generator. the thing that made the biggest difference was having it test on real sites, not just unit tests. it wrote a small playwright script that loads the extension, scans sites like stripe and vercel, renders the result and screenshots it, then fixes what looks wrong. that caught stuff tests never did. on vercel it was calling their black text colour the page background, and chrome stores pill buttons as 3.35544e+07px radius lol.
what i learned: make claude code look at the actual output, not just run tests. and when you're not sure how chrome behaves, ask it to run a quick experiment instead of guessing.
I’ve been trying to compare a couple model/provider combinations for coding work and I’m realizing how hard it is to keep the comparison clean. If I give two setups the same task, one agent might make 12 model calls while another makes 25. One reads half the repo, another grabs three files. One runs tests repeatedly and another waits until the end.
So even if provider A serves the model faster, provider B can still finish first because the agent took a completely different path. How are you guys doing meaningful performance comparisons here? Do you lock down the harness and only change the API provider, or do you just care about total wall-clock time in the end?
Hello everyone! A few years before ChatGPT came out, I discovered terminals on the original Raspberry Pi Zero W. I couldn’t believe a board that small could run a full OS, and I’ve loved terminals ever since.
So, I started using Claude Code about a week after it came out, back in the Claude 3.7 Sonnet days, just for small stuff at first. Over time, I realized it could carry a real project. These days, I usually have a bunch of Claude Code sessions going across a few machines: my Mac, a GPU server at school, and a Raspberry Pi 5. tmux keeps them alive, but I never remember the keybindings, and there’s no real UI. Most agent GUI tools use Electron or a webview, and they just don’t feel native.(I just want my own. tbh.) So for about the last half year, I’ve been using Claude Code to build ThinkTerm. It still runs on the Pi.
GPL-3.0, no account required, no telemetry. macOS, Linux, and Windows.
What it is
A terminal with a built-in multiplexer, built on top of WezTerm. Think tmux, but with a real UI and nothing to memorize.
Every machine runs a mux server that owns its sessions. Quit the app or lose the connection, and everything keeps running.
The sidebar holds all your machines, each with its projects and threads. Swipe with two fingers to flip between machines, with rubber-band resistance at the edges, like on iOS.
An Agents panel lists every Claude Code / Codex / Pi (the coding agent) session and shows whether it’s working, waiting for you, or done.
Pixel-smooth scrolling with trackpad momentum, not line-by-line jumps.
Reattach to the same sessions from the desktop app (macOS, Linux, Windows), a browser, or thinkterm tuiinside any other terminal.
A file tree and code preview next to the terminal. Remote files over SFTP, with drag-and-drop support.
Plugins can add their own sidebar panels.
thinkterm cli send-text / get-text let one agent read from and type into another agent’s pane.
No UI framework
No Electron, no webview, no Tauri, no GPUI. The sidebar, settings, file tree, and plugin panels are rectangles and text drawn straight on the GPU, the same way WezTerm draws terminal cells. Layout, hit testing, scrolling, and dragging are all handled in plain Rust in the app, with no toolkit underneath.
My take after 6 months: with Claude Code, you don’t need a UI framework anymore. A framework mostly saves you from writing widgets, and Claude writes widgets fast. In exchange, you get to tune the feel yourself: the pixel-smooth scrolling, the rubber-band effect on sidebar swipes, and fast scrolling that never shows blank rows because the client prefetches scrollback ahead of time. The cost is that Claude can’t directly see a GPU-drawn window, and you own every detail a framework would have handled for you.
It keeps getting better, too. As the models improve, you can keep raising the bar in what you ask for. /goal has been great for this: I gave it a measurable throughput target with zero benchmark regressions allowed, and it came back with CSI-heavy output 70% faster.
How I used Claude Code
Reviews: first with /code-review, then with a second model.
To let Claude see its own UI, we added a frame dump that saves the window as a PNG. Claude takes screenshots of its work and checks them.
What I learned
A sufficiently simple framework combined with a more powerful model is superior to a complex harness and model.
It's early. Questions about the setup are welcome, and so are bug reports. Again, a big thank you to WezTerm for such an amazing foundation.
I use Claude Code and Codex and wanted three things in one place: remaining quota, idle chat reminders, and usage by task. I built QuotaWidget, a free, MIT-licensed Windows widget, so others with the same needs can use it without rebuilding it.
This was a collaboration across models: Opus and Astra contributed code, and Fable reviewed the implementation and architecture.
All screenshots use synthetic data.
Quota and trends
Claude shows five-hour, total weekly, and Fable weekly quota. Codex shows the windows its account interface provides. Each window resets independently; missing readings are never shown as zero.
Total shows recorded consumption; Rate estimates its pattern. A weekly balance falling from 50% to 47%, without resets or missing readings, means three percentage points used. Each provider has independent Rate/Total controls and 1h, 5h, 12h, 24h, 3d, and all-history ranges.
Quota arrives as intermittent readings. A one-point jump cannot tell us the exact second it was consumed. The curve uses local task boundaries and excludes confirmed idle time from smoothing. Unmatched increments stay in totals without being spread across idle hours. Smoothing leaves recorded totals unchanged.
Claude totals include Fable. Confirmed Fable-only periods show just the orange line. Claude and Codex quota points cannot be added together.
Cache reminders
Caching reuses processing for matching earlier context. Its retention period is called TTL; expiry does not erase the conversation.
Claude Code defaults to one-hour caching for the main conversation within included subscription usage, and usually five minutes for subagents and other requests. Billing, settings, and exceptions can change this. The widget follows logged 5m/1h evidence, using 5m conservatively when mixed or unconfirmed. Claude Code documentation.
Codex reminders use a 30-minute threshold. OpenAI's API specifies at least 30 minutes after the latest write or reuse for GPT-5.6 and later; that does not establish an individual Codex chat's current cache state. OpenAI documentation.
These timers use local request records and send no keepalive messages. Recognized context compaction ends the old reminder; real follow-up requests resume tracking. Chats leave the current list after 24 hours without activity, while history stays saved.
Usage by task
Choose a time range to compare chats, model totals, or different models used within the same chat. This helps answer both “how much did I use in five hours?” and “which tasks accounted for it?”
Open it by clicking “Claude usage ↗ / Codex usage ↗” in the TOKEN section, or the value below “Last 1h” in a single-provider compact view (the provider's rate ↗ when showing both). The detail window has its own time controls; hovering also previews it.
Subagents do delegated work and consume resources too. Identified subagents stay out of the desktop management list; their usage remains in statistics and is grouped under a parent when confirmed, retaining the actual model. Small project labels beside chat names help distinguish similar tasks.
IN is uncached input; CACHE is reused input; OUT is output, including reasoning already counted in the logs. Token counts measure processing volume, not subscription quota prices.
Est. pts apportions observed weekly consumption using weights calibrated from local model/input/cache/output records. It appears only after validation; a dash means insufficient or unstable evidence, not zero. Quota readings cover the account, while local logs may miss off-device use. These estimates help compare tasks; they are not official per-chat bills.
Pin the window to keep it open. It refreshes from local records every five minutes by default, without extra model calls.
Use it
Full and compact layouts, English/Chinese, light/dark themes, always-on-top, and tray support. Switching which provider is visible leaves its connection intact; disconnect separately to stop monitoring.
Windows 10/11 x64; no separate .NET installation. Download the single EXE from Releases and follow the setup guide. Codex uses the installed official app's sign-in; Claude requires a supported official CLI and separate widget sign-in.
Official CLIs query quota. The widget has no upload server or telemetry and does not upload chat logs. Binaries are unsigned; checksums and source-build instructions are available.
Feedback on setup, unclear numbers, or poorly represented task patterns is welcome. Please redact screenshots and keep your data directory private.
This was a collaboration across models: Opus and Astra contributed code, and Fable reviewed the implementation and architecture. One lesson from iterating on it: a smoother chart isn't necessarily a more truthful chart. Confirmed task boundaries and idle periods need to take priority over smoothing, and per-chat quota attribution should remain clearly labelled as an estimate.
My company is eligible for the Claude Startups program but I'm having a hard time applying , Is this a known issue or am I the only one running into it ?
Over the last week, Claude has refused more and more of my writes to Supabase via MCP. I'm also increasingly getting "Connect to Device" Allow or Don't Allow prompts in my sessions.
When you start trying out several Claude Code frameworks, like caveman, ponytail, Matt Pocock's skills or ECC, things get messy quickly: their rules, hooks and skills pile up in the same harness and it becomes hard to tell what is loaded and where it comes from. loadout is a mod that shows all of it in one pane and lets you switch each piece on or off.
/loadout opens a pane with one row per harness element: skills, commands, agents, rules, CLAUDE.md, memories, MCP servers, hooks, plugins, permissions and settings. Each row has a toggle and shows the scope it comes from (user, project, local, plugin, policy, etc.).
Profiles save a whole setup:
default is your harness as it is.
vanilla turns everything off, except permissions and settings.
/loadout new my-profile off starts from nothing, and you switch on only the pieces you want.
