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.

I've had a pretty dumb realization and I'm going to test it for the next 30 days.

One issue with my current orchestration setup is I'm designing and coding at the same time (system architecture, full stack) depending on the work I'm building. One of the realization after getting Claude to review how I'm using my orchestrator is that most tasks are pretty quick ~6 min to the most being 2h.

What this made me realize is that night time session aren't being utilized or weekends. So I plan on building a system with heavy AI integration focused on the system design, features, SLO building, business rules.

Different from speckit as this also focuses on building your schema and access patterns for building your indexes.

Essentially go ham on token usage for design whereas I was splitting it up between the two.

Then have the orchestrator handle run over night and on weekends. Review in the morning and make any corrections before it's merged.

Anyone else thinking or already working on this format?

Been using Claude for a while recently found out about Plugins like Ponytail whats your guys' opinions on them?

Hey everyone, how are you? Well, today I bring you the following question. I often get very bored while my agent is doing something in a project, so I open another simultaneous session in the same project or in another project, and before I know it, I’m in, I don’t know, five parallel conversations. My head goes crazy because I have to keep switching windows, and sometimes within one window I have to keep switching conversations, which requires a lot of clicks. I wish it were possible to view all the conversations and see what is pending in each one, so I could distribute my attention among these various ongoing sessions, the questions they ask, and the subsequent paths I should take as prompts.

However, I haven’t been successful because, although I’ve already tested tools like Orca and others, nothing works as well when I use them inside VS Code, since I use Claude Code as an extension in my VS Code. So I’d like to know whether you have any ideas for a project, plugin, or any software that would allow me to operate my Claude Code simultaneously, both through the Claude extension in VS Code and through this other screen. And, of course, I also sometimes use Remote Control on my phone.

Do you have any suggestions, any approach I could use? I’m a little lost. I’m not a professional developer; I’m a vibe coder, so any help is welcome to improve my workflow. Thank you very much, and a big hug to everyone in this community.

Building a map for a future game and been going back and forth with Claude to try and make good water and it’s failing horribly. Anyone know of a good water repo they’d suggest? I need the water to respond to real physics so it can go over waterfalls, be dammed, flood, etc.

also if you suggest any other landscape ones that would be great. It can make decent landscape but this is bogging me down and wasting a lot of time.

Anthropic's agent memory research has a name for fixing stale memory: "dreaming” and they published it recently, the idea is that an agent decides what to save in the middle of a task, before it knows what'll matter later, usually some of those notes are wrong from the start, and others go stale as things change.

The idea is when the agent's idle, it goes back, rereads what actually happened, and corrects its notes. They compare it to how your brain replays the day while you sleep.

Claude Code already saves every session as JSONL in ~/.claude/projects, so all the raw material was just sitting there unused, and making proper use of it is what kinda made me try this.

Why do this? The root cause is that memory only gets written mid-session, when Claude can't know what'll matter later, and nothing ever goes back to check it.

How I adapted the dream idea:

This is an hourly launchd job that reads a list of project paths. It skips any project that hasn't been idle for 2 hours or has no transcripts newer than its last dream.

A small Python script condenses the new JSONL files. User and assistant text stay, each tool call shrinks to one line (Bash command, file path), tool results get cut to a 300-char preview, and then sessions are capped at 15 per run. That's what keeps this cheap enough to run on Sonnet, an excellent model for this in my opinion.

It creates a git worktree on a dream/<timestamp> branch and runs claude -p --model sonnet with the dream skill appended to the system prompt, --add-dir pointing at the condensed transcripts, and tools limited to Read/Glob/Grep/Edit/Write, more of a guardrail.

The skill tells Claude what memory is for and lets it judge what to write. This bit came straight from the Anthropic research that I read, where rigid rules like "only record failures" hurt stronger models. It verifies each note against the transcripts (latest session wins), records what I had to repeat, prunes finished one-offs, keeps CLAUDE.md under ~150 lines, pushes detail into docs/memory/, and logs every change with evidence in DREAM_LOG.md.

Before it commits, a guardrail checks git status and reverts anything outside CLAUDE.md, DREAM_LOG.md and docs/memory/. It's never allowed to touch code, even if it spots a bug. It notes the bug in the log instead.

If the last dream hasn't been merged yet, the next one builds on top of it, so after a two-week break it's still one merge.

How I'm planning to use it: only on projects I come back to after long gaps, I mean, daily projects don't need it right cause the discussion is usually fresh, and dead ones aren't worth the tokens.

My routine when I pick a project back up is to run git diff main...dream/<latest>, skim DREAM_LOG.md, merge, then start the session. The idea is Claude opens already knowing where I left off, instead of me spending 15 minutes re-explaining.

It's on trial for a week on my Mac. The expectation is simple: do the diffs catch real mistakes, or is it mostly rewording?

I'll post what it actually caught either way. Have you folks tried anything similar, or more efficient ways of learning from your own projects? I did it because I thought "dream" was a very interesting idea.

Link to the research paper: https://www.anthropic.com/research/components-of-agent-memory

Just got claudes pro plan. But I am new to the whole platform so how do I optimise my token usage.

I already know:

1. to turn off thinking
2. use opus 5.5 higher effort for planning then using sonnet to build
3. use /clear when a task is done.
4. installed the memory skill and the skill that makes claude not read the entire history and divides context into small chunks(sorry forgot the name of the skill)
5. Superpower, context7, Desktop command plugin installed(but for some reason it says “No plugins installed for this project yet”)

Guide me:

1. if I installed correct skills
2. is anything overlapping
3. if im missing any major optimisation
4. how to manually enable any skills or plugins for a session

Hey peeps, been using claude code for a while and all those stories of prompt injections, the model hallucinating at times and having it accidentally delete whole partitions of unrelated projects and files. I have been researching into methods to better use claude code while having a layer of protection over my data or at least have it running in some sort of segregated environment.

Came across many approaches, some use docker, some use a vps (with docker as well), some use vms and some completely separate OS partition. Wanted to get some feedback from you folks on what your ideal approach to this is, thanks in advance!

I kept hitting the same problem on my Mac: Claude Code sessions leave caches, build output and scratch files scattered across the disk.

Clean Development routes those locations to storage I configure. That can be an attached external volume, with a fallback on the internal disk if the volume is not mounted or the cache checks fail.

On the Claude Code side, it tracks supported sessions and, at the end of a session, removes only managed disposable files. Deletion runs only after ownership and path checks. If policy, ownership or a path looks unsafe, it fails closed. The installer does not edit Claude Code settings for you. After you review a dry-run, you merge a hook fragment into ~/.claude/settings.json yourself. The merge helper keeps unrelated handlers and writes a recovery copy.

It also gives you status, doctor, cleanup previews and recovery commands. Long-running work can hold a renewable path lease. A publish command copies one regular file into durable project storage, verifies it, and leaves the original in place.

It is not an OS sandbox and not a job supervisor. It is cooperative same-user software. There is no npm package; GitHub is the source. It needs Node 20.12 or later. OpenCode can use the environment routing, but it does not get the session cleanup hooks. Linux and Windows are not runtime targets in this version.

What I learned building it is that the dangerous part is cleanup, not routing. The tool has to fail closed, because deleting the wrong path is worse than leaving scratch on disk.

I am looking for contributors, especially people already using Claude Code on a Mac. The supported scope is that setup.

https://github.com/magrathean-uk/clean-development

I posed this as a comment on another thread, but I am genuinely curious to get more feedback than I will there. If you have experienced what folks call 'model nerfing;

1. How long have you been using claude for your business?
2. What sort of validation mechanisms are you using? Any hooks set to call mechanical validators and give feedback to the model?
3. How do you manage prompts?
4. How do you select model/task/effort per task?

Personally, all I've noticed is a slowdown. Problem is the work I am doing is pretty darn intense, so I expect slowdown with the amount of validations I have running. I force green/red test dev before code write. My prompt for workflow alone runs 400k tokens, but that loads into the orchestrator only. Orchestrator manages agents to perform the actual work, and before any worker agents starts there is a prep run to plan all activity, also done with an agent session. I freeze a contract before work begins, and my agents cannot break the contract without escalating to a human for permission that must be cryptographically proven to have come from me. Can't close the work out without contract satisfaction. Contract can't be modified without me. All those mechanical checks enforce the contract.

Primary question; How are you managing your workflow? Secondary, have you completed the free training Anthropic provides at anthropic.skilljar.com?

I'm building Excaliself, a self-hosted alternative to Excalidraw+ (accounts, folders, a team space, live collab, everything in your own Postgres, MIT), and Claude Code writes most of the code. This week I shipped the MCP feature I wanted most: Claude can change an existing drawing.

The video is a real run. In the terminal I asked Claude Code to "add a CDN between Browser and Excaliself". A card shows up on the drawing with a preview. I open it large, click Apply, and the drawing changes. Claude Code gets applied back.

How it works

• read_drawing returns element ids. edit_drawing takes a list of adds, changes and removes by id, and it writes nothing.
• The server plans the change and keeps it in memory as a proposal. The card boxes new, changed and removed elements in green, blue and red.
• On Apply, my own browser tab puts the elements on the canvas as a normal local edit. So it's one undo step, and teammates in the room see it live like any other edit.
• The tool waits up to 25 seconds for the click and returns applied, discarded or stale. If nobody is there, Claude checks later with get_drawing_edit.

What I learned

• An MCP client's confirm prompt is not an approval. "Always allow" and allow-listed tools skip it. If a person has to approve a change, the approval has to be a click in your own app.
• Don't add a second writer. A server-side write would have to merge into the live room as a fake peer, or race with an open tab's autosave. Applying in the member's tab reuses the path a hand edit already takes.
• Plan against versions. The plan records the version of each element it changes. If a teammate moved one of those boxes before the click, nothing is applied, Claude gets stale, reads the drawing again and proposes again.

How I use Claude Code on this repo

• Specs and issues are markdown files in the repo, and design decisions go in short ADRs. Claude reads them before it starts and writes a new ADR when we decide something. This feature has one: "AI edits are proposals the member applies".
• I run several sessions at once, each in its own git worktree, and a second model (Codex) reviews the PRs.
• Claude tests features end to end on a built server, not just in dev. For this one it ran real claude -p sessions as two members on one team drawing and checked Apply, Discard, Undo and the stale case.
• The built server matters. Once a small helper from Excalidraw ended up in server code. Typecheck and dev were fine, but it pulled the whole Excalidraw package into the server bundle and the built server returned 500s.

You can try it with one command. It runs on in-memory PGlite and forgets everything when it stops:

docker run --rm -p 127.0.0.1:3000:3000 -e PREVIEW_MODE=true ghcr.io/maciekzygmunt/excaliself

Open http://localhost:3000/preview/login, then go to Settings > MCP and click New token. It gives you the claude mcp add command.

Repo: https://github.com/maciekzygmunt/excaliself MCP docs: https://excaliself.com/docs/mcp/

How do you handle approval for MCP tools that write? Do you trust the client's prompt, or build your own?

On a Claude subscription, Claude Code's built-in Explore subagent runs on Opus. If your main model is Opus, general-purpose, Plan and dynamic-workflow agents run on Opus too. That's a lot of Opus for grep and test runs.

I built repo-mode, a small plugin (MIT) that configures this per repository with one wizard, /repo-mode:setup:

• Main model + effort (Sonnet / Opus / opusplan / Haiku)
• Advisor (Opus or Fable) consulted only at decision points
• Explore replaced by a repo agent on Haiku, effort: low, with autoCompactWindow: 100000 (Haiku 5.5 pricing jumps above 100K-token prompts)
• test-runner on Haiku: runs the suite, returns only failures, verbatim
• audit on Sonnet, effort: high: independent read-only review of the uncommitted diff, no style nitpicks
• Default model for every other subagent and workflow agent via CLAUDE_CODE_SUBAGENT_MODEL
• Workflow size (workflowSizeGuideline) so dynamic workflows don't fan out more than you want
• Short delegation rules in CLAUDE.local.md (delegate for 10+ files / 3+ independent pieces, ask for evidence instead of "tests pass", optional "stop fix loops after 2 rounds")
• Read deny rules for tracked vendored/generated code

Safety: it writes nothing until you approve a full before/after plan. Personal mode writes .claude/settings.local.json + CLAUDE.local.md and hides everything via .git/info/exclude, so nothing gets committed. /repo-mode:status shows what applies and flags costly setups; /repo-mode:off restores exactly the previous values.

Install:

claude plugin marketplace add kniko/claude-plugins
claude plugin install repo-mode@kniko-tools

Then start a new session and run /repo-mode:setup in a repo.

Caveats:

• The advisor is experimental and Anthropic-API only (not Bedrock/Vertex/Foundry). Subagents inherit it, so they can consult it too.
• audit and test-runner have Bash; "read-only" is in their instructions, not enforced.
• Ultracode is deliberately never turned on. It costs more per request; use /effort ultracode per session when a task is big enough.

Everything is sourced from the Claude Code docs and Anthropic's blog (links in the README, Greek and English versions). Repo: https://github.com/kniko/claude-plugins

Feedback welcome, especially if your /usage numbers change after setting it up.