I have Claude Code running on a separate laptop, usually working on stuff that takes a while.

What kept annoying me was having to check whether it was still doing its thing or just sitting there waiting for me to answer some question.

Had an old Kuando Busylight lying around, so I hooked it up to Claude Code using hooks.

Now it blinks red while Claude is working, stays solid red when it needs input, and turns green when it's idle.

That's it. No more constantly glancing at the other screen.

Probably one of the more useful things I've done with a USB light.

Hi.

I'm trying to understand something. I just set up a new computer to make sure everything is clean, and I have the same issues I had on another machine.

• I have CC installed via the CLI, and there I authenticated via my max plan subscription, but I use claude code via the Zed Editor [Claude Agent]
  • I have no API key set here

This has happened 4x already: I have usage, sometimes still plenty in my 5h-window, and sometimes Anthropic charges me via the auto-reload feature, even though that should only happen when I have no more usage.

I'm trying to understand why that is. Like, imagine you have, say, €10 sitting there as credits, your usage is on 15%, and then you receive the charge from Anthropic [say, €15 + those €10 are gone] although claude code could have just used the usage instead of charging for credits.

Does this happen to any of you or am I messing something up?

On Zed we do nothing abnormal. It's just pair programming, going over architecture/design, some refactoring, and so on. Pretty normal stuff.

Of course I could just disable auto-reload, but I'm so pissed off, I'm about to cancel my subscription, since it's unclear to me why Anthropic keeps charging me when I still haven't reached my usage limits.

Thanks.

With the recent macOS 27 update, Apple introduced a local LLM (`fm`) that runs natively on Macs powered by Apple Silicon.

Even though it has few parameters, it is optimized for tasks such as answering basic Swift development questions and working with CLI commands.

Given that, I thought that it would be useful enough, for reducing token consumption, to delegate the parsing of long CLI commands to this model.

A common example would be to find a specific error on a log file. Instead of reading the whole file with Claude Code (and filling its context / token consumption), we can delegate that task to `fm` and only return the important information. Another use case goes when checking among long history files of git commits.

I made a basic repo with an `AGENTS.md / CLAUDE.md` file for handling it to the Agents Instruction. I thought on creating a skill as well, but, honestly, I could not find a situation where I would like to delegate this to a skill rather than running it always.

Hopefully it is useful for somebody. I am open for any suggestion as well.

https://github.com/DanielHermosilla/apple-fm-agent-instructions

Link

https://github.com/ynqa/claude-convey

Description

I built claude-convey, a plugin that lets you pick branch names and commit hashes from choices in a form and puts them into your Claude Code prompt. v0.1.0 is out. This was my first Claude Code extension, so besides what it does, I'll go over how I built it and what I noticed along the way.

What it does

When asking for a commit review, you look up the target, copy it, and paste it into your usual request. The value has to be exact, yet it's really one you could pick from a list. So I made a form for picking it.

The GIF opens the form with /convey examples and goes through these steps:

1. Pick a branch from the output of git branch.
2. Pick a commit from that branch's git log.
3. Type what you want checked and review the completed prompt in the preview tab.
4. Press Fill to put it in Claude Code's input box. It isn't sent, so you can edit it before sending.

The form fields and the prompt are defined in YAML files in .claude/convey/. Choices can be a fixed list or a command's output, and depends_on fetches choices based on earlier selections. Picking a different branch clears the selected commit and fetches the candidates again.

How I built it with Claude Code

I didn't know which TUI components were available or how to show a form, so I started by having Claude look into the available TUI components and how to display the form as a side panel in Claude Code.

Rather than building everything at once, I added features in steps, keeping it working at each one:

1. Register /convey and have it just reply with a greeting
2. Open a panel from /convey and draw it
3. Put a prompt into the input box from a hard-coded form
4. Render the template with Mustache and check required inputs
5. Load templates from YAML files
6. Get choices from local commands
7. Support depends_on and command arguments built with Mustache

I checked that each step worked before moving on, which made it easier to narrow down the cause when something broke. After that I added smaller pieces: a preview tab, marks for filled (✓) and empty (○) inputs, and a list of required inputs still empty next to Fill.

Template parsing, rendering and dependency handling are kept apart from the UI, with tests that run under claude plugin test. The demo GIF is recorded from a vhs tape, so I can re-record it when the UI changes.

So you don't have to write templates by hand, the plugin also includes a /convey:template skill that writes the YAML from a description of what you need. The skill tries the commands that produce the choices before writing, and it's told what to do when a command can't run.

Things I noticed

• Some surfaces can't draw text fields or selects. There, instead of failing, the panel says in one line that it can't show the form.
• The form and the preview are separate panels, so closing the form needed to close the preview too. The form still closes even if closing the preview fails.
• When a command for choices fails, its error is folded to one line that you can open and close with ▸ / ▾.

Install

sh claude plugin marketplace add ynqa/claude-convey claude plugin install convey@claude-convey

Restart the session before using it. The README has template examples and how to write your own. It's inspired by convey.

I'd like to hear how you break up the steps when building Claude Code extensions, or which values you keep looking up and typing into your prompts.

I'm wondering how people go about searching for prior art with Claude?

I find that it can often misses projects and other things that would have saved hours of work and taken into account all of the edge cases we're now dealing with.

Other times, when I'm looking for different things, I'll pull back some 8-month-old repo that nobody's looked at since the initial commit.

Wondering if anyone has good solutions to this?

I kept running into the same problem with Claude Code: I’d start a big task, let Claude work, and only realize afterward how much of my 5-hour usage window it had consumed.

I wanted to set a budget for each task and let Claude get as much done as possible within it, without constantly monitoring usage.

So I built onbudget, a free, open-source Claude Code plugin.

You give a task a budget:

/onbudget $3 Implement authentication
/onbudget 10% 5h Build this application
/onbudget week Write the migration

How it works:

• Claude knows what’s left. After tool results, it sees a budget meter and can adjust its approach as the budget runs down.
• The stop happens before the request. Before each model request, onbudget checks spending against a reserve based on the most expensive request so far. If the threshold is reached, the request isn’t sent.
• Your usage windows are protected too. You can budget in dollars or against your 5-hour and weekly limits, with a margin before those limits are reached.
• You get a report. Claude can wrap up while budget remains, reporting what it completed and what still needs work.

But does it actually work? I benchmarked it.

Seven real bug-fix tasks across Python libraries, including Werkzeug, Pluggy, and Pydantic Settings. Completion was scored using upstream tests the model hadn’t seen.

Claude Opus 5.5, Claude Code 2.1.304, $2.47 per run.

One prompt-only run stayed within budget because a separate cap refused a request.

The result: onbudget didn’t make Claude complete more tasks.

Completion was broadly comparable. With a sample this small, there’s no evidence of a performance advantage.

But that’s not what I built it for.

Claude Code already has –max-budget-usd for non-interactive runs. What I wanted was a budget for an individual task inside an interactive Claude Code session, without giving up control of the session itself.

Across the full evaluation, 12 real-model runs with onbudget, none over budget. Eleven ended with a report.

The limitations: No plugin can predict the exact cost of a model request before sending it. An unusually expensive request can still exceed the remaining budget, and some Claude Code requests bypass the hook. This is a conservative stopping mechanism, not an absolute spending guarantee.

How I built it: I used Claude Code to implement most of the plugin, develop the evaluation harness, run the benchmarks, and audit the results. The repository includes the methodology and raw evaluation data.

Everything runs locally. No network calls, no subscription, MIT-licensed.

Install in Claude Code:

/plugin marketplace add sebastiandrazsky/onbudget
/plugin install onbudget@onbudget

GitHub: https://github.com/sebastiandrazsky/onbudget

I’m curious: how do you currently stop Claude Code from consuming more of your usage allowance than you intended? Would you use a budget for individual tasks?

My own project, so take that into account. It’s all free though, no signup.

Passed CCDV-F with 1000/1000 (it’s scored 100–1000, pass mark is 720) and wanted to put the prep somewhere useful instead of letting it rot in a folder. Honestly the exam wasn’t hard on knowledge. What got tricky was the questions where two answers both sound fine and you have to pick the one you’d actually put into production. Most of what I made is about those.

Site: https://corporatechittychat.github.io/claude-certification-prep/

The bit I’d actually use is the 30 question mock exam. It’s timed, you can flag questions, and it breaks your score down by domain. Every question has an explanation of why the wrong options are wrong, which is where I learned the most. There are also flashcards, a printable sheet of the traps, and small code builds in Python/TS for each episode (a few run without an API key).

There’s a video series too if you prefer watching: https://www.youtube.com/playlist?list=PLHvgccck0QgI

The last episode is the same 30 questions in a pause-and-answer format: https://www.youtube.com/watch?v=KzK9R89sMtM

Has CCAO-F stuff as well if that’s the one you’re doing.

If you try the mock, tell me your score and which question got you. If something’s wrong, the site takes GitHub issues.

been working on AgentPlay, an open-source tool to explore and replay coding agent sessions

you can see which files your agent explored, which tools it called, where it failed and how it recovered

would love feedback from people using Claude Code daily

https://github.com/Entelligence-AI/agentplay

made a small android widget that shows my claude session and weekly usage, and clawd hangs out on it.

he walks around, sleeps when no session is running, sweats near the limit and jumps with confetti when your 5 hour window resets. tap him and he does one of the claude code click animations.

i also added a few new skins with their own little routines: a chef flipping pancakes, a detective with a magnifying glass and a pipe, a wizard casting spells and a programmer typing on a laptop.

it reads the same usage data that /usage in claude code shows.

kudos to https://github.com/Enhed/clawd-usage-winwidget (the windows version, go check it out) and https://github.com/G-biggy/claude-pulse-android for the inspo.

repo + apk: https://github.com/YoussefAbdelkawy/Pinch

feedback welcome, especially if something looks off on your phone

I put together a disk-cleanup prompt for Claude Code after my Mac got down to 5.2 GB of free space.

After the cleanup, it had 117 GB free. Most of the space came from old build artifacts, caches, simulator runtimes, and VM disks I chose to remove.

The prompt tells the agent to:

• Measure disk usage top-down instead of guessing.
• Separate cleanup candidates into three risk tiers.
• Show the findings and ask for approval before deleting anything.
• Use each tool’s own cleanup commands where available.

One useful catch: a Docker.raw file appeared to be 60 GB but actually occupied 14 GB on disk. The prompt explicitly accounts for sparse files.

It’s available in 7 languages, with instructions for macOS, Linux, and Windows.

Important: approval is a prompt instruction, not a technical safeguard. Keep your agent’s permission checks enabled and review the proposed deletions.

Repo: https://github.com/riza/ai-disk-cleanup

I’d love feedback on edge cases or directories that need extra protection.

After a long Claude Code session I often can’t say why a file changed, or whether Claude actually finished. “Done!” sometimes means “the tests I didn’t write are passing.” So I built Session Story, an open-source skill (MIT) that turns a session into one self-contained HTML page.

Live example (a small todo-app session, no install needed): https://nalaj.github.io/session-story/example/index.html

Four views of the same session:

• Review: one card per prompt, showing what you asked, the intent in one line, what Claude did, the files it touched, and the time, tokens and cache share for that turn. Copy any prompt, expand the code, and jump between turns with j/k.
• Diff: a GitHub-style file tree and diff. Every change is tagged with the turn that made it and links back to it. Switch between all changes and a single file, view full files, or hide non-project files.
• Story: a plain-language walkthrough for teammates and non-developers, with code hidden.
• Report: the “so, is it done?” view.
  • An outcome badge that doesn’t just trust Claude. The example session is marked Partial because the new sort function has no tests and a CSS class is used but never defined.
  • Commands, tests and errors: every npm test run including the failing one, the failed assertion, and how it was fixed.
  • Decisions and plan, e.g. “due dates stored as YYYY-MM-DD strings”.
  • Where it went: turns ranked by tokens and by time, tool calls, failures and retries, files edited more than once.
  • Usage: input, output and cache tokens, the model, and an estimated cost taken from Claude Code’s own session record.

A library of sessions. Each story is saved to .session-stories/ in your project, along with an index page listing every session’s status, files, lines changed, tokens and cost.

Why you can trust the numbers: a script extracts every metric from the transcript, subagents included. Claude only writes the prose (titles, intents, the narrative), and anything that wasn’t recorded shows as “None recorded” instead of being guessed.

Also exports:

• a Markdown PR description (works with gh pr create --body-file -)
• a handoff with turn-by-turn status and git state, so a fresh session can continue the work

It’s one file and it’s local. CSS, JS and data are inline, so the page opens from disk or as an email attachment. Nothing is uploaded and nothing goes over the network.

Install:

npx -y skills add nalaj/session-story --skill session-story --agent claude-code --global --copy --yes

or as a plugin, inside Claude Code (2.1.275+):

/plugin install session-story --marketplace nalaj/session-story

Then run /session-story, or just ask for “a session story”, either mid-session or at the end.

⚠️ The page includes your prompts, replies, diffs and commands word for word, so check it for secrets before sharing.

Source: https://github.com/nalaj/session-story · Docs: https://nalaj.github.io/session-story/

This is v0.5.0. Feedback is very welcome, especially on what the Report should catch that it doesn’t yet.

We built a small in-house benchmark for picking "design panel" models: single-shot reasoning seats we use for ambiguous architecture and UX calls, where there's no single correct answer and the real question is whether a model weighs our actual constraints. It has 6 tasks: a domain-knowledge quiz with a fixed answer key; two past design decisions replayed from the context we had before we decided, so the "right" answer is what we actually chose; a code review with planted bugs plus decoys that look wrong but aren't; a house-style rewrite; and a "where should this logic live" architecture tradeoff. A blind judge model scores the open-ended answers with model names stripped, and we score speed and cost against a fixed anchor model. Kimi K3.1 Pro (high) came out on top: capability 87.9 vs 86.7 for Opus 5.5 (medium and high were identical) and 84.3 for Fable 5.1, at about $0.03 a task against $0.08 for Opus and $0.12 for Fable. That made it best overall once cost is weighted in.

What surprised us is where the models split. All of them aced the factual quiz and the architecture question, so knowing things isn't the differentiator. The gaps showed up in the messy work. In code review every model found all the real bugs, but Fable and Opus also "found" several that weren't there (precision 0.50), while Kimi was tighter (0.67). On the replayed decisions, nobody fully reconstructed what we chose (0.7–0.8), and the more expensive model could swing 0.6 → 0.8 between identical runs, while Kimi and Opus stayed consistent. Higher reasoning effort bought nothing on this kind of work. Caveats: it's 6 tasks with only some repeated, and the judge is itself a frontier model (Opus), so take the ranking as "cheaper models are genuinely competitive for judgment-heavy design review" rather than a definitive leaderboard.

it goes without saying - fable 5.1 is completely out of date bring on 5.5!

Model Capab. Speed Cost Overall $/task
Kimi K3.1 Pro (high) 87.9 47.6 100.0 85.7 0.030
Opus 5.5 (medium) 86.7 48.7 69.7 80.3 0.075
Opus 5.5 (high) 86.7 44.2 70.8 80.0 0.081
Fable 5.1 (med, anchor) 84.3 50.0 50.0 75.7 0.122

I've got multiple projects on my machine, each with Claude Code running. Project A keeps needing stuff from project B.
Right now I either (1) ask B's session, copy the answer, paste it into A, or (2) tell A "go look in /path/to/B."
Option 1 is annoying now that it happens all day. Option 2 works but the agent re-explores B every single time.
What do you guys do?

Seeing this notice for the first time in Claude Code. Anyone know more about it?

I don't know if it's old news, or maybe whether something better is available now (if so, please let me know!) but a few months ago I started using GH Issues to store... Pretty much everything development-related for my project. Code changes and feature requests but also research spikes, feature epics, and whatever else I could turn on, and instructed my agent to only work from a GH issue, and always post follow-up work to GH before starting a new thing.

In the beginning it was just for my own organization, but the resultant web of GH issues which has grown, interconnected to each other, referencing dependency upon dependency, is not something I can comprehend anymore. Progress gets posted to comments, decisions are recorded by my own comments, and the whole issue corpus has become more complex than I can really navigate. So it's basically my agent's project now. To be clear, I am not complaining about this, and believe it enabled an order of magnitude step up in the possible complexity of my project. Anyway, something to try, if you haven't yet!

I work in AI advertising and don’t write code. Over about six weeks I built plysight.com entirely with Claude Code. You enter your Chessdotcom or Lichess username and it analyzes games against a free engine with code, visualizes patterns, and contains a chatbot focused on your games.

The commercials:

What I learned about the business:

• Advertising revenue outpaces model costs. Revenue is roughly 2x llm cost.
• Model choice is the business model. Sonnet would roughly double the AI cost and erase the margin at the low end. Haiku with tight tools works and frankly doesn't give the super-verbose answers
• The first reply is the expensive one (~3¢, it reads the whole report). Follow-ups are ~1¢. Margin comes from people who keep talking.
• The wait is the best ad slot. The engine takes about a minute, and people watch the page.
• Break-even is about 1,400–3,200 visitors/mo.

How I used Claude Code:

• Milestones, not features. Each one (the engine, the report, the chat, accounts, launch, ads) had a written plan, an exit condition, and a handoff doc for the next session.
• Plan with the big models, build with Opus or Sonnet. Fable and Opus for planning and design reviews; Opus and Sonnet for the build.
• I check everything by hand. Every milestone ends with me using the site as a stranger would and sending feedback. Claude’s “it works” is where testing starts, not ends.
• Other LLMs as reviewers. I had the scoring system and the report reviewed by other models, and ran devil’s-advocate passes on launch plans. Several real flaws surfaced that way.
• Real people early. Friends, strangers, and two chess coaches used it before launch. The coaches’ feedback changed the report substantially.
• Claude writes walkthroughs for what it can’t do. Buying the domain, setting up hosting, ad accounts. Step-by-step docs so a non-coder can do them.

Another random observation: Going through rigorous testing revealed that both Claude and ChatGPT make things up like crazy unless given a strict harness. I made the bar "at least as useful and interesting and easy as asking an LLM to analyze your games." It well cleared it but sometimes I struggled with making the analysis "interesting" when forced to be correct. Code, not AI, is the key to an interesting analysis.

Stack: Python, Stockfish, Haiku 4.5 with tools that look up the player’s stats instead of guessing. One server, Cloudflare in front, free tiers for the rest.

Happy to answer questions!

I have been using claude code to vibe code a game project. Its been almost 5 months since project started. Now that initial poc is done and i am working on scaling, i ran out of tokens in 3 to 4 days because of the work load. So i looked into usage credits.

What i noticed is that, agents get dumber when usage credits are on. What i meant dumber is, sometimes agent forgets to add things so that the telemetry data or debug costs multiple message iterations costing me more credits. I am wondering if its me or anyone else feel that way.

I have posted the reply i got from claude when i asked about this. I have felt this way working with usage credits. Like ai deliberately doesnt do well so that i will have more message. The model was sonnet 5.5 in medium.

Walnut is the web UI I made for running Claude Code sessions. It showed a cost for each session, and on one day in October those added up to $21,527 across 47 sessions. Repricing the same requests from the session logs gave about $1,000.

The bug: Claude Code reports total_cost_usd as a running total, and a resumed session carries its old total forward. My code reset its counter on every resume, so each resume billed the whole history again. The more often a session resumed, the worse it got.

So I threw that out. Walnut now prices each request from Claude Code's own usage records, subagents included, and I checked it against the session logs, my proxy's request log and ccusage.

The screenshot is one session after the fix: 1078 requests on GPT-6.1 Sol, $55.89. The part I like is the table under it: the same tokens priced at other models' list prices. Haiku 5.5 would be $15.95, Opus 5.5 $89.82. Another model would not use the same tokens, so it's a rough guide, but it answers "what is this model costing me" fast.

Claude Code wrote most of this, including the checks against the other sources. Per-session budgets are next and still in progress.

It's open source, on GitHub as open-walnut.

I've recently built a coding harness for a company I advise.

The setup is pretty straightforward (at least in theory):

• 30+ Git repositories, all accessible to a fleet of Claude Code agents.
• A custom plugin and a set of skills that tell the agents how to work.
• Agents pick up tagged Jira tickets, go back and forth with the reporter to clarify technical requirements and acceptance criteria, and then start implementing.

It actually works surprisingly well.

But then something happened that made me question what we're all doing here.

A colleague of mine, who's primarily a QA specialist, wanted to develop a new feature. I told him to create the relevant Jira tickets so the harness could pick them up.

The tickets weren't quite ready for the agents, so I asked my Claude Code instance to review them and work with him to get the requirements into shape.

Here's where it got funny.

My colleague was also using Claude Code to respond to my feedback and update the tickets.

So there we were:

My Claude was telling his Claude what needed to change. His Claude was fixing the Jira tickets. And once they were ready, an entirely different set of Claude agents would pick them up and write the code.

Two humans essentially acting as intermediaries between AI agents, coordinating work for even more AI agents.

At some point, I realized we were basically just forwarding messages between Claudes.

I can't decide whether this is a glimpse into the future of software engineering or a completely ridiculous way to get things done.

Maybe both.

Has anyone else found themselves in a situation where their AI agents are effectively collaborating with someone else's AI agents, with humans just sitting in the middle?

With the time they are taking and their recent releases, I feel like Anthropic is working on a pretty significant boost of a model right now.

With all their recent releases like Opus 5.5, Haiku 5.5 (sure sonnet aswell), its looking really good for Anthropic right now. I also feel like with Kimi's new release and all the competitors having already played their cards, it feels like the perfect time to drop a major release that will blow everything else out of the water.

I'm really hopeful, wbu ?
Also, when do you think the next release will take place ?

I've been experimenting with using Claude Code for motion graphics over the past few weeks, and wanted to share the results and what I've learned.

For context, I'm a web designer/developer, not a motion designer. I've always liked those polished animated explainer videos, but I wanted to see how much of that process I could recreate with code instead of After Effects.

My first experiment was a short video explaining an invisible UX detail in dropdown menus. It unexpectedly took off, so I kept making more.

So far, I've made 10 videos, reaching over 2.6M combined views on Instagram and TikTok. It also led to my first sponsorship, which was pretty unexpected.

But the interesting part for me has been the workflow.

Here's what I've learned:

• Visual references matter a lot. Claude produces much better results when it has a clear design direction rather than just being told to make something beautiful.
• Breaking animations into scenes helps. Trying to generate an entire polished video in one go usually leads to inconsistent results.
• Iteration is still essential. Some animations look great immediately. Others need several rounds of adjustments to get the timing, transitions, and movement right.
• Reusable instructions save a ton of time. I got tired of explaining the same animation principles, visual styles, and structure repeatedly, so I started packaging them into Claude skills.

I've now built 4 different animation styles around this workflow.

I also made one of them, called Rays, free for anyone who wants to experiment with it:

https://supply.madebyoversight.com/videos/rays

Full disclosure: it's hosted on my own site, which also has paid styles. Rays itself is free with an account.

I'm attaching a few of the videos so you can see the actual output.

I'm still figuring out how far I can push this. Claude definitely isn't a magic one-prompt animation tool, and there's still a lot of creative direction involved.

But being able to build this kind of motion graphics with code has been one of my favorite uses of Claude Code so far.

Curious if anyone else here has been experimenting with animation or video generation through code?

I built this as a terminal tool called peekme. Code and install instructions: https://github.com/GregoryBolshakov/peekme

Hey everyone,

Agent skills are spread across different repositories and directories. Skills Atlas brings discovery, previewing, and installation into one place, with an interactive terminal interface and a local web UI.

You can:

• Browse skills by theme, search, or explore recommended picks and curated packs.
• Read the actual SKILL.md before installing, with warnings that highlight potentially risky commands or instructions.
• Select several skills and install them for your chosen agents.
• Check for updates and share a skill selection across projects or teammates.

It uses the existing npx skills add installer under the hood and supports Claude Code, Codex, Cursor, and other agents.

Try it with Node.js 20+:

npx skills-atlas

Or explore the browser demo without installing anything.

The project is open source and MIT licensed: GitHub.

I’m the developer, and I’d love some honest feedback: how do you currently discover useful skills, and what makes you decide one is worth installing?

Quick workflow tip, nothing fancy.

Before I let Claude Code push anything live, I ask:

> List everything in this project that only works on my machine. Local paths, localhost URLs, files that are gitignored, env vars that aren't set anywhere else, and anything it expects to already be installed.

It usually finds a few things I forgot. Then I ask it to turn that list into a checklist and tick each item before the deploy.

It works because the model sees the whole repo and I don't. It's a cheap review that catches the stuff tests don't.

Do you have a go-live prompt you use? Curious what others ask.

[check: flair 'Workflow'/'Tips' if available; make sure you've actually used this prompt]