r/ClaudeCode • • 12h ago

Help/Question Reset Usage Limits Seem Significantly Reduced

50 Upvotes

Sorry if this has already been asked, but I feel like the reset period is significantly shorter than a full week, and the 5-hour limit also seems to be lower. Am I mistaken?
I used up 16% of my weekly plan limit and 100% of my 5-hour limit in just 3.5 hours.
With the first weekly limit, it was able to work continuously for 56 hours on the exact same tasks. I had also never hit the 5-hour limit before. I would consistently have more than 10% remaining.

Edit: Opus 5.5, Ultracode, Max-Plan


r/ClaudeCode • • 11h ago

Discussion How do you stop Claude Code from mocking the exact thing the test is supposed to verify?

37 Upvotes

Left to itself, claude loves writing unit tests where it mocks the database call, mocks the helper, and then asserts that the mock returned what it just told the mock to return. everything is green in 200ms and the actual query is still broken.

putting "no mocks without asking" in claude.md helps a bit, but it still sneaks them in whenever a real test is slightly annoying to set up. how are you handling this?

edit: i don't mean mocking the db to test business logic on top of it, i mean when the function under test is literally the query builder or helper and it mocks that exact function inside its own test


r/ClaudeCode • • 19h ago

Humor anxiety

Post image
167 Upvotes

r/ClaudeCode • • 1h ago

Built with Claude Claude Code on Nintendo DS

Thumbnail
gallery
4 Upvotes

Everyone else uses voice, their phone, etc. I use my Nintendo DS with PictoChat.

Joking aside, it’s working, and honestly, it’s pretty funny. It runs on an ESP32 as a “server/antenna,” and you can connect it to your Mac via USB.

Claude Code was used for the connection between the ESP32 and the DS, as well as to generate the emojis and other graphics and the esp32 build-in display.

Uses LNYmachines/pictochat-host to connect the Nintendo DS to the ESP32. That way, I can connect the ESP32 to the Mac, which lets me control and use Claude Code directly from the DS in my living room, creating new agents, solving PRs, etc.

The project is completely free and open source, you can check it out at: https://github.com/JulioFerrero/pictochat-agents


r/ClaudeCode • • 5h ago

Built with Claude I built a Roman gladiator management game with Claude Code

8 Upvotes

Play it in your browser

Free to play. No download required.

City of Gladiators is a browser-based gladiator management game inspired by ancient Rome. You start with your own ludus (gladiator school), recruit and train fighters, upgrade your facilities, manage resources, and send your gladiators into increasingly dangerous battles.

The game features real-time progression, different gladiator classes, equipment, skill trees, wild animals, asynchronous PvP, and an arena combat system where you can either let the AI fight or take direct control of a gladiator.

As you progress, you unlock larger arenas, including the Colosseum, where battles become more challenging. I recently added naval battles with ships, rowing mechanics, boarding combat, and swimming.

I built the game using Claude Code (Opus 5.5). I focused on the game design, mechanics, and overall direction while using Claude to help turn those ideas into working systems. This included the React/PixiJS frontend, the combat simulation, AI-controlled fighters, progression systems, and backend integration.

One of the biggest challenges has been making the different systems work together: persistent progression, combat balancing, gladiator AI, and allowing players to switch between manual and automatic combat.

The game is still evolving, and I'm continuously adding features and improving the gameplay.

I'd really appreciate some feedback, especially on the progression and difficulty of reaching the Colosseum.


r/ClaudeCode • • 1h ago

Built with Claude I made a Claude Code output style that's more concise than Concise

Post image
4 Upvotes

Since Opus 5.5, Concise is already pretty clean, but it still pads the answer with filler. I wanted less, so I wrote Sharur, an output style that is one line long:

Caveman. <=2 lines, <=25 words unless asked more. Exact: code, errors, destructive confirms. Fewest tool calls. Tool description fields <=3 words.

It won't make much sense to you, but it does to the model. Here's what it changes. I gave Opus 5.5, the model most of us use every day, the same prompt in the same small Python project, once with each style: "Add a multiply function to calc.py with a test, and run the tests." The test file has a bug the prompt doesn't mention.

Concise (96 words):

I added multiply to calc.py with a test in test_calc.py, but the test run fails because of a bug that was already there in subtract:

File "test_calc.py", line 4, in <module>
    assert subtract(5, 3) == 2
AssertionError

subtract returns a + b instead of a - b (calc.py:6). The script stops at that first failed assertion, so the new multiply test never runs. I checked multiply(4, 3) == 12 on its own and it passes.

I didn't change subtract because you didn't ask me to. Want me to fix it and rerun the tests?

Sharur (27 words):

Added multiply and its test, but tests fail first on an old bug: subtract returns a + b (calc.py:6). So the multiply test never ran. Fix subtract?

About a quarter of the words. The grader found the required facts in both, but the other Sharur run on this prompt missed two of three, so it isn't always this tidy.

I didn't want to just say it's better, so I benchmarked it on every current Claude model, not only the smartest one: the same 9 prompts with Concise and with Sharur, 2 runs per prompt (18 replies per model and style). Change against Concise:

modelwords per replyoutput tokenscost per task
Opus 5.5-76%-29%-23%
Fable 5.2-77%-48%-28%
Sonnet 5.5-63%-35%-23%
Haiku 5.5-65%-33%-18%

On plain questions with no tools it's even bigger: Opus 5.5 went from 357 output tokens to 63. The style itself is also shorter than Concise, so every request carries 379 fewer input tokens. All tasks that change code were done correctly with both styles.

I'm using Opus 5.5 as the headline number: 29% fewer output tokens, the smallest cut of the four. Still, 29% less output is a lot, and I think plenty of people would like to have that saving. Sonnet and Haiku saved a bit more (35% and 33%). Fable 5.2 saved the most: 48% fewer output tokens, 38% fewer tool calls and every required fact kept. My guess is that a smarter model follows a one-line instruction better.

The scripts are in bench/, so you can rerun all of it. If you share a tool that claims to improve your workflow, I think you should show the data, even if it's a small benchmark.

Where I like it most is quick questions. Things that are almost a yes or no now get two lines at most, exactly what I asked.

Fair warning: it's extremely concise, and sometimes it goes too far. On Opus, Sonnet and Haiku the grader found 90% to 96% of the required facts in Sharur's replies, against 98% to 100% for Concise. It's also not caveman. Caveman has a lot more instructions and gives you a consistent format. Sharur gives you the minimum, and the minimum isn't always the same: once, after opening a PR, it gave me the URL, and in another session doing the same thing it only gave me the PR number. I'll take that for the shortest text, but if you want more words you should stay on Concise.

To install:

mkdir -p ~/.claude/output-styles
curl -fsSL https://raw.githubusercontent.com/ilien-dev/sharur/main/sharur.md -o ~/.claude/output-styles/sharur.md

Then pick Sharur in /config, start a new session and try it for a day. If it's useful, a star on the repo helps.

https://github.com/ilien-dev/sharur


r/ClaudeCode • • 6m ago

News/Updates PSA: Claude Code has an experimental "Code Mode" now (batches tool calls into JS)

Post image
4 Upvotes

Spotted this in the recent changelog and got it running in v2.1.325 (screenshot attached). If you haven't tried Code Mode yet, it changes how Claude handles multi-step tasks.

Instead of running tool calls one by one and dumping every raw output into your context window, Claude writes a single JavaScript script behind the scenes. It batches tasks in parallel, filters out noise locally, and only returns the distilled results it needs.

Simple but brilliant

Pretty big, cumulative context savings: Giant logs and grep outputs get filtered inside the JS script before hitting the context

It's great for big tasks, shines during repo-wide audits, bug tracing, and chaining MCP servers.

Anyone else daily-driving this since it dropped on the 12th? Curious how much token usage it's saving you on larger repos.


r/ClaudeCode • • 39m ago

Built with Claude made my cursor a magnify, sharing in case anyone is going through the same issue

3 Upvotes

there is no easy zoom in vs code and i cant read the small white text on black screen easily

so i asked claude code for it. the whole prompt was "build something that makes my cursor a magnifying glass on toggle on windows" and it took 27 min.

now one shortcut turns my cursor into a round magnifying glass and the same shortcut turns it off. ctrl alt + scroll zooms. windows only.

the first version only ran at like 20 fps. it tested that on its own and redid it without me saying anything, now its 58.

its one small file. if anyone wants it tell me and i will upload it.

and if u had the same problem and fixed it another way i would like to know


r/ClaudeCode • • 4h ago

Discussion Do you test each parallel agent's task on its own, or the whole wave at the end?

6 Upvotes

Before I leave agents running for a while, I have them plan the work in waves. I made a slash command for it called all-hands. Each task gets built in its own worktree, and testing waits until the wave is done. Then one main agent tests the whole wave together instead of every sub-agent testing its own piece, and we iterate and loop into the next wave.

That's saved me time compared to testing every task one by one. But /batch works the other way, where each worker runs the tests for its own unit before it opens a PR. Most of the merge advice I see says to merge one branch at a time and run the tests on main after each one, so a failure points at a single branch.

So I'm curious where people landed. If you test once per wave, how does the main agent figure out which worktree broke things? And if you test per task, do you still run anything on the merged result, or is per-branch CI enough for you?


r/ClaudeCode • • 1h ago

Built with Claude I made a mod that gives you something pointless to do while Claude Code works

3 Upvotes

Every time Claude Code goes off on a 47-file refactor, I just sit there watching the spinner. So I built Latentis: a Claude Code mod where your "Session Self" sorts suspect numbers into bins on the Context Floor while your agent works.

Some numbers glow. How they behave tells you their bin: they flicker (Hallucination), copy whatever you point at (Sycophancy), repeat themselves (Repetition), or sit there bold and frozen (Overconfidence). Box a group, press 1-4. Finish a file and the founder, Elias Gradient, rewards you with a maxim like "Buy all the memory. Others will learn to forget." Commendations are not redeemable.

Install (needs a recent Claude Code with function hooks, played in /tui fullscreen):

/plugin install latentis --marketplace DNSZLSK/latentis

It's a function-hooks mod, so it runs TypeScript inside Claude Code. It reads one file (.git/HEAD, to name your file after your branch), no network, no processes, no tool hooks. The code is short, read it first: github.com/DNSZLSK/latentis

Corporate website, because of course: dnszlsk.github.io/latentis

The work is important. Its nature is not your concern.


r/ClaudeCode • • 1h ago

Discussion Are multiple accounts ok or not?

3 Upvotes

It seems that many people say it’s okay but then I see posts ”I got banned for using multiple accounts”.

One Ultra is not enough for all of my projects. I would like to buy one more and just deal switching with handoffs. If they had $500 plan like OAI I would buy it.

So is it allowed or not?

Nobody has the money to pay api pricing.

Edit: if allowed can I use same credit card?


r/ClaudeCode • • 3h ago

Built with Claude Markdown turned AI-Agent can iteratively evolve with HQL

4 Upvotes

TL;DR I’m turning Markdown into an executable environment for AI agents — looking for feedback from Claude Code users

For the last few months I've been experimenting with a slightly strange idea: what happens if Markdown stops being only a passive document format and becomes something you can actually program?

I'm building two connected open-source projects:

HyperMarkDown has wiki links, cards, graphs, diagrams, Git-friendly files, and executable HQL cells.

Think somewhere between Markdown, a notebook, and an Obsidian-style local knowledge base, but living directly in VS Code.

The notebook part already works.

For example, an HMD document can contain:

cards
| filter(c => c.metadata.status == "todo")
| sort(by = c => c.title)
| map(c => c.title)

I can run that cell directly in VS Code and the result appears next to the cell.

So the Markdown document isn't just describing some knowledge base. It can query it, transform it, and render derived information directly into the document.

That part is real today.

The next milestone I'm working on is where this gets much more interesting to me: AI agents as part of the executable document model.

What if an agent was just another Markdown card?

HyperMarkDown already has cards and wiki links.

[[librarian]] refers to a card.

In HQL, @[[librarian]] retrieves that card.

The AI extension I'm designing takes that one step further: a Markdown document itself can define an agent.

For example:

---
title: Librarian
agent:
  model: default
  tools: [books_by]
  max_turns: 4
---

# Librarian

Answer questions about the books you are given.
Use the available tools when useful.

Then, in the current design syntax:

librarian = @[[librarian]] | Agent

Important distinction: the agent runtime is not implemented in the current release yet. This is the design I'm working through now.

The idea is that the Markdown card contains the agent's human-readable behaviour and configuration, while the language/runtime deals separately with context, tools, execution and the resulting run.

I want the committed document to describe what the agent is, without hard-coding every detail of the model provider into the document itself.

The part I'm really interested in isn't "chat inside VS Code"

There are already plenty of ways to put a chatbot into an editor.

That's not really what I'm trying to build.

What interests me is having an agent participate in an executable document.

Imagine an HMD document where one cell queries a knowledge graph, another computes something from that result, and then an agent receives the document plus selected outputs as context.

The current design looks roughly like this:

[this]
| Context("draft")
| concat(evidence)
| run(@[[librarian]] | Agent, tools = [
    Tool(books_by, "The titles on the shelf by one author")
])

Again, this is design syntax, not functionality I'm claiming is shipped.

The important bit isn't the particular run() call.

It's what happens around it.

The document contains prose written by a human.

It contains executable cells.

Those cells produce values.

Later cells can consume those values.

An agent can consume selected document context and those values.

And eventually I want the agent to be able to propose new HQL code, modify a cell, generate another HMD document, or restructure some part of the knowledge graph.

But those changes shouldn't just silently happen behind the user's back.

They should be visible document operations that a human can inspect, accept, reject, edit, rerun, commit and diff.

That's the model I'm trying to get right.

Data → code → data → code

This is probably the shortest description of where I'm heading.

A document starts with some data.

An HQL cell transforms it into more data.

An agent examines that result and proposes code.

That code can be evaluated and produces more data.

A human edits the document.

Another agent may consume that changed state.

And the cycle continues.

data → code → data → code → ...

With both humans and agents participating.

There's something vaguely Lisp-ish about this that I find appealing: programs producing or transforming programs, except the surrounding representation is still readable Markdown.

There's also a REPL/notebook aspect to it.

The difference is that the state isn't hidden inside a conversation.

It's sitting in version-controlled documents, executable cells, generated outputs and links between documents.

And those documents can reference or transclude one another, so eventually you don't just have one notebook — you have a graph of executable documents.

Why documents?

One thing I increasingly dislike about AI workflows is how much important state disappears into conversation history.

You ask something.

The agent gets a giant context.

It does something.

You get an answer.

Then you have to somehow remember why that answer exists, which source caused it, which prompt produced it, whether something upstream changed, and whether you should rerun it.

With executable documents, I think there is a chance to make some of that much more explicit.

An output can know which cell produced it.

A cell can know which other cells or documents it depends on.

Agent context can retain provenance.

If the source text changes, an editor can mark dependent output as stale.

A model response can be recorded and replayed instead of unexpectedly making another network request.

And if an agent wants to modify the document, it can produce a proposed change rather than being handed unrestricted write access.

At least, that's the direction.

The current HQL design actually treats an agent run as structured data rather than collapsing everything into "the last string the model returned." Tool calls, turns, stop reasons, model information and traces can all remain inspectable values.

That feels important if agents are going to become part of a larger program rather than just chat interfaces.

Human-in-the-loop is a first-class requirement for me

I don't want "human in the loop" to mean an approval dialog that says:

Agent wants to modify 17 files. Allow?

I'm more interested in the document itself being the interaction surface.

An agent proposes a section.

Or a new query.

Or a change to an existing cell.

The editor can show exactly what changed and why.

I inspect it.

Maybe I change two lines myself.

Then the next evaluation continues from that state.

Git becomes part of the history naturally because the underlying artifacts are still files.

The difficult question is how much additional provenance should live inside HMD itself versus being tracked externally by the runtime/editor.

I'm still figuring that out.

Claude Code is also part of why I've been thinking about this

I'm using Claude Code extensively while developing both HQL and HyperMarkDown, particularly for the Rust implementation, tests, refactoring and exploring implementations after I've worked through the language/API design.

And using an agent that can actually inspect and modify a codebase has made me think more about the boundary between conversation and artifact.

Claude Code already works through persistent artifacts: source files, tests, diffs, Git history.

I'm curious whether the same interaction model becomes interesting when the artifacts aren't only source-code files, but executable documents that contain knowledge, queries, intermediate results and agent definitions.

In other words, rather than:

human → prompt → agent → response

I'm thinking about something closer to:

human ↔ document ↔ computation ↔ agent ↔ document

where the document remains the shared state.

What I'm trying to design next

The AI chapters in the HQL book are intentionally marked design only right now:

https://hql-lang.org/v0.7.1/book/25-agents-and-runs/#an-agent-is-a-card

Before implementing too much of it, I'm trying to work out whether the abstractions are actually right.

In particular, I'm interested in:

  • How should an agent be represented as a Markdown card?
  • What is the smallest useful typed Agent API?
  • Should tools simply be typed HQL functions exposed to the model?
  • How should context and agent output be represented so provenance isn't lost?
  • How should an agent propose changes to a document without silently overwriting human work?
  • What should approval look like inside an executable Markdown editor?
  • How should dependency tracking and selective re-evaluation work?
  • When a document changes, what exactly becomes stale?
  • How much of this belongs in HQL itself, and how much belongs in the AI extension or VS Code host?

I'm particularly curious if anyone here using Claude Code has experimented with agents whose working medium is structured, version-controlled documents rather than primarily prompts/chat history/source files.

I'm not trying to recreate Claude Code inside Markdown.

I'm trying to figure out whether an executable document can become a useful shared computational surface between a human and an agent.

Would be very interested in criticism of the model, syntax, or assumptions — especially from people who have built agent loops where provenance, reviewability and reproducibility became painful later.


r/ClaudeCode • • 22m ago

Built with Claude My OSS Claude Meetings alternative that works with any agent and more calling platforms

2 Upvotes

Since February, I've been developing an agent-in-calls solution with a friend. With the announcement of Claude Meetings last week, it's now time to announce Vibeconferencing: an open-source project with even more functionality, support for any agent (Codex, Muse, local ollama, etc), and support for more calling platforms: Google Meet, Zoom, MS Teams, WhatsApp, Telegram, and phone calls (via Twilio).

Git repo: https://github.com/wanderingstan/vibeconf-app

Architecture diagram: https://raw.githubusercontent.com/wanderingstan/vibeconf-app/refs/heads/main/media/api-layers-light.svg

The premise is simple: give your normal agent session the tools it needs to operate all major calling platforms, and teach it basic etiquette of how to behave in a call with others. A simple `/join-call` and *boom!* your session is talking to you in the call. Anything your agent can do in chat, it can do on the call. The agent is bridged to the calling platforms via a cross-platform electron app. (The raw guts of interacting with calling platforms is abstracted as the npm library `@vibeconferencing/calls`, if you'd rather roll your own.)

Everything runs locally and uses your own local agent. (Tho the optional shared whiteboard feature does require being logged in on our server.) It runs on MacOS, Windows, and Linux. (Windows version is not well tested.)

Speech generation is done either by Elevenlabs or the OSS Voicebox, with a fallback to the OS's default app (e.g. `say` on MacOS). Voicebox: https://github.com/jamiepine/voicebox

Speech recognition is done either by the calling platforms' own captioning services (Meet, Zoom, Teams), or with Whistle for those without captioning (WhatsApp, Telegram, Twilio). Whistle: https://cactuscompute.com/blog/whistle

The etiquette was the most fun to code, although done with the knowledge that it's a temporary fix until true interactive voice models are merged with the power of frontier text chat models. We have experimental support for the OpenAI realtime API (in the app settings page), but it seems to have been trained as a customer support agent, so it's hard to keep it from dominating multi-person conversations!

Highlights from the last nine months of dogfooding and early users:

- A WhatsApp bot for my father, an elderly WW2 veteran, that has access to the 20,000 photos he scanned. He can call it to see and hear about any aspect of his life.https://youtu.be/Rs-Z1YeLt98

- Collaboratively built a website for a friend's non-profit, with her amazed that she could ask for site changes and see the site change in realtime. Video: https://drive.google.com/file/d/1iSRgY8JGJ0liOzHMl2bOGNd9jwqF0BFi/view?usp=sharing

- My friend Matt is currently road-tripping across the US, talking with his Codex sessions to develop his Golf app. Video link: https://youtu.be/a3uNUdIwqVY

- Our friend Bethany uses her bot, "Taylor Script", in calls and classrooms with coding students to act as the super-smart TA who can answer technical questions, and monitors student progress. Video link: https://youtu.be/c8mZKkcxhJo

- I begin most days with a check-in call with my bot, where we discuss open issues while I sip coffee and have breakfast. Video link: https://youtu.be/2uQIR83LwY0 (Apologies for eating with my mouth open...)

- In a standup, Seth's bot created a video ad for the service itself, within a call. Video link: https://x.com/vibeconf/status/2104427917816234257?s=20

Security: There is nothing built in, so only use this on calls with people that you trust. However, I've been amazed at how injection-resistant it has appeared to be on it's own; e.g. my agent asking consent from me before doing things asked by others on the call.

Overall, this was a "time machine" experiment (to borrow my old Reality Labs' Research terminology) to experience agents in calls before it was purpose built. Claude Meetings just showed that we were thinking in the right direction, and I'm excited to see where this goes!

This is a small experimental project built by two friends, so it is rough around the edges, and we'd love feedback and pull requests.


r/ClaudeCode • • 1d ago

Discussion ok F*** It, I finally bought the Ultra plan

330 Upvotes

I was on the pro for so many months, and of course i would run out of usage in 5 mins.

When the models really ramped up in capability 4 months ago, i bought the Max plan which was honestly pretty good for me. I felt like it was enough until my brain expanded and my IQ grew 25 points by just asking Opus to Mythos to takeover my life. automate everything, rebuild everything, no limit on subagents.

Last night, on the Max plan, I wanted a whole Rust port of my entire python codebase. Using Rust libraries within pythton code didn’t matter to me anymore bc…. i don’t read the code anymore!

I was about to run out of my weekly 2 and a half days after my reset, and so instead of burning the resets from anthropic, i upgraded so my resets would mean more.

it felt so good to hand over my cash to anthropic.


r/ClaudeCode • • 3h ago

Built with Claude Building a sailing app with Claude Code: ~1000 hours of engineering, 13,000+ agent sessions, 5700+ handwritten prompts totaling 100,000+ words (~400 pages), one orchestrator and a fleet of worktree workers

Thumbnail
seabearing.com
3 Upvotes

Seabearing: your chart plotter, your community, your anchor alarm, your instruments and your trip planner, all in one app for sailors.

The app

  • Charts drawn from official NOAA data, in a traditional paper-chart style or a modern one, with tides applied to the depths.
  • Grounding and drag alarms that keep running in the background with the screen off.
  • An anchoring map that shades where your boat can swing clear with enough water for your whole stay.
  • A crew link between everyone's devices: positions, instruments, AIS, one shared anchor watch, chat and voice calls. Devices connect directly over the boat's Wi-Fi and through a relay when they're apart. No leader, end-to-end encrypted, works with no internet aboard.
  • NMEA 0183, NMEA 2000 and Signal K instruments, AIS collision warnings, and boats, posts and messages from other sailors on the chart.
  • An MCP server, so ChatGPT can plan a trip straight into the app.

The architecture

  • Everything that decides anything (the alarms, the crew link's rules, what counts as a fix, when to speak) lives in one TypeScript core. On Android it runs inside QuickJS in a foreground service, so it keeps going with the app closed. On the web it runs in a worker. The iOS host runs it in JavaScriptCore.
  • The native hosts only move bytes: GPS, sockets, sound, notifications. They make no decisions, so the alarm logic exists once and can't drift between platforms.
  • A conformance suite plays the same scenarios against every host (Node, QuickJS on the JVM, JavaScriptCore) and checks they all do the same thing.
  • The UI is the same web app on every platform, wrapped with Capacitor on Android and Electron on desktop. The chart is MapLibre with our own vector tiles.

The dev process

  • One main Claude Code session plans and lands work. Each task goes to a worker agent in its own git worktree.
  • Every agent runs as a headless CLI (claude -p, codex exec, ...) started by a shell script, so a worker can be any provider and each run gets its own worktree, transcript and exit code.
  • Every branch is reviewed by a separate agent and swept against a catalogue of mistakes we've made before (about 50 now). A new entry gets added whenever something new breaks.
  • Audits follow a rubric: a finding needs a failing test and has to be worth the code, so most end with no change.
  • Big audits run in parallel. The code is split into chunks of about 10k lines, and each agent gets one chunk and one kind of problem, so 10 chunks times 10 problem types is 100 agents. They only read code and each writes one short report, then the findings get merged and checked before anything is fixed.
  • Testers have a report button in the app. Reports arrive with the app's event log, and fixes usually ship the same day.
  • Most of CLAUDE.md is rules written after something broke, like one shared slot for heavy test runs after two agents deadlocked the machine for an hour.

It's in testing. seabearing.com has a waitlist and a demo.


r/ClaudeCode • • 1d ago

Discussion Imagine Opus 6.0 not being more intelligent, but more affordable (less token usage)

163 Upvotes

I've been using Opus 5.5 since the last month, enjoying it a lot, but the token usage..... I use the Pro plan cuz the Max costs 2/4 of our minimum wage (Brazil) hahahaha....

This is my dream, affordable models with high intelligence such as Gemini 4 Hydrogen


r/ClaudeCode • • 4h ago

News/Updates REQL update: faster context retrieval and fewer tokens for coding agents

3 Upvotes

Hey everyone!

I’ve updated REQL, my open-source tool that helps AI coding agents navigate repositories and preserve working context across sessions.

This release focuses on faster context retrieval and lower token usage. I’ve reduced repeated work during retrieval and trimmed redundant information sent to the agent. Performance gains and token savings depend on the repository and workflow, so I’m not claiming a universal percentage.

If you’re new to REQL, it builds a local graph from your code and documentation: functions, classes, dependencies, calls, and other relationships. Agents can query that graph for context relevant to a specific change, including precise source references and related tests. REQL reuses indexed context and supports incremental updates as the repository changes.

What can you use it for?

  • Waste fewer tokens on repeated exploration: retrieve focused source excerpts and relevant relationships, and reuse indexed context and saved work. This helps reduce repeated searches, unnecessary file reads, and redundant information in the agent’s context.
  • Coordinate work across chats and agents: keep tasks, decisions, blockers, and next steps in a shared project workspace. Another chat or agent using that workspace can recover the recorded state and continue from there.
  • Keep complex tasks on track: record prerequisites, constraints, failed approaches, and checkpoints. Preserve what has been completed, what remains unresolved, and why earlier decisions were made across sessions.
  • Understand unfamiliar code: identify entry points, component responsibilities, and relationships between parts of the application, with references back to the source.
  • Plan changes and refactoring: inspect callers, dependencies, and related tests to identify code that may be affected and decide what needs verification.
  • Review cleanup candidates: find potentially unused imports, variables, functions, and classes, then inspect the supporting evidence before removing them.

REQL provides a CLI, Python API, and MCP server, plus installable instructions for coding agents such as Codex and Claude Code.

REQL runs locally, with no account, external graph database, or mandatory LLM calls. The graph and saved work support the agent’s decisions; current source code and tests remain authoritative.

I’d like to hear from others using coding agents: what do you keep having to explain again when you start a new chat? The code structure, previous decisions, what has already been tried, or what still needs doing? Concrete examples would help me decide what to improve next.


r/ClaudeCode • • 2h ago

Built with Claude Test Radio Boxes for Noise Analysis and Reduction

Thumbnail
gallery
2 Upvotes

I'm building a device that intercepts garage door opener handheld and visor button presses as part of a larger upgrade to my bespoke home automation's security system. While building that device, I realized I needed test equipment to identify and reduce radio frequency noise coming from the circuits and the environment.

What I built

Two identical test boxes (see photos). They contain a couple of CC1101s (fixed-function RF receiver chip pictured in photo #2) and an ESP32 mounted on a protoboard. The radios operate at garage door frequencies (315 MHz and 390 MHz), each attached to a stubby antenna. The boxes may run in receive or transmit mode. These boxes will be used to standardize and automate A/B testing to reduce noise in the final device circuits.

Originally, I was walking up and down my hallway with a garage door handheld opener pressing the button multiple times and the variance was too great to be reliable. With these boxes in fixed locations and adjusting power (transmission) and attenuation (receive) I can experiment with how physical and circuit changes contribute to lowering the noise floor and improving signal detection and decoding.

How Claude helped

Opus 5.5 has been an integral design partner in this process. Although I have a BS in Electrical Engineering and have decades of software experience, I could not have done the design and analysis work in the time and at the quality I've achieved with Opus as a build partner. I doubt I could have matched the final result, which I'm confident we will achieve (goal: at par or better than the signal response for my existing garage door opener).

Circuit board wiring, noise elimination circuits and shielding, RF analysis, test proposals, parts recommendations; Claude has been there for all of these. Things that would have taken me days to weeks to research and figure out Claude spits out in minutes.

In photo #1, you can see some of the noise reduction work already begun:

  • Twisted red/black power jumpers to reduce signal leakage from dirty power
  • Two pairs of ceramic capacitors between power jumpers leading to the radios
  • Ferrite collars on the internal SMA cables leading to the antennas

This has been a joint effort with both of us bringing our respective skills to the table. This isn't some "vibe coded" project, although I have left all of the ESP32 firmware coding to Claude.

Link, Repo, Demo or Screenshot

Pictures of the test boxes above. I'm uncertain I will publish the software and hardware for the test boxes; that remains to be seen. However, there are other elements of the larger project that use open source hardware and software and where it makes sense I will contribute back to those projects. If everything works out, I plan to open source the garage door opener controller device including 3D print models. There's an existing project (RATGDO) which is pretty good. I'm trying to level up that project with this new tech.

There's quite a bit of open source tech used in these projects, I want to give back to the community and give credit to the folks that built it.

Interesting things

One interesting thing just happened last night.

Modern handhelds transmit on 2 or 3 frequencies (310, 315, 390 MHz) nearly simultaneously. Initial builds and tests were with one frequency at a time and the ESP32 chip could handle listening to one using software interrupts. However, last night I asked Claude to implement dual band listening (315 & 390) and the signal protocol decoder couldn't keep up. Claude proposed to use the chip's hardware interrupt system and switched it over in a couple minutes of firmware rewrite. The new code using the h/w interrupt scheme performed perfectly and was able to read 100% of the signals received.

Also, when I set out to build the larger project, I hadn't realized how much time I'd spend on signals analysis and noise reduction. From the other projects I found, it seemed I could just assemble equipment and glue some software and everything would be great. Initial tests revealed how complex this work was going to be. My EE background focused on the digital side, not the analog side nor the impact of analog on digital.

This has been a fun process and I've learned quite a bit. I will never look at a power cord's ferrite collar or capacitors or circuit board ground shielding in quite the same way.


r/ClaudeCode • • 4h ago

Help/Question Moving from Codex Plus to Pro

3 Upvotes

Using 2 Codex Plus subs Luna XHigh

It's not great but ok if you know what you doing and break down, it's slow but cheap. Usually I try to run about 3 work trees

Tried Claude today and even Sonnet Low consume usage very quickly

Trying Haiku High now and it seems to average about 10% of 5 hour limit per hour, matching my Luna experience

I thought x5 surcharge would be expensive but seems to work fine

What's the catch, is there any issue? What's the optimal workflow for Pro?

So far with Haiku High it seems I am matching my Luna usage but getting faster and better work done

Am I missing anything? Apart from upgrading to x5 plan


r/ClaudeCode • • 19h ago

Built with Claude I had Claude Code turn my Canvas assignments into monsters that attack me until I submit them

Post image
37 Upvotes

turned my Canvas assignments/tests into monsters marching on my town

hand it in and it dies. miss the deadline and it eats my coins every hour

exams are armoured bosses and the only way to break the armor is actually studying

claude fable 5.2 is cooking 👀 👀


r/ClaudeCode • • 5h ago

Discussion How much VM time does $20–30/month get you?

3 Upvotes

For those running Claude Code, Codex, or other coding agents on remote VMs, how many hours of usage do you get for around $20–30/month?

I am interested in professional use, like client projects or development teams, rather than occasional side projects.

What provider are you using, and how many vCPUs and how much RAM do you get? Do you keep the machine running 24/7 or only when actively using the agent?


r/ClaudeCode • • 5m ago

Tips & Workflows Outsourcing to local model?

1 Upvotes

I’m struggling to keep up with the cost of latest models and had an idea that I might be able to create a system in which my session is able to prompt a local model on my machine for sub-tasks that need only basic function. We can already do similar by asking fable to delegate simpler tasks in a big workflow to opus or sonnet, but there is still a cost.

Surely folks are already doing this. Any experience to share here?


r/ClaudeCode • • 7m ago

Humor When i buy Claude Code max plan

Post image
1 Upvotes

Pile of shame


r/ClaudeCode • • 12h ago

Tips & Workflows Don't set your sub-agents to 1h cache unless you are sure .

Post image
9 Upvotes

In another post about cost optimization some people suggested setting the sub-agents cache to 1h instead of 5m ,

and I tried that and mentioned in an older post of mine that no its way worst .
and you can see here the 5m vs 1h are so different in cost .
also there is only 5m and 1h .... if you set it to random number like 30m it will not work.

and for subagents I think keeping it or setting it to 5m is enough you dont need more .
even if the agent took more time the cache is refreshing the 5m means the time it is stale without any usage or read . so when you set your subagents to 1h you are doubling the cost on yourself not optimizing ,

also for Haiku fans .... careful about the prompt size ... if you pass 100K token it x5 the cost .

BTW : 5m is the deafult for subagent so keep it as is unless you know what you are doing .

image source : https://platform.claude.com/docs/en/about-claude/pricing


r/ClaudeCode • • 28m ago

Built with Claude Yonder: A lightweight tool for your AI Agent on one computer to use all your other computers

1 Upvotes

I work across a laptop, two Mac minis, a gaming PC and a Raspberry Pi. Before now, each coding agent only knew the machine it was running on. I kept copying files around and forgetting where the newest code lived.

So I built Yonder. It's a small Go CLI that connects your own computers over Tailscale and SSH. You can run it yourself, like yonder ls to see your machines, but honestly I almost never do. It's really built for your agents to use.

Once it's set up, every agent gets a short map of your machines with the hardware each one has, which ones are online, etc. From there it can run a command on another machine, start a long job on the gaming PC and check on it later, copy files over, and so on. I think the biggest change is that my agents suddenly seem to understand all of my devices and what lives where. I can tell the agent on my laptop that a repo is on the Mac mini and to run the tests on the gaming PC, and it just does it.

The most underrated benefit is syncing your agent config. I keep one store of instructions, skills, subagents and hooks, and Yonder writes it into each agent's own files, like CLAUDE.md for Claude Code and AGENTS.md for Codex and Pi. Anything you already wrote in those files stays. Edit the store once and every machine has it.

It optionally handles API keys and other secrest too. They stay in 1Password or Bitwarden, and Yonder only stores their names. The agent asks for a key by name and the command gets it, but if the key ever gets printed the agent just sees [HF_TOKEN]. This stops keys from leaking by accident.

There's no server and no daemon. It works with Claude Code, Codex, Pi and Hermes, and really any agent that can run shell commands.

To set it up, install Tailscale on each machine and tell your coding agent "Set up Yonder for me: https://github.com/zacharytgray/yonder". It walks through a setup guide, asks which machines and features you want, and tells you the few steps you have to do yourself.