If you open a new projet and ask Claude to summarise everything to know about REA and aks it to make some guide it will do the search then trigger a safety guardrail mid sentence and tells you this:

if you have tried it and had underwhelming results, it is most likely because Opus (and all claude) was told to not perform well when doing this type of task.

to me this is insane, I am used to paying a premium to get first person weapons and hands rigged posed and animated, and to have opus 5.5 do the whole deal in blender and be able to import it into unity and unreal, any animation in my head, is crazy. If opus 5.5 is at this level can't tell what the future will look like. im hyped!

I see so many of the marketing videos where people advertise their use cases and they are like:

Claude takes my TeAM opINIONS from SlACk and it gives me dashboard

PRs are open, and Claude bla bla bla

My Teaaaam on Slaaack discussion and we found a SoluuuTION

Claude is able to find Vegan restaurants near my Area in Silicon valley and book me a time at "Thiss time" yeahh because I'm vegan

Me and my wife wanted to do our vacation in HawAIII so claude went in booking.com and lowballed the guy for $2000/night and that was perfect for us. And they AllOW Dogs.

Like this feels like they live in an alternate reality from a majority of their userbase.

I've seen dozens of posts here: "Why do I run out of usage so much?", "Why do I have to keep repeating myself to Claude?", etc.

I've built a set up that works amazingly well, for me, as a solo developer. YMMV if trying to implement this in a team. But here goes.

Full disclosure: This post was generated by my prompting my Claude Code as follows:

I feel like most people that are using Claude Code are not doing it effectively. I feel that my use of Claude Code, with my setup of mcps, gitlab, etc. is VERY effective, however I struggle to explain it to other people.

Can you create a description of what our set up is? something that I can post to reddit?

---------------------------------------------------

I've been programming for a long time, and I use Claude Code heavily for personal projects, a homelab and day-job support. Most people I talk to use it as a smarter autocomplete: open a session, describe a problem, accept whatever it does, repeat. That leaves most of the value on the table. Here's how my setup is built and why each piece is there.

1. The rules live in hooks, not in prose

Everyone writes a CLAUDE.md full of rules, and the model drifts from them anyway. My rule of thumb: if I've corrected the same behaviour twice, it becomes a PreToolUse hook that denies the call. Some of the things enforced that way:

• Nothing is deleted. A delete is blocked and rewritten as a move into an _archive/ folder.
• Git commands go through one wrapper script, never cd && git.
• Commit messages can't contain closing keywords like fixes #12, because those auto-close issues and skip my close-out process. There's no AI co-author trailer either.
• Writes to my day-job systems (ticketing, work email, work repos) are blocked unless I've said OK for that specific action. Reads are fine.
• Work content can only go to approved models. Other vendors' agents are blocked from seeing it, with no override.

CLAUDE.md still exists, but it's short and points to the detail. The hooks do the enforcing.

2. A self-hosted git server is the system of record, and the workflow lives in the tools

I run my own GitLab and wrote an MCP server for it (around 90 tools). The key design choice is that the workflow rules are inside the tools, so the model can't skip them:

• Every issue has exactly one type:: and one status:: label, and status is a state machine. Only I can move backlog -> ready. An agent can move ready -> in-progress, -> blocked (and blocking means posting a question on the issue instead of guessing), and in-progress -> review, which requires an open MR. review -> done happens only when I say so.
• Closing an issue is one tool call that runs the whole protocol: cross-reference the commits, log estimated skilled-developer effort (not clock time), set the terminal status, close it and sync the wiki.
• Raw API calls are forbidden, because a raw call bypasses the rules.

So the AI doesn't decide when work is "done". The tracker does, and I do.

3. The main thread orchestrates; subagents do the work, routed by model tier

The main session doesn't edit code. It plans and dispatches:

• Cheap and fast (Haiku): drafting short text, finding docs, trivial one-line fixes
• Mid tier (Sonnet): implementation from a clear spec, reading and synthesizing documentation
• Strongest model: bugs that several attempts haven't cracked, real architecture tradeoffs
• Below all of these: Jev for typed judgments over large piles (next section). It doesn't write.

This keeps the main context clean and the cost sane. I can also send a task to another vendor's coding agent for a second opinion. It runs headless in a disposable git worktree and never writes to the real repo, and Claude reviews whatever comes back.

4. A cheap decision model sits under the agents: Jev

Plenty of the work in this setup isn't writing. It's judging: is this issue ready, is this log line mine or the game's, is this alert noise, does this MR description match its diff. Sending all of that through Opus is expensive and fills the context. So there's a third tier below Haiku. Jev is TypeSafe's "System One" model, and it only returns typed judgments: pick one option, score on a scale, or give a yes/no probability. It can't write prose at all.

The standing rule is Jev decides, Claude writes. When Jev is unsure, Claude makes the call.

How it's wired:

• It's behind an MCP server I wrote. jev_ask takes questions (or a saved question set) plus file paths, globs or a GitLab query. The file contents never enter Claude's context. The server screens every item, sends them in parallel with back-off, and returns a compact table: accept / look / decide, with totals and a cost line. Claude reads only the items marked decide.
• Question sets are saved and re-measured. Confidence bands are tuned per question against real outcomes. The generic 0.8/0.2 thresholds left 80% of a backlog in the borderline zone; re-measured bands fixed that.
• It's embedded in other tools, not just called by hand:
  • The GitLab ready gate can run a Jev check on whether an issue still contains an unmade decision. It's advisory and opt-in per project.
  • Backlog grooming pre-sorts issues so the expensive model reads only the borderline ones.
  • An audit skill reports closed issues that don't meet their acceptance criteria, type:: labels that have drifted, and commits whose diff doesn't match the issue they cite. It reports only and never writes to GitLab.
  • The second-opinion workflow uses Jev as an acceptance gate on what the other vendors' agents return.
  • It also triages homelab alert noise, classifies game log origins, and finds duplicate memory files.
• Every turn that calls it reports the cost: calls, input tokens and USD. The API returns tokens, not dollars, so the cost is computed.

Measured accuracy against my own ground truth: 16/16 on the second-opinion gate, 92/97 on the backlog pre-sort, 18/18 on memory dedupe, 6/6 on MR-vs-diff.

The trap I measured, which most people will hit: a cheap model doesn't automatically save tokens. Each extra round trip resends 60-75k tokens of context to the orchestrator. On a 14-issue backlog, the Jev run used more Opus tokens than having Opus read the issues itself. Break-even came out at about 45-60 issues, or roughly 15-20k tokens of issue bodies. Above that, the gap widens fast. On 267 closed issues (about 1 MB of text):

• Opus usage: 1.7M tokens with Jev, against 9.5M without it. That's 5.7x fewer raw tokens, about 4x cost-weighted.
• Jev's own bill: 223 calls for $0.014.
• Verdicts: they agreed on 208 of 223. Jev was the stricter of the two, and it never passed something Opus failed.

And the safety lesson: anything sent to Jev leaves the machine. My first bulk run sent a memory file that contained a LAN login. The screen for client content didn't catch it, because it wasn't looking for secrets. Now every item goes through a credential screen as well, and work content is blocked outright. On one 267-issue run the screen held back 16% of the items, and the tool lists what it held back instead of dropping it silently.

5. Skills turn repeated workflows into one command

• Work the ready queue: one subagent per ready issue, each in its own worktree, in three phases: validate and lock, implement, review. It opens an MR and hands the issue back to review. It never merges or closes.
• Groom the backlog: check each issue against a definition of ready, draft acceptance criteria from the actual code, and promote only the issues I name.
• Work a milestone: walk it stage by stage, one branch, MR and delivery per lane, until nothing is left that doesn't need me.
• Ask the board: a panel of personas modelled on well-known engineers argues a decision from different angles, maps where they agree and split, and gives one recommendation. It's useful when I'm clearly talking myself into something.

6. Memory is a structured knowledge base, not a junk drawer

Each fact is its own file with typed frontmatter: who I am, feedback on how I want it to work, project state, or reference material. On top of that:

• stale_after dates on anything that ages (versions, IPs, prices, who owns what). At session start, a hook flags stale facts so they get re-checked before anyone relies on them.
• status: deprecated instead of deletion, so the history stays.
• verified: by human. A fact I confirmed beats one the model inferred.
• A hook validates every memory write, fixes the links and regenerates the index.
• Many entries are explicitly marked TRAP: things that cost me hours once ("this command exits 0 but does nothing"). Those are the most valuable entries in the whole thing.

The whole memory store is version-controlled.

7. Custom MCP servers for every domain I work in

• Homelab: provisions VirtualBox VMs over SSH, reads the installer screen, waits for boot and registers the new host in an inventory.
• Git hosting: described above.
• Jev: described above.
• A game-modding toolkit: compile checks, log and screenshot retrieval.
• Work mailbox: read-only, and it deliberately has no send or delete verb. The safest permission is a capability that doesn't exist.

Each server has a help() tool that serves as its catalogue, so the model looks up what's available instead of guessing.

8. Standing rules for infrastructure

When a VM, host or container comes into existence, three things happen in the same pass without me asking: it's registered in the inventory (and proven reachable with a real command, not just a ping), it gets a tile on my homelab start page if it has a web UI, and its timezone is set. CI on the container stack fails any service that's missing a timezone.

9. Verify, don't assert

• "Verify before asking or asserting" is a hard rule. Before it asks me something, it goes and checks.
• Deliveries are verified by file hash, not by poking at the app.
• Word documents go through a render loop (docx -> PDF -> images, then the model looks at the pages) before I see them.
• Code gets a compile check before every deploy.

What I think most people get wrong

1. Rules written as prose and expected to stick. Enforce them with hooks.
2. No system of record. The AI shouldn't decide what's done; a tracker with a state machine should.
3. One model for everything. Route by difficulty and keep the orchestrator's context clean.
4. Memory as a dumping ground. Type it, date it, mark what's verified, and record your traps.
5. Generic MCPs only. The best MCP servers are the ones you write for your own domain, with your rules built in.
6. Trusting "done". Make verification part of the workflow.
7. Using an expensive model for every decision. Put a cheap classifier under it, but measure the break-even first. On small piles it costs more, not less.

The result is that I spend my time making decisions (what's ready, what's done, which tradeoff to take) and very little on supervising keystrokes.

----------------------------------------------

I don't claim to be an expert in any of this, but I'm a seasoned developer with 45 years of professional programming experience.

Some of the stuff you see here might sound familiar, like "grooming", I use Matt Pocock's skill for that (more accurately I took the idea of his grooming skill and built my own), the "ask the board" I took the idea from one of Austin Marchese's Youtube videos.

I don't have ANY skill "packs", plugins, etc. installed in my environment.

I wish I could share some of the stuff that I've built, like my gitlab-mcp, but unfortunately when I built it I was building it for me, and there is way too much I would have to sanitize before making it public. What I can say is that EVERYTHING talked about above WAS built by Claude. I just told it what I wanted.

If I had to answer "What is single most important thing in your setup?" I would have to say my locally hosted Gitlab server. By using the "Issues" module in Gitlab I can keep track of everything that is going on, no matter how many projects I have going at a time. In the past 60 days I've worked and closed 1,160 issues across 15 different projects. Of all of those issues, EVERY SINGLE ONE was written by Claude by prompting "Create an issue in project xyz to solve/implement .... Validate the issue against current code", or something to that effect. I believe all of this could also be accomplished using Github, for those not inclined to host their own gitlab.

Below is the diagram for the state machine that controls my process:
(created with the prompt:
show me the diagram for the issue state machine
)

Everyone's been saying "expires Oct 22," but nobody had an exact time, and Anthropic's help page only says it expires "on the day and time listed on the offer." So I dug into the network responses on the usage page.

The offer object contains:

"starts_at":"2026-09-22T16:00:00+00:00",
"ends_at":"2026-10-22T16:00:00+00:00",
"clears":["five_hour","seven_day"]

So it's exactly 30 days, from 9 AM Pacific to 9 AM Pacific. It expires Oct 22 at 16:00 UTC:

That also explains why some people in Asia see "Expires Oct 23": the UI shows the date in your local time zone.

Verify it yourself (Firefox/Chrome):

1. Go to claude.ai → Settings → Usage
2. Open DevTools (F12) → Network tab, then reload
3. Use the search in responses (magnifier icon in Firefox, Ctrl+Shift+F in Chrome) and search for ends_at or 2026-10-22

If you're in the US, don't wait until the evening. Use it before your Thursday morning or lunch break is over.

It’s called spelunkr.

28 channels (so far) of forgotten videos organized into themed "cable tv channels" that play on a synced schedule 'round the clock.

The entire collection so far is about 2,700 hours of video, running around the clock. You tune in and land in the middle of whatever is on, at the same moment as everyone else watching, the way TV used to work.

Codebase is about 87,000 lines, made up of 24,000 of app code, 13,000 of CSS, 28,000 of tooling scripts, 16,000 of tests and 5,000 of SQL. 670 commits over 8 months, and we run over 850 unit tests and 160 browser tests. It's been a real passion project for me, really my first idea of what to build with Claude and has just been growing slowly as I've had time to work on it.

I've been plugging away at this off and on for the past 8 months, about 40 days of "total" work across that time, nearly all of it done with Claude Code. Here's how it works under the hood:

All videos on the website are streamed directly from the Internet Archive. The player is a plain HTML <video> element pointed at the Archive’s own file. No iframe, no proxy, no re-encoding, no copy. Spelunkr itself serves the page (about 110 KB of JavaScript, gzipped), small JSON schedules, and about 200 public domain or CC BY or BY-SA music tracks for the breaks. Every title links to the tape’s own page at the Archive.

There are station "bump" breaks between videos as an homage to the classic Adult Swim bumps.

Channels are built from Archive search audits to see if the IA has enough content to support a full length channel. Some channels are classed as "REWIND" and usually are 2 to 6 hour long VHS rips of actual live cable TV from someone's VCR in 1993. There's also classic movie channels dedicated to horror, monster flicks, detective noir capers, and western flicks. I even found every episode of The Joy of Painting and gave it CH 12: HAPPY TREES.

Claude checks all the tapes to make sure they're legit, then formulates the descriptions, facts, and schedule for me to approve. Each channel has its own branding, a 32×32 pixel logo drawn from eight color tokens, its own station-break voice and its own music pool.

A channel orders its tapes one of three ways: by year (8 channels), shuffled (12), or block rotation (4). Block rotation is a few episodes of one show, then the next show, round and round.

A channel is a published list of tapes with a start time.

“What is on now” is arithmetic: walk the schedule from its start to the present. The same code runs in the browser, the publishing tool and the tests, in whole milliseconds, so every machine gets the identical spot on every channel's schedule across the globe.

The math also accounts for the bump breaks, which get re-picked on every pass through the lineup. The browser measures its clock against the server’s once (the HTTP Date header) and corrects it only when it is more than 2 seconds off. A new lineup is published at least two minutes ahead and takes over at the end of a break. Open tabs hear of it over a websocket and switch without a reload.

Some key features built in:

• Limited DVR: Pause, skip back 15 seconds, or scrub within the tape that is on. The player shows how far behind live you are, and LIVE snaps back. (While paused you fall further behind each second)
• Machine Generated Subtitles: IA doesn't always have subtitles, so I use local software on my hardware to transcribe the tapes in their native language, and then translate them and output as subtitles overlaid on the player.
• In-line timestamped comments and reactions: A comment is stored against the tape (its Archive identifier) and a second within it, not against a channel or an air date. It comes back at that second every time the tape airs, on any channel that carries it. I've linked up a discord to help moderate potential comments (there are none yet lol). Signing in to comment also joins you to the Discord. Reactions work the same way and require no account or Discord. Its a free for all. A reaction from someone within 10 seconds of your playhead floats up over your picture as it happens.
• Comments are permanent pins on the timeline and pop up over the picture as the playhead crosses them. I like to think of it as pop-up video cable graffiti.

Urban planner here building a realistic city simulator. It’s more policy oriented than cities skylines, which tends to be more authoritarian esque and entirely focused on the urban design. My game is more realistic where you physically build less but influence growth through public policy. It’s much more in depth when it comes to inequality, disinvestment, public transit, coordination with state and federal gov, etc.

ANYWAYS, I’m more here to discuss the asset creation using blender. These assets are insane quality for being created by Claude with blender.

That said, any suggestions on other tools that deliver similar performance/outcomes as I refine the UI, menus, and landscape? Even suggestions on refining the simulation would be greatly appreciated.

IRON CURTAIN CALL WW3: Third time’s the charm. A sarcastic cartoon fast paced FPS built in Godot.

I used Claude for nearly everything, ElevenLabs for voices, Higgsfield for artwork, and Kling for cinematic clips, then edited those together with recorded Godot gameplay.

Curious what you guys think of the style?

Demo coming soon currently awaiting Steam approval.

Wishlist on Steam: https://store.steampowered.com/app/5417460/Iron_Curtain_Call/
https://ironcurtaincall.com 

I've been really wanting to create my own personal site. I absolutely hate the current wave of sites juiced to the gills with 3D animations.

So with the help of Claude I finally figured out a minimalistic but still pretty cool website! The site is always adapting according to my current local time with each tab being its own papercraft scene. The way Claude got the scenes (tabs) to transition between each is sick.

Super happy with how it came out!

If you want to check it out: lukerenton.com

Feedback more than welcome!

“…and make no mistakes.”

Fable 5.5 might not be real though. He might be a internet nerd-youtube-bro psyops scheme to make money on prediction markets by convincing people to bet on a too early release date. Maybe there is no Fable 5.5. Maybe nothing is real....

I have a few days off and forked a repo from GitHub for my Nas to adapt it for my needs, basically my last three days are the following:
- sketching a prompt and asking Gemini Argon to refine it
- plan implementation with Claude Opus
- ask Sonnet to do the work.

I am watching it for 3rd day straight touching grass between token limits and I think I'm getting addicted, I don't know why but it's so satisfying.

Talked with a friend that is a senior dev and he said that basically he had the same when he started a while back.

This thing is crazy good. But the thing is what do you do without upscaling to Max when you hit the limit? You get a second account? If yes, how to safely handoff? Are you stopping mid project? Or you just upgrade to max and you don't care? What are the odds of hitting daily limits with Max using a workflow like mine?

I tried Claude for the first time in my life after chinese models like glm, kimi and deepseek. Bought their 20$ plan even tho people were saying that it eats usage.. but i didn't find so in my tests.. if you use sonnet 5.5 even on med-large codebases during off peak times only then it's pretty good. I bought on sunday, so by my usage i will finish weekly by Friday or Thursday night for the week because i have been working intensely lol. I want a suggestion tho, should i use two 20 dollar plan? since my usage still fills up by max 5 days even after using sonnet 5.5 off peak. Will two 20 dollar plan be okay for a little bit of opus?

Change your environment variables

Hey everyone,
I’ve been trying to use the REA (Reverse Engineer Anything) toolkit within Claude Code with Opus 5.5, but I keep running into a wall: almost any command or context related to unpacking APKs, inspecting smali/dex, or setting up proxy intercepts triggers a false ⁠[cyber]⁠ safeguard flag.

Can you share a working prompt/workflow? If you have a prompt pattern that actually gets Opus 5.5 to cooperate with reverse engineering an Android app to capture and map out encrypted API traffic (without getting flagged or giving up), I’d love to see it.

Appreciate any tips or prompt templates you've found success with!

I have a work laptop, a personal one, and a DGX spark home lab setup. On top of that, I got a new replacement work laptop last week. I had to figure out a manual, somewhat agent-assisted process to sync up my custom Claude Code setup using git: about six MCP servers, a few skills I wrote, my CLAUDE.md, a couple of plugins, and the model settings. I always missed something, and usually didn't notice for a week.

So I built a tool that pins all of it into one file:

hlock pin --user # writes harness.lock
git add harness.lock .hlock/ && git push

# on the other machines
hlock pull github:cosmicbboy/my-agent-setup
hlock sync

Here's a quick video:

Some details that matter for Claude Code specifically:

• It records only /mcpServers from ~/.claude.json, not the session state, project history or OAuth stuff in the rest of that file.
• Tokens in MCP server env or headers become HLOCK_SECRET_* placeholders, and you fill them in from your keychain on the other machine. Nothing secret goes in the file.
• Plugins and marketplaces are pinned with their versions, and sync reinstalls them through claude plugin install.
• Sync goes into an isolated CLAUDE_CONFIG_DIR by default, so it won't overwrite your existing setup unless you ask it to (--in-place).
• hlock check tells you what changed after a Claude Code update ("plugin X 1.4.0 → 1.5.0").

It's open source (Apache-2.0). Disclosure: I work at Union.ai, which funds it. I'd really like to hear what how it works on your setup.

Repo:
https://github.com/unionai-oss/hlock

Does anybody else feel that the actual code means less for the human in the loop? I've been coding for well over a decade and my need to actually review lines of code have lessened an incredible amount. So much so that I tend to review code for fun. Like I really don't need to review anything. All debugging, I just run through Claude to fix.

My point is, why are we still using coding languages that were meant for human readability? Why are we not looking to optimize how agents create apps, software, etc.?

So we're prompting and letting the ai do everything that works best for it. Potentially saving a butt load of tokens and allowing the model to work more efficiently for the same outcome.

I've been locked in building a 3D motion design editor for a while. This week I shipped an API for it and wanted to see if Claude could make the launch video on its own. Pointed it at the editor through MCP and let it go. Every shot, every animation, the sound. I never touched the timeline. Video below.

This isn't like Remotion or HyperFrames where Claude turns code into video. It works inside the same editor I use. Layers, keyframes, camera, sound. What comes out is a project file, like a Figma file. Me, my team, and Claude can all be in it at once.

Yes, Claude made 100% of this one, but I only did that to show what it can do. My best videos come from trial and error. I try one look, don't like it, tweak it until it's right, have Claude do the repetitive stuff. I'd be so bothered if I had to re-prompt for every little edit. I need just as much control as the AI, if not more. These videos are best when creativity is expressed, not just generated.

The API is for content that otherwise wouldn't exist because nobody has time. Changelog clips, a short social cut per feature. A GitHub action on a big UI PR or a client marking a brief as ready can trigger a draft, a person reviews and greenlights it. The AI drafts, the person decides.

What would you hand to Claude in a creative tool, and what would you refuse to let it touch?

[Edit]

A few replies asked why I stay in one session, so here's the context.

I use Claude Code for more than code. I think through product strategy with it, using our own skills to pressure-test ideas, and then fold the result straight into the codebase in the same session. Over weeks I kept updating the rules and wrote down how Claude answers and pushes back when it checks my claims.

I used to do the usual thing: when the context hit around 80%, I'd have Claude write a handoff doc and move to a fresh session. That doc wasn't just facts. I put the way of working into it in a lot of detail: how to check my reasoning, how to answer, what to push back on, along with the rules and skills. It still didn't work. The new session knew the facts but didn't work that way. I tried for a while, then gave up and stayed in one long session, letting it compact. When something old is needed, Claude greps the transcript.

So I'm stuck between two bad options.
A fresh session loses the way of working, even when it's written down in detail. A long session keeps the way of working but slowly loses old decisions, as below. Has anyone gotten a new session to actually work the way a written handoff describes?

________________________________________________________________________________________________

Disclosure first: I'm building a local AI agent called 'Sonjari' :)

Setup: Claude Code desktop, Opus 5.5. One long session since Sep 30 on a Windows agent project, with CLAUDE.md and auto memory on. It has been compacted 62 times so far.

What I expected: the compaction summary would keep the decisions we made along the way.

What I found when I checked:

- I took a stretch from about 10 compactions back and listed 12 decisions we made there.

- The current summary had 0 of the 12.

- Our memory files had about 8. The other 4 were nowhere.

- The most recent stretch was fine: 20 of 21 items were in the summary.

Recent work survives. It's the summary of a summary of a summary that quietly drops the older stuff.

The 4 we lost completely were not things we could do without: a one-line product positioning we'd agreed on, a design call to do some cleanup in one place on the backend, a bug we had tracked down, and how to answer one specific comment. I only noticed because I asked "what did we decide about X?" and Claude had to piece the answer back together from the summary.

How do you handle this? A decision log you update by hand? A hook before /compact? Or do you just start fresh sessions more often?

One thing we're trying: while 'Sonjari' is idle, it reads the Claude Code transcript on my own GPU and keeps decision cards, each with the line number and a word-for-word quote, so Claude can pull them back after a compaction. Sonjari itself is out, but this feature ships in the next update, and I haven't measured whether it actually helps. Curious what works for you first.

For anyone wanting to give any AI full control over IDA/Ghidra feel free to use this

script I created about 1 year ago, didn't share it until recently, it gives AI full control of ida and ghidra to reverse anything and rebuild it from scratch or whoever you want.

I spend my whole day rebuilding a games, dlls etc with Claude Opus 5.5 and Fable 5.1 and not issues even codex astra.

https://github.com/oscarsantanaarias/IDA-Ghidra-bridge

Just tell the agent where the scripts are and to save it in memory and done agents will always know all about the scripts, in IDA select FILE / SCRIPT FILE and select and done AI has full access, and in ghidra Script manager and add it manually creating a new jython script or drop t he script where ghidra script folder is and run it. Ghidra Scripts are usually in: C:\Users\UserName\ghidra_scripts

I've had a lot of fun (and been too addicted) the last couple of weeks with using Claude Opus 5.5 to create music videos.

This time I wanted to try something new - and did the whole video in 3D. That required more effort from me & Claude, and there is still a lot of room for improvement.

I wanted to share this here - maybe some of you can relate to the sentiment in the song and video.

I've had some questions previously on the process and effort so I'll try to explain a little bit:

Grilling and design sessions with Claude to land a direction for a music video renderer which solely is code-driven. For each music video, there has usually been something new to build and add, further expanding the features that can be reused for later videos. Additionally, I have a playback-tool that Claude created so I can simply point out specific things that must be improved at specific parts of the music video - great for iterating and giving direct feedback!

In this specific video I also had Claude create models in Blender.

(However, I will say that iterating on a full 3D music-video was much more time-consuming and also cost a lot more tokens than the 2d + 3d mixes I've done before)