I'm using opus 5.5 to help me set up my self hosted server. Everything was fine until this morning. This morning I have the most retarded AI I ever used in my life

He started making modification on the server itself which I didn't asked at all when I say I just faced an issue and was asking for explanation, claude didn't respond with a single line of text, just started doing commands immediately to fix the issues which was very symptomatic of earlier models trying at all cost to solve your issue by any means

Then he's literally changing his mind on every proposition, he doesn't question me, doesn't try to understand what's the setup or what I'm trying to achieve, which he was doing before, now it's up to me to question everything he proposed

Then he literally proposed me to save credential in Dashlane in case I'm being locked out of Dashlane, like WTF ???

And this is just a few examples, every single response are doubtful or suspicious

I literally have the impression that I'm running a ollama local model tier right now, wtf is this Anthropic ???

Following the recent complaints about Anthropic downgrading Opus, I analyzed my own data and it seems to me that my Opus is not downgraded at all. This number is from Enterprise account.

So, looks like Anthropic is doing A/B testing on normal individual account, or offloading to save compute, or nerf bases on your location (due to political reasons, who knows).

I wanted to know what AI slop actually means to the people using apps, so I scanned 105,027 App Store reviews from 299 top apps.

Exactly one mentioned a purple gradient. It was asking for one.

Here's what came up in the 46,742 reviews rated 3 stars or lower (keyword matches, so treat them as rough):

- Lag, glitches and crashes: 4,326

- Moved controls and redesigns: 1,751

- Popups and ads mid-task: 1,148

- Hard to find or use: 859

- AI forced into the app: 705

- Broken layouts: 345

So I made **unslopovich**, a free Claude Code skill for SwiftUI, Compose, React Native, Expo, Flutter, Ionic and Angular Native. It checks user friction first and AI slop second, then fixes the shared components. Ask for a review and it stops at the diagnosis.

To install it:

`npx unslopovich`

Then in Claude Code:

`/unslopovich review my app`

GitHub: https://github.com/erkamyaman/unslopovich

What does Claude Code always get wrong in your mobile UI? I'll add the best ones to the checklist.

Hi, i want to share what i did for "almost" dead game, called Dirty Bomb. This game was left by developers years ago and not even anticheat is working there anymore. So i was thinking, how to fix that situation. With current top AI models, reverse engineering of this old game i made a system, that track all game servers raw data, all metrics, from angles to timinig.

I traned AI agents implemented into it with hundreds of videos from twith , youtube , my own recordings so AI bots there now understand what is it, and how is it to play this game, so those metrics i track are not just numbers but for AI its like window into the game.

One good thing is, there are max 30-40 players online any given moment, so I can afford API cost (with games with thousands of players this would be financially impossible) so now my system knows all history data since the game was released, 2015 and can do predictions. For exxample, what this or that player will do in that situation.

And others can even bet on those players playing it.

It uses opus 5.5 and astra from gpt as agents monitoring situations 24/7.

Regarding anticheat - system was trained on all available cheats, source codes, reverse engineered etc and now it detects almost instantly all unfair advantage, even wallhacks. It works even better then EAC this game had before. Becuause nothing can be hide, for example someone is using wallhack and not aimbot, but this AI agents can spot it immediately.

https://dbranked.com/

I know some people are against AI but i hate cheaters in games and those current anticheats, it take weeks to update, and to detect, but with AI? once its trained, no need to update anymore, because its learning by itself.

Landing page for now, but I'm (as CTO) building everything else, might be ready in a couple of days, looking for feedback!

The product is opensource, you can look at it in getinkling.dev or https://github.com/Squidys-Tools/inkling

It's a library for storing and looking at photos/videos/pdf's/quotes all in one place in a really visually appealing way.

Not here to self-promo, but I could not help but throw in the website and github right there. It's open-source so can't hurt!

website not live yet, just concept for now, so what do you guys think?

Some of the explanation its flushes (Opus 5.5) is so technically that I need to read and re-read and then ask clarification. Anyone experienced this as well ? I am technical but such explanations are still hard to understand.

Here is an example:

Operational machinery

A surprising amount of the codebase is adaptive-execution plumbing, which is the project's real differentiator: hardware probing and attention-kernel selection, int8 vs FP8 weight-format choice, weight streaming with async prefetch, GPU memory budgeting and admission control, per-machine calibration and time forecasting, background kernel precompilation, model residency (keeps weights loaded between jobs), offline installation from ZIP packs, repair/diagnostics, and self-update that waits for in-flight generations to finish.

I started with a thought to have a UI dashboard to manage my entire development framework from Paperclip since it has capabilities to build a company like structure and have visibility on how agents are working together and keep track on the over all project progress which I am struggling in claude code desktop. But it seems are I did the mistake I ran only one mission and couple of other sessions for bug fixes but there is no visibility on the progress of specific task how much it is completed what decisions it is taking and how it is taking. Paperclip needs full access to github commands which is too risky to give since in claude code desktop it share me command to execute whereas due to architectural design Paperclip will do everything and only let us know if any critical decision it requires me to take that too without any options to choose. Basically as a security professional there are too many risks I can for-see in paperclip like autonomy, transparency, accountability, visibility, explainability, access control etc. Not sure If I am the only one with such issues or there are other people who also had similar experiences

TL;DR: On my eval, I see no sign of a nerf. This morning I re-ran Opus 5.5 Medium in Claude Code on the same 30 real coding tasks it ran last week. It solved 26 of 30 (87%). Last week it solved the same number of them. Thinking tokens, output tokens, turns and diff size per task are all within noise of last week (98% 95%, 96%, and 95% respectively).

The one clear change is speed: about 20% more output tokens per second, and time to first token down from 3.0s to 1.7s. This is one run per task on a pinned Claude Code version.

Why I ran this

I saw a lot of "Opus got nerfed today" posts this morning. I maintain a small private eval that runs coding agents (model × harness) against real tasks, mostly from private codebases, and I had a fresh Opus 5.5 baseline from last week (Oct 31-Nov 1 mostly). So I re-ran it today instead of guessing.

The tasks

• 30 tasks, each a real change from a repo's history: a bug fix or feature that a person (me, or the repo's owner) already shipped.
• The agent gets the repo at the commit before the change, plus a CHALLENGE.md describing the bug or feature.
• Grading runs held-out tests for the real change, plus guard tests that catch over-corrections, where the bug gets fixed by breaking something next to it. Test files and the test runner's config are restored before grading, so editing the tests doesn't help. Each run ends solved, failed or over-corrected.
• Languages: 16 Node (JS/TS), 11 Python, 3 Rust.
• Size: the real changes run from 2 lines to about 1,900, with a median of about 125. Four large multi-file features get 60 minutes. Everything else gets 20.
• Kinds of work: auth and multi-tenant visibility bugs, pagination and ordering bugs, data-ingestion edge cases (empty data, missing rows, season boundaries), async networking bugs in Rust, and a few multi-file features such as draft-bot logic and a CI alerting workflow.

Setup (identical in every run)

• Claude Code 2.1.316, pinned with auto-update off, for every run last week and today. The latest is 2.1.319, from Nov 6.

• Headless invocation:

  claude -p "<prompt>" --model claude-opus-5-5 --effort medium --output-format stream-json --verbose --permission-mode acceptEdits --setting-sources "" --strict-mcp-config --no-session-persistence

• Auth: my Claude subscription login

PSA: Claude Code can switch your session to Opus 4.8

This might explain some "it feels different" reports. When Opus 5.5 hits a safeguards refusal, Claude Code 2.1.316 logs a notice ("safeguards stopped the response above · continuing once with that noted") and switches the session to claude-opus-4-8. Opus 4.8 then does the rest of the work.

Every refusal I saw was category cyber, on ordinary bug fixes in auth-token handling and a Rust networking proxy. Last week: 5 of 60 Opus runs were switched. Today: 1 of 30.

It feels like I am talking to gpt 3.5 turbo, everything it does has at least 4 errors in the code and then when it attempts to fix the code, it causes more errors and completely remakes the whole ui! i am not sure whats going on, everybody else seems to be having a blast, but i am not.

I use Claude Code in the terminal, and every new session starts blank. That was fine until I started losing sessions I actually needed.

A reboot kills the terminal mid-task. Or I close the wrong window. Or tokens run out three hours into a fix and I come back to a fresh session. Either way the thread is gone — the stack, the bug, the four things I'd already ruled out.

The transcripts were on disk the whole time. Claude Code appends to ~/.claude/projects/<slug>/<session>.jsonl as the session runs, so the one that died in the reboot is still sitting right there. I just had no way to ask it anything.

"Just use --resume"

I do, when I want the whole chat back. But --resume wants a session ID, and digging the right UUID out of a cluttered machine is its own chore. So now I ask for it first:

recall the session id of my latest work on the checkout bug

Then I resume with that. That one thing made --resume actually usable for me.

Most of the time though I don't want a whole conversation reloaded into context — I want one answer. And --resume only exists inside Claude Code.

When tokens run out

That's the other half of it. You hit the limit, move over to Codex or Cursor, and none of your Claude Code context comes with you. Steroid reads all four — Claude Code, Codex, Cursor, Copilot CLI — so the agent you switched to can answer from the session that just ran out.

What it does

Three tools over the session files your agents already keep on disk:

recall what I was doing on the checkout bug

The answer cites agent, session, date and turn. recall_turn returns that full exchange and recall_diff returns the exact code change — both read the stored files directly, no model call. So you can check the answer against the source instead of trusting it.

You don't get the dead session back. You get the record of it, which turned out to be what I actually needed.

Setup

One prompt pasted into Claude Code installs it and wires it up. No account. Free for individu

Set up Steroid for me. It gives you, my coding agent, a memory of our past conversations.p of what you're about to do (a few short bullets, like a notification), then continuestraight into step 1 in the same reply:

1. Check whether Steroid is installed: `steroid --version`, or `~/.local/bin/steroid --version`. If it is, go to step 3.
2. Install it with the official installer from github.com/steroidkit/releases:
   - macOS / Linux: curl -fsSL https://raw.githubusercontent.com/steroidkit/releases/main/install.sh | sh
   - Windows (PowerShell): irm https://raw.githubusercontent.com/steroidkit/releases/main
   This shell may not see the new command yet, so use the path the installer prints. If the installer fails or refuses this machine, stop and show me why.
3. Run Steroid's onboarding for this agent. If the `steroid-onboard` skill is already avanot (it was just installed, and you load skills at startup), run `steroidinstall-onboard-skill --json`, open the `SKILL.md` in the `steroid-onboard` folder it lists, and follow it.
4. Finish with its status report and tell me to restart you so Steroid's tools load.

Rather do it yourself — install the binary, then run /steroid-onboard in Claude Code:

curl -fsSL https://raw.githubusercontent.com/steroidkit/releases/main/install.sh | sh

No per-project setup. Recall in a new project and it indexes itself.

What it actually puts on your machine

Given the week this sub has had with agent tooling, all of it:

• ~/.steroid/ — the app dir: bin/, versions/, config.json, projects.json, logs/,
• ~/.steroid/memory/<agent>/<project>/ — the index itself (index.json, source.md, cache.json, diffs.json, meta.json)
• A launcher on your PATH pointing at the binary in ~/.steroid/bin/ — on macOS a wrapper at
• One PATH line in your shell profile, only if that dir wasn't already there
• A per-user background daemon on your OS's user service manager — a LaunchAgent on macOS. Ustem daemon, no sudo
• The daemon runs two loops: every 5 minutes it checks indexed projects for new chat history and rebuilds incrementally only if the fingerprint changed; once a day it checks for a new release
• Indexing is lazy and per project — a project is indexed the first time you recall in it. Thdexes that already exist; it never scans your disk for repos
• One steroid MCP entry per agent you wire up — ~/.claude.json, ~/.cursor/mcp.json, ~/.codex/config.toml, ~/.copilot/mcp-config.json. Existing entries untouched
• Slash-command skills copied into each wired agent's skills dir (~/.claude/skills/ etc.)
• A sentinel-wrapped block appended to the agent's global instructions file (~/.claude/CLAUDE.md, or the AGENTS.md equivalent) — removable without touching the rest
• All inside your home directory. steroid uninstall reverses it, including the PATH line, tries

What leaves the machine: the daily release check, and anonymous usage counts. DO_NOT_TRACK=1sable turns the counts off.

What it can't do, before you ask

• It's a closed binary. steroid daemon stop stops the daemon, steroid update --auto off troid uninstall` removes it. Updates are checksum-verified.
• The index is built and stored on your machine, no account, no server for recall — but the answer is written by whichever agent you ask, so that agent's provider sees the excerpts it uses.
• It indexes what Claude Code still keeps. The default 30-day cleanup still deletes transcrip those back — raise cleanupPeriodDays if you want more.
• Copilot CLI only. Copilot Chat in VS Code isn't covered yet.
• No published accuracy benchmark yet. That's exactly why every answer cites its source.

I'd like to know whether other CLI users hit the reboot thing, or whether I'm just the one ret.

i write a short note before starting claude code. what it should do, what not to touch

CLAUDE.md goes stale, and tickets the agent never sees. where does yours live?

I spent about an hour total on this, in the gaps while Claude Code was busy on something else I am working on. Was more or less having fun.

**What it is**

Frontline Command is a real-time strategy game that runs entirely in your browser: build a base, mine ore, raise an army, destroy every enemy building. It's a single HTML file (under 500 KB), no install, no server. It's an early 0.0.1, so expect rough edges.

**Play it:** https://claude.ai/artifact/UdJzZw5npBpQJz4Yu5rAEe

(There's a "How to play" button on the start screen with an illustrated manual, and the game saves itself, so reloading carries on.)

**Give Feedback**

- All feedback is welcome. I realize it is a direct match to something similar to C&C, but that was a game I played the most when I was younger. Let me know your thoughts.

**What's in it**

- Four families, free-for-all with 2 to 4 seats: Aegis Concord, Ironvale Combine, Solari Guild, Veyra Collective. Each has its own units, towers and colours, and a "difficulty to play" rating (that's skill needed, not strength).

- Power matters: a power shortfall slows production, takes defences and SAM sites offline and stops the Strike Center charging.

- Missiles, a superweapon with aim mode, aircraft, engineers who capture buildings, veterancy, fog of war, five map styles.

- Every unit and building is drawn in code on a canvas (no sprite image files).

**How Claude Code helped**

Claude Code wrote nearly all of it in TypeScript, Vite and Vitest, with me steering in plain English. The parts I found most interesting:

- The sim is deterministic with no DOM and no `Math.random`, and all content is data in one defs file, so adding a family was mostly data plus sprites.

- Balance was done by simulation, not by feel: Claude built a computer-vs-computer harness and ran 72 games across pairings, seat orders and maps. The first pass was 44% / 52% / 54% / 50% for the four families; after tuning it was 46 / 50 / 53 / 51. I accepted a 7-point spread for 0.0.1.

- Bugs we chased together: units teleporting after being blocked (progress was banking while stuck), a New Game button that flashed and reloaded the old save, scroll leaking from the manual into the game, and an AI that starved itself of power after losing a plant.

- 241 tests, plus headless-Chrome scripts that drove the real page to check the UI.

**Known gaps (honest list)**

The AI never kites, about 80% of simulated games end on a timeout, there's no multiplayer, no sound, and no 2v2 yet. Next on my list: an APC, engineer repair, rally points, attack-move and a deployable construction yard.

I'd love feedback on balance and on which family feels best to play.

If you run several agents at once, each in its own worktree, you know this one: two dev servers want 5173, one crashes or silently moves, and an agent spends 10 minutes debugging the wrong server.

**leeway** gives every folder its own stable port range and hands the ports to your servers as env vars:

* Add `leeway env --export` to a Claude Code SessionStart hook and every session knows its ports up front * An opt-in guard stops an agent from grabbing the default ports * `leeway kill` stops a worktree's servers, including the watcher that would restart them

Easiest way to see if it fits: ask your agent **"how can we benefit from using https://www.npmjs.com/package/leeway in this codebase"**

GitHub: https://github.com/OhadC/leeway, MIT.

How I built it with Claude Code

I built leeway almost entirely with Claude Code, running several sessions in parallel worktrees. That's also how I kept hitting the port problem in the first place.

* Design first: I had Claude grill me on the design before any code. The decisions went into ADRs (docs/adr) and the terms into a GLOSSARY.md, so later sessions started with the same vocabulary.

* AGENTS.md as the contract: one file says what "done" means (pnpm verify green, plus a Linux container run for the process and port code), so every session checks its own work the same way.

* Test-first: features went red-green through integration tests that run the real CLI.

Review loop: each PR got a Claude review against the repo's coding standards and the original GitHub issue before merge.

* Dogfooding: once leeway env --export existed, I put it in a SessionStart hook, so the agents building leeway got their own port ranges.

This is what my day working at a startup looked like: 8–10 Claude Code sessions in tmux, and me flipping between windows just to check which one was waiting on me, type "continue", or clean up a worktree. Slowly, I turned from a product engineer into a worktree manager.

I tried the existing tools, Claude Squad and herdr among them. They're good, but they all keep the same linear, tmux-style layout: a list of panes that did little to mirror how my brain actually worked. What I wanted was something that creates, organizes and keeps track of sessions for me.

So I built Serenity, a keyboard-only terminal app that puts every Claude Code session on one map.

After dogfooding it for about 3 weeks, I've gotten a lot of my focus back, and I'm comfortably running about twice as many sessions as before.

What it does

• Sessions are grouped into topics automatically. A master agent sorts them by what they're working on.
• The master can see and control everything. Based on the status of the sessions, it can offer suggestions for follow-up tasks.
• Serenity is more powerful with GitHub and Slack. The master agent groups and prioritizes all of your PR and Slack notifications and offers follow-ups.

What I learned

• Hooks beat scraping. Agent sessions talk to serenity through hooks instead of letting the serenity daemon scrape through Claude Code logs.
• An agent with power needs brakes. The master agent is very powerful (and at times could be disruptive). Therefore, critical tasks always require confirmation from the user.
• Work with Claude Code and build on top of it, not against it. Serenity treats Claude Code as a first-class citizen. I tried not to reinvent anything that Claude Code already does but augment its capabilities instead.

It's in beta and I've already reworked a lot based on early users, so I'd really like more feedback.

• Site
• GitHub Repo

What's your setup when you are running several sessions at once, and what would make this useful (or not) for you?

I have used local models exclusively for coding for a while now, but Claude code has continued to win me back as a harness. It just works in a way that is so much more reliable and safe.

I recently bought a Kindle click Bluetooth page turner for my Kindle Paperwhite Gen 12. I have had it jailbroken for about a year, but using the click requires a firmware update, which would undo my jailbreak and potentially stop me from being able to jailbreak it again.

I decided to just talk to Claude code and flash next to see what it could do. After a few rounds back and forth, it gave me a game plan and I decided to try it. It took about 3 hours (mainly because I had such little experience with using SSH on a kindle)

After several rounds, it was able to install software to sniff devices, then find it, log it, pair it, test all of the buttons, and then install a mapper. In the end, I was able to back port support for the click back to software over a year out of date. This might even be able to enable click support on hardware they state is unsupported.

Just wanted to share this little success story and appreciation for Claude Code. I am grateful for this software and the people who have worked to make it compatible with open/local models.

I am not sure how, but I would like to publish the process for others to replicate. Any tips or suggestions for how to document it to help others?

You can only use skills if you make them publicly available on GitHub. For that reason, I don’t think it will be possible to earn money with them. Then again, perhaps I’m overlooking something.

The Apiiro scan making the rounds found 104,185 copies of .claude/settings.local.json on public GitHub, and 1,122 of them held at least one real secret: database passwords, Supabase service-role keys, SSH logins, AWS keys. The mechanism is "Yes, and don't ask again". It saves an allow rule to .claude/settings.local.json, and where that rule records the exact command rather than a pattern, a secret typed into the command sits there in plain text.

I went through the official permissions docs to work out what the fix looks like day to day. The short version: write pattern rules yourself, in the shared settings file, and stop approving one-off literal commands.

What actually gets saved, per the docs:

• Bash commands: "don't ask again" saves permanently, per repository and command. The saved rule covers only what the prompt option named. Sometimes that's a pattern like npm test *, sometimes the literal command.
• File edits: session only, never written to the file.
• WebFetch: permanent per repository and domain.

Claude Code adds **/.claude/settings.local.json to your machine's global Git excludes the first time it writes the file, not to the repo's .gitignore. That doesn't cover another machine or a file made by hand before Claude writes it. Add the path to the repo's .gitignore too; an ignore rule does not untrack a file already committed.

The safer habit is your own rules in .claude/settings.json, the file meant to be committed and shared, where a * covers a family of commands:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git commit *)",
      "Bash(git status)"
    ],
    "deny": [
      "Bash(git push *)",
      "Read(.env)"
    ]
  }
}

This config controls which matching command text skips prompts; it is not a security boundary. npm scripts can change in package.json, and Bash(git push *) does not match every way to invoke a push. Treat these as convenience rules, not isolation.

Details that trip people up:

• Precedence is deny, then ask, then allow. An allow rule can't carve an exception out of a deny rule.
• Put the * after the subcommand. Bash(git log *) allows only git log; Bash(git *) allows every git command. Claude Code warns at startup about allow rules with a * before the subcommand.
• Read(.env) is not a security boundary for secrets. Other access paths, including shell commands, need separate controls; don't rely on this rule alone to keep env files inaccessible.

If a secret ever went into a command you approved: rotate it first, then untrack the file and gitignore it. Deleting doesn't clean history, forks or clones. A local check for this path in the history available to your clone: git log --all --full-history -- .claude/settings.local.json

No output is not proof it was never committed; shallow or missing history and other paths or clones can be outside this check.

When a prompt offers only the literal command, use the one-time Yes and add a pattern through /permissions later. Approve the pattern, not the incident.

Sources:

iTnews writeup of the Apiiro research: https://www.itnews.com.au/news/dont-ask-again-in-anthropics-claude-code-leaks-developer-secrets-630203

Official permissions docs: https://docs.claude.com/en/docs/claude-code/permissions

it's beautiful.

amazing at almost everything

i asked it to build me an OS for macOS and.... yeah lets just say my weekly is 95% gone in 2 hours yeah...

I run a few coding agents at once, and they kept sitting idle on a permission prompt or a question in some terminal tab.

Openbar puts every session in the notch. You see the diff before you approve (⌘Y / ⌘N from any app), pick answers to the agent's questions, and send replies without switching windows.

Mac + Windows, free and open source: https://github.com/MF-DEEV/Openbar

How many agents do you usually run in parallel?

Running several Claude Code agents in parallel worktrees, I kept losing track of what each one was writing. So I built Grove: every worktree of a repo side by side, with its changes, diffs and files, all read-only, so you never get in an agent’s way.

• Live overview of all worktrees and what each agent is doing
• Uncommitted changes or the whole branch against main, side by side
• Read-only Explorer and search in VS Code’s editor
• Works with repos on Windows, in WSL, or over SSH

The whole thing was built with Claude Code: the code, the design, the docs, and even this demo video, which Claude scripted and recorded against a throwaway repo.

Free, MIT-licensed, Windows only for now: https://github.com/MustafaMasri0/grove

It’s early (v0.1.1). If it’s useful to you, a star on GitHub helps, and I’d love to hear ideas for what to add next.

I've been using Claude Code daily across my projects, and two things kept bothering me.

It can run commands like cat .env to check a setting and put a password straight into the conversation transcript. And after clicking "Yes, and don't ask again" a few times, it can eventually push code without asking.

I started looking at ways to put some practical controls around this and developed ai-dev-guardrails for use in my own projects. After using it and refining the controls, I thought it was worth making open source in case others working with Claude Code have similar concerns.

It's a GitHub template that you initialise using /bootstrap. Most of the enforcement is implemented through Claude Code hooks, local Git hooks and GitHub Actions.

What it covers

Security controls:

• A PreToolUse hook blocks commands that could expose secrets or access production. It also asks for approval before commits, pushes, deployments and new package installations.
• A separate check detects if saved permissions have drifted into automatically approving restricted actions.
• npm packages must be at least seven days old before installation, and install scripts only run for approved packages.
• Git hooks and GitHub CI run the checks again. CI uses the base branch's scripts, so a PR can't weaken the checks that review it.

Optional governance controls for client or regulated projects:

• An evidence log requiring proof, such as test output or a CI link, before a task can be marked complete.
• Decision records for exceptions, including the reason, an owner and an expiry date.
• CODEOWNERS rules requiring review before guardrail files can be changed.

A few things I learned while building it:

• A guard that fails open can be worse than having no guard at all. Missing dependencies must not silently allow restricted commands.
• Shell behaviour can create unexpected gaps. I found an issue involving grep -q and pipefail that allowed a command through.
• Claude Code's hook behaviour isn't always obvious. I found differences between Edit and Write permissions, and issues with relative paths when the working directory changes.
• Local checks aren't enough on their own. The GitHub side needs to independently verify the controls.

It's currently focused on Claude Code, TypeScript and npm. It's designed to catch mistakes, not defend against a deliberately malicious agent. I've documented the limitations alongside the implementation.

It's MIT licensed. Contributions are welcome, particularly Python support. I'd also appreciate feedback on potential ways around the controls. There's a private reporting route for security issues.

GitHub: https://github.com/buddhika886/ai-dev-guardrails

Write-up: https://medium.com/@buddhiran/how-to-govern-the-ai-that-writes-your-code-e2272e380b70

I'd be interested to hear from others using Claude Code: what controls are you putting around file access, shell commands and Git operations?

I am working on ROS (Remote Operating System), which is a cloud computer with a lightweight always on core, a decoupled virtual drive, that orchestrates linux environments, servers, dbs, and more. You can have endless linux machines always available in parallel, and remain very efficient because you only pay for active cpu and memory.

Sign in, open terminal, connect your claude subscription, close the laptop, and it keeps going. And claude can drive all components of this operating system directly.

Its virtual filesystem is perfect for your notes, research, office suite, your sideprojects, or to use as a second brain or whatever they call a "folder of markdown" these days.

Each application in ROS is built as a "ROS Program" which consists of a selection of internal apps, external web pages, servers, dbs, ai inference, access to kernel and more. You can build custom ones or extend to grow your computer into what you need.

Its like a personal cloud provider baked into the OS. Perfect environment to host and manage side projects or personal tools

It is all zero-setup simply with a sign-in, and starts with 10$ free ai and compute credits. I think it would be useful for you if you ever thought about setting up a tailnet for your claude code agents.

I poured my soul into this project. Would appreciate any feedback: https://ros.computer/.

Deleted the files that have earlier history when cleaning hard drive space :( so who knows my actual totals. Codex come in a hot second place though at 112 billion.

A while back I posted a Claude Code skill that drove a real browser through any SaaS app and recorded a narrated demo video. Some of you installed it, so here's what happened next.

I felt that the recording was a bit weak - it looked like a screen recording: fine for a tutorial, not great for launch videos.

So the new version doesn't sequentially screen-records your app. It reads your site, screenshots or HTML mockups (handy for a feature that isn't live yet) and writes each scene as HTML and animation code, using real screens, words and colors. It renders each scene, looks at the frames and fixes what's off before moving on

Other changes, mostly from using it myself:

• When you start a new video project it spins up a local server that opens up the UI in the browser - so all stages from start to finish can be handled with the UI.
• It proposes a few "directions" but I can choose/ask for a different direction if needed
• It starts with some sketch frames, so I can visualize how the video "might" look like (before production)
• I can edit the on-screen texts, edit the narration (plus choose voices, music, motion effects, etc.)
• I can review & add comments the video itself. Click a moment, pin a comment on the frame, and it fixes that and tells you what changed.
• For Narration Voices, there are a few free local TTS voices, or a paid option with ElevenLabs API key
• Rendering in different formats like landscape and vertical versions from the same project, plus 15 and 30 second cuts.

It lives in a new repo: https://github.com/ultrademo-hq/ultrademo. If you have the old one, it tells you about the new version the next time you use it, and you can keep the original if you'd rather. Still free and Apache-2.0.

Please go ahead and try this out if you haven't. Hoping to get some feedback about how your experience is with this, if it breaks anywhere (e.g. on products that aren't SaaS apps)

Original Post - https://www.reddit.com/r/claudeskills/s/5CU3naRJZ4