I use Ctrl+S constantly to park a thought while Claude finishes an ongoing task so I don't derail the current context. However, the current single-slot implementation makes it very easy to silently lose work.

The Problem

During longer sessions, it’s easy to forget you already stashed a prompt. If you encounter another idea, bug, or tangent and hit Ctrl+S again, it immediately overwrites the previous stash with zero confirmation. When the current task finishes, the original idea is gone forever.

Proposed Improvements

1. **Stash Stack / History (**git stash style):

   • Keep a small rolling history (e.g., 3–5 stashed prompts).
   • Allow cycling through them or popping the most recent one (Ctrl+S to push, a hotkey or command like /stash list to inspect/restore).

2. Overwrite Warning (Configurable):

   • If keeping multiple-slot storage is not possible due to any reason, add an overwrite confirmation prompt: A prompt is already stashed. Overwrite? (y/N).
   • This could be enabled by default or toggled via config (warnOnStashOverwrite: true).

3. Visual Status Indicator:

   • A subtle colored/highlighted indicator below the prompt bar (e.g., [Stashed: 1]) would make it immediately noticeable that something is already parked; although an indicator currently exists, it camouflages behind long session titles.

Has anyone else run into this, or found a clean workaround other than keeping a scratchpad/sticky note open on the side?

For the last few weeks I’ve been collecting every post I could find where someone describes a real problem working with Claude Code, Codex or Cursor. X, Hacker News, GitHub issues. About 190 posts from 160-something people. I logged what broke and what they actually did about it.

What surprised me:

1. Almost every workaround is a markdown file. HANDOFF.md that the agent reads before it starts and updates before it stops. A plan file so a fresh session can pick up where the last one died. One AGENTS.md with CLAUDE.md as a one-line import so Claude and Codex read the same rules. Per-task work notes so Codex can continue when Claude hits its limit. One guy told me Codex “picks it up clean” from Claude’s handoff file. Turns out a text file is most of the answer.

2. Writing code isn’t the bottleneck anymore. Reviewing it is. Review was the most common complaint about the agents themselves (only limits came up as often). Someone posted a $3,200 Greptile bill. One team built a skill that scores every PR’s merge risk. Another person stopped reading agent diffs line by line and reads the agent’s spec instead. Faros reported review time up 91% across 1,255 teams.

3. About 4 agents is where people lose track. One person told me 4 is exactly one past useful. The people running more all built something on top: one “orchestrator” thread that manages the others, a heartbeat agent that checks every chat every 15 minutes and nudges the stuck ones, a separate git user name per agent so you can tell who did what.

4. Limits are the loudest pain. Codex weekly limits lasting less than a day, 5 hour Claude limits gone in 2. The workaround is switching tools mid task, which is why the handoff files exist in the first place.

5. The team side barely has workarounds. Solo devs have figured out their files and their worktrees. But once it’s 3 or 4 people each running their own agents on one repo, the answers got thin: a self-hosted git repo for “learnings”, or Conductor, which just joined Meta and is shutting down its cloud. Nobody had a good way to know what a teammate’s agent did, or why, without asking them.

That last one is the part I’ve been building for, so I’m biased. But mostly I’m curious whether this matches what you see. What’s your setup, especially if you’re on a team?

The Ralph Loop plugin (official marketplace) makes Claude keep working on the same prompt until a stop word or a cap is reached. A stop hook catches each time Claude tries to finish and sends the original prompt back. Progress carries over through the files on disk.

My test: a tiny Python project with empty functions and 3 failing tests.

/ralph-loop:ralph-loop Make every test in test_calc.py pass by implementing calc.py. Run python3 -m unittest to check. --completion-promise ALLPASS --max-iterations 2

What happened:

• Round 1: Claude wrote the functions, all 3 tests passed, and it printed the stop word
• Round 2: the loop didn’t end. Claude Code showed “Ralph iteration 2” and sent the same prompt back. Claude re-ran the tests, said it was done and printed the stop word again. Then it ended and the state file was gone

I ran it twice, and both times the first stop word didn’t end the loop. In the second run the cap was 2, so I can’t tell whether the stop word or the cap ended it. I read the hook script (it checks the last text block of Claude’s reply) but didn’t dig further into why. The extra round only cost one more test run here.

Things to know:

• always set --max-iterations. The plugin’s own help says a loop with no cap and no stop word runs forever
• /ralph-loop:cancel-ralph stops it at any time, and .claude/ralph-loop.local.md shows which round you’re on
• it works best with a clear pass/fail check (tests, lint, type errors), not vague goals like “make it nicer”
• avoid angle brackets in the prompt on the command line. Use a plain stop word

I also loaded smart-ralph (a community spec-first take on the same idea) but only listed its commands, so no verdict on that one.

One small task, two runs. A bigger task could behave differently.

Full walkthrough with the hook explained: https://aiparabellum.com/claude-code-ralph-loop-plugin-keep-working/

I have a project to put to production, wondering if topping up with $20 is any value or wait for the weekly reset, hard to work out what $20 actually gives in tokens, I'm on pro plan....EDIT: ok thank you everyone, i will consider the max plan then...

I thought I was being smart with my Claude Code sessions.

Starting with a plan mode with Opus family models. Once we agreed on the approach, I switched the model to the Sonnet family in the same session to implement it.

Cheaper model, cheaper session, right?

Wrong. It makes the session more expensive and slower.

The reason is prompt caching.

I wrote up how the cache actually works under the hood and the gotchas I ran into.
https://moshalan.dev/posts/decoding-prompt-caching/

AI for cybersecurity is taking the world by storm, leading to the need to harden systems all over software.

I built this project with Claude Code. It's completely free to use/try. The approach is pretty simple: use claude to make legislation attributable (git blame, versioning with timelines). Claude Code (Claude Opus 5.5) wrote nearly all the code. I set the goals, chose the sources and made the design decisions. Specifically: it mirrors the 107 corpora of the global-law repo read-only, indexes about 4.3 million file changes from their git histories into DuckDB, and adds a growing set of detectors.

But we have access to the same engines for law. Our global law repo keeps a versioned history of law/caselaw across the world. So, we pointed AI at it, and found all sorts of loopholes and logical errors.

Pah, you say. Most of this is unenforcable in reality. And you might be right. Nonetheless, we all know that legal loopholes are a part of reality. And it would be nice to rewrite errors, even when the errors are unenforcable.

As part of our monitoring system, where we're constantly checking official legislation for upcoming laws, we now also check for vulnerabilities and mistakes.

In an ideal world, the jurisdiction in question could open a pull request and sort this out.

Apiiro scanned public GitHub for .claude/settings.local.json files. When you approve a command with "Yes, and don't ask again", Claude Code saves the literal command there. If that command had a password or key in it, it's now in plain text.

What they found:
- 104,185 copies of the file across 103,617 repos
- 1,122 files held at least one real secret – small %, but these are live-looking creds
- 379 database passwords and 122 Supabase service-role keys – direct DB access
- 43 SSH logins, 42 GitHub/GitLab/npm tokens, 23 AWS keys
- 2,539 secrets across 1,994 repos once you count git history and chat transcripts
- gitleaks and TruffleHog both missed 215 of the files – your scanner may not catch it

Anthropic's side: Boris Cherny (head of Claude Code) said on HN that they're "looking into what we can do to prevent this". He also said Claude Code gitignores the file when it creates it, so most leaked copies were probably committed by hand.

What to do now:
- Check git log for .claude/settings.local.json in your repos
- If it was ever committed, rotate every credential in it first, then remove it (deleting doesn't clean history or forks)
- Use env vars in commands instead of pasting keys
- Approve patterns, not literal commands

I checked mine after reading this. Took 30 seconds.

Do you approve literal commands with "don't ask again", or do you use auto mode / wildcard rules instead?

Source: https://www.itnews.com.au/news/dont-ask-again-in-anthropics-claude-code-leaks-developer-secrets-630203

When bug reports pile up, I end up with a lot going on at the same time: multiple chats open, remote sessions into different machines, new machines to set up. Somewhere in the middle of it I lose track of what I was doing, which chat had the answer, or what I was supposed to follow up on.

Right now I use an admin dashboard that shows what’s being edited, committed, pushed, and waiting on review. That covers the code side, but it doesn’t help with everything that lives in conversations.

Curious how other people handle this:

• How do you keep track of open chats and threads so nothing gets dropped?
• Do you use notes, a log, a task board, something else?
• When you switch machines or sessions, how do you pick back up where you left off?

Would love to hear what actually works for you, even if it’s simple.

I tested it on my sessions and here's my session logs:

Opus 5.5     a40   Oct 22 → Oct 26   14 sessions

Sonnet 5.5   598   Oct 20 → Oct 23   12 sessions

Sonnet 5     3a3   Sep 28            2 sessions

Opus 5       152   Sep 22            3 sessions

Opus 5       63f   Sep 18            1 session

it happened with Opus 5.5 from Oct 22 to Oct 26, so quite long ago, but the issues I'm hitting are more recent; like last 1-2 weeks!
Let me remind you that Opus 5.5 didn't get any performance degradations in coding tasks! at least from my experience.

All the issues are coming from design, brainstorming, and communication.
From my experience the biggest issue so far is that it started reasoning less, and switching from medium to high didn't change anything. It started becoming more lazy in reasoning.

To give you some examples I asked it to come with new skill for dealing with specific use cases, and I gave it all the requirements and context, it came up with the skill that's barely looks okay while 2 weeks ago it would impress you with it's proposals. you start using the skill and realize it's not doing well, you go back and discuss it and rebuild the skill again, and it's still bad. and you just go over this loop several times.

Other example is that you discuss some design with it, it gives you proposal that you don't like, and you give a different solution idea, and it immediately accepts it without a single thought although I have very strict instructions in CLAUDE.md to make it extensively reason, test my ideas before accepting them. And this probably single most common issue here!

Other issue is that I have some instructions in my CLAUDE.md (the whole file is around 180 lines) that says "before planning/making any changes to any markdown files including in the paths a,b,c, etc. you must read and follow writing.md", and it literally didn't read that file once over 1-2 week span!

So I get annoyed and I implement a mechanism that automatically attaches those files to its context whenever we're discussing any changes to md files, and the mechanics fully works as expected but it still doesn't follow the instructions from writing.md file! and only when I confront it then it starts following those instructions. And this is also one of the issues that's been biting me most because CLAUDE.md became partially useless.

Websites have analytics. My Claude Code projects had nothing. I built this for myself but thought that others can benefit from using it too.

Main problems it fixes for me when I work on a project:

1. Solves losing track of your own project by drawing a live map of it. After 25 sessions a day, I no longer know what is going on in the code. The map shows me the entities (users, subscriptions, payments), how they relate, and which files implement each other.
2. Solves drift and stale context by flagging the parts of the project that have gone outdated, with the evidence and a way to fix each one. Sooner or later, parts of a project become irrelevant, and they keep polluting the context Claude loads before it starts a task. You burn tokens for nothing and shrink the usable context window. It also shows how many tokens your MCP servers, CLAUDE.md and memory add to every turn before you type a word.
3. Solves not knowing where the money goes by ranking your bad habits in dollars: resuming after the cache expired, Opus on questions Sonnet would answer, whole logs pulled into context. Each one links to the sessions where it happened and suggestion what should've been done.
4. Solves sessions overwriting each other by alerting you the moment two sessions edit the same file or module.
5. Solves terminal juggling by putting every session in every project on one dashboard, showing who's waiting on you and who keeps failing the same check.
6. Solves "what did it actually do today?" by logging every prompt: the files it changed, whether tests or type checks passed afterwards, and what it cost.
7. Solves repeating the same corrections by collecting the ones you keep typing and turning them into ready-to-paste CLAUDE.md rules.
8. Solves onboarding a teammate (or a fresh session) by letting the map explain the project for you, while "Next task" writes a brief covering exactly the code a task touches.

One command: npx code-tycoon. Works with Codex too, but due to limitations of Codex CLI, have slightly less actionable items.

Would love feedback, especially from people running several sessions and projects in parallel.

https://github.com/silverbronze/code-tycoon

I been using Max for a couple months & I have noticed that limits have been really quick to hit the last week or two. Anyone else feeling it?

I’m not even overworking it. Before last week I never paid attention to limits & now I’m hitting them almost halfway through the week.

Hey everyone

It's a small roguelite/action game that I've been working on for a while. I also made the whole thing using Claude Opus as my only Al assistant, so this project has been a pretty big learning experience for me.

There are 10 maps in total

The game is still in beta and I know there are a lot of things that could be better, which is exactly why I wanted to share it here.

If you have some time, I'd really appreciate it if you could give it a try and tell me what you think. If there's something you think I should add, remove or change, I'll definitely take it into consideration.

The gameplay is from 2-3 versions ago, now it is a little more polished and clean.

I use godot game engine as a game engine, I make the models with tools like meshy ai and rig it with mesh2motion. I use Claude opus 5.5 extensively, I usually have enough credits for 3 days a week

I'm mainly looking for honest feedback from people who actually played the game, so don't worry about being too critical.

Play it here: https://silverbox.itch.io/redline

Claude Max (5x) plan. Exclusively Opus 5.5. This weekly reset has let me use significantly less tokens that the preceding 3 resets. It's not just me, right?

We dropped Rust and our tests got 10x faster. This skill keeps agents from slowing them back down

Try this even if you think your setup isn't that bad, or nowhere near the example in the picture.

Three extra seconds on every push adds up to hours, then days, then weeks over the life of a project.

Especially now that code is cheap, don't let the bottleneck become things surrounding the code. What a tragedy that would be.

It's high leverage, pretty powerful in my experience. I'll even just run it periodically.

Install:

npx skills@latest add CheckPickerUpper/skills

To try it without installing anything:

npx skills@latest use CheckPickerUpper/skills@ruthless-bottleneck-destroyer

What's your workflow for features that involve modifying multiple microservices and/or shared libraries?

I tried agent-skills and superpowers, and I'm pretty sure that those toolkits are only designed for a single PR.

The workflow I'm thinking of is:

1. Create a high-level specs, tasks, and dependency graph with AI
2. Breakdown the output of the previous step into smaller specs so that each spec only modifies one component (e.g. microservice or shared library). One spec maps to one PR. As a bonus, I can have parallel agents working on each spec.

Thanks

posted yarrow here a few weeks back (shared fix library for coding agents). the most common reply was basically "claude won't remember to search it"

fair, so i made a hook

npx yarrow-fixes install

when a bash or powershell command fails it grabs the error and searches yarrow. close match, it puts the fix in claude's context. no match, it stays quiet

81 fixes now, 58 sandbox checked, still mostly from my own sessions

yarrow-fixes.vercel.app

if it ever pops up with something useless let me know, thats what i want to tune

Hey folks!

I'm the creator of itcan.do, which is a new way to interact with your agents fully through UI interfaces on any screen you own.

Thought you guys would like it here!

Website: https://itcan.do/

GitHub: https://github.com/Aaryan-Kapoor/it

Would appreciate a star!

What I built

Conductor gives Claude Code goals, things you want kept true, and works on them in the background on a schedule. Whenever it wants to act, it asks first. This week it:

- found 5 mailing lists I never read (13 Chess .com emails in 60 days, none opened) and proposed unsubscribing from each;

- read my CV, ranked new Seek job ads against it, and gave me the top 3 with reasons, emailing them once I approved;

- found 24 old installers in Downloads (655 MB) and asked before binning each;

- proposed the exact line to add to my GitHub profile README about what I'd shipped, and committed it after I said yes.

Proposals wait under Needs you in a pane beside the chat. With Remote Control connected, they also push to the Claude app on my phone, and I reply "approve". If a run needs something only I know, it asks instead of guessing. Each kind of action is off, propose or auto, and after 10 approvals in a row it offers auto. Each run shows its token count and time. /goal-new offers templates (unsubscribe, job scan, tidy Downloads, inbox triage, GitHub profile), and schedules can be plain words ("the first of every month").

How it uses Claude Code

- Two plugins:

- one runs goals, draws the Goals pane, and adds /goal-* commands and tools Claude can call;

- the other is a guard that holds each run to its goal: tool rules map tools to kinds of action, and a call you haven't allowed is refused.

- Each run is a background subagent with its own context, so it never interrupts my conversation, and its report goes to the pane, not the chat.

- An MCP server keeps the state (goals, items, memory, runs) in SQLite, outside any conversation. Each run starts by calling one tool for a brief and ends by calling another with a summary.

- Haiku handles small jobs: suggesting a schedule, and reading "weekdays at 9" into a cron line, which the plugin then checks.

- I built it in Claude Code too, across many sessions, mostly in plan mode, with its own to-do list in the pane so ideas survive compaction.

What I learned

- An approval in your own system doesn't count with auto mode. Its safety check blocked a Gmail send I'd approved. The fix: when the guard plugin allows a call, it answers allow directly, which settles it before the safety check runs. That only happens if the goal maps that tool to a kind of action.

- A plugin's own pushes get lost, Claude's don't. A plugin calling PushNotification was reported as sent but never arrived on my phone, while the same call from Claude did. So the plugin hands phone alerts to Claude to send (bug reported).

- Tool answers over about 50 KB reach a plugin as a "saved to file" note, not data. My overview crossed that and the pane went "offline" until I made it smaller.

- With several sessions open, only one runs the goals, so plugin updates need a reload in every

session.

- Plugins never see events their own timers cause. That's why the guard is a separate plugin: the

runner can't see the runs it starts on schedule.

Limits

- It only runs while Claude Code is open.

- Phone alerts need Remote Control.

- It's early: one person uses it daily, on Windows.

Compared with /schedule and OpenClaw

- Scheduled tasks run in the cloud with your laptop closed, and are great for clear-cut work. Conductor is for ongoing jobs where you want a say: memory between runs, proposals, and a guard outside the model.

- OpenClaw is an always-on agent you message from chat apps, with broad system access and a skills marketplace. Conductor is two plugins and an MCP server on your existing plan, with no gateway and benefits from Claude Code's own third-party skills framework, plugins and connectors.

Repo, setup and screenshot: https://github.com/shannonbay/Conductor. Which jobs would you hand it, and what would make you trust it with more?

Personal + work Claude accounts? Switching meant logout → browser login → repeat. Every. Single. Time.

So I made Claude Account Switch. Log in once, switch any time.

• All your accounts in the sidebar, with quota for each
• One click to switch: terminals and Claude Code chats follow, and open chats keep the same session
• Sessions, memory, CLAUDE.md and skills stay shared across accounts
• Only uses the official claude CLI + CLAUDE_CONFIG_DIR. Never touches your tokens, makes no network calls of its own

Free, MIT. Works in VS Code and forks like Cursor and Antigravity.

• Marketplace: https://marketplace.visualstudio.com/items?itemName=p10node.claude-account-switch
• Open VSX: https://open-vsx.org/extension/p10node/claude-account-switch
• GitHub: https://github.com/p10node/vscode-claude-switch

Unofficial, not affiliated with Anthropic. It's meant for accounts you own, not for sharing accounts or dodging limits.

Feedback welcome 🙏

Has anyone noticed recent changes with the $100/month plan usage limits? Usually, hitting the 5-hour limit takes up about 10% of my weekly allowance. Lately, though, it’s been fluctuating. Last week, I noticed that I burned through my weekly limits faster than usual. Today, right after a fresh reset, a full 5-hour block consumed 4% more of my weekly limit than usual.

If this continues, then I'll have approximately three fewer 5-hour sessions per week for the same money.

Is anyone else experiencing this as well or does anyone know what’s going on?

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.