# Deduped AI Use Cases

Generated 2026-10-19. Every current use case for the top AI repos, with steps and copy-paste prompts.

Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk.

## 1. morluto/rea

GitHub: https://github.com/morluto/rea
Page: https://dedupedai.com/use-cases/morluto-rea/

A plug-in that lets your AI agent take apart an app and explain how a feature works.

Audience: For developers and security-minded builders who want an AI agent to take apart an app they can run locally and explain how a feature works, with evidence.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Requirements:
- Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+, plus npm
- An MCP-capable AI agent such as Claude Code, Codex, Cursor or Gemini CLI
- For native binaries: Hopper, Ghidra or IDA installed locally
- For websites: a Chrome-family browser
- On Linux: a procps-compatible ps on PATH for JavaScript/Electron analysis

### How to rebuild a feature you saw, in your own project with rea

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: Solo founder who wants a comparable feature in their product after studying how another app does it
Problem: You know what the feature does but not how to build it, and copying blindly risks missing key details.
Outcome: A working implementation in your project, grounded in what the agent observed in the target app.

Steps:
1. Run npx rea-agents setup and restart your agent.
2. Ask the agent to investigate the feature in the target app and explain it first.
3. Ask it to build a version for your project and test it.
4. Review the code and compare it against the evidence it listed.

Prompt:

```text
Use REA to investigate <feature> in <app> at <path>, show the evidence, then build a version for my project at <project path> and test it. Verify the result matches the behavior it observed, not just a guess.
```

Caveat: Reimplementing another product's behavior can raise copyright, license and terms-of-service issues. Write your own code and only study apps you are permitted to inspect.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112187888741822588
- X (Oct 2026): https://x.com/i/web/status/2112162379614314867
URL: https://dedupedai.com/use-cases/morluto-rea/build-similar-feature-for-my-project/

### How to map how a website's front end behaves with rea

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Frontend developer curious how a web app wires its UI to its scripts and requests
Problem: Minified scripts and network traffic make it hard to see how a web app actually works.
Outcome: A summary of the page structure, scripts and observed network requests for the site.

Steps:
1. Run npx rea-agents setup and restart your agent.
2. Make sure a Chrome-family browser is installed.
3. Ask your agent to observe the target website with REA and list scripts and network calls.
4. Ask it to explain the part of the behavior you care about.

Prompt:

```text
Use REA to observe <website url> in a browser and summarize its page structure, scripts and network requests. Explain how <feature> works and verify claims against the observed requests.
```

Caveat: Observation covers the client side only. Server logic can only be inferred from responses, and you should respect the site's terms of use.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112162379614314867
URL: https://dedupedai.com/use-cases/morluto-rea/inspect-web-player-from-browser/

### How to learn how a feature in another app works with rea

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Indie developer who likes a feature in a desktop app and wants to understand how it is built
Problem: The app has no public source code, so you cannot tell how the feature is put together.
Outcome: A written explanation of how the feature works, with the evidence listed and unknowns flagged.

Steps:
1. Run npx rea-agents setup, pick your agent, approve the changes, then restart the agent.
2. Ask your agent to investigate one specific feature in the target app using REA.
3. Ask it to show the evidence for each claim and mark anything it is guessing.
4. Read the explanation and ask follow-up questions about the parts you will reuse.

Prompt:

```text
Use REA to work out how <feature> works in <app> at <path>. Show the evidence, flag what you are guessing, and summarize the design in plain words. Verify every claim points to a file, symbol or observed behavior.
```

Caveat: Only analyze software you own or are licensed to inspect, and check the app's license terms. REA can only infer backend logic from what the client exposes.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112187888741822588
- Reddit: https://www.reddit.com/r/singularity/comments/1x2rrsi/reverse_engineer_anything_is_a_great_toolkit_what/
URL: https://dedupedai.com/use-cases/morluto-rea/learn-how-app-feature-works/

### How to pull apart a game's web build with rea

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Hobbyist or modder who wants to know how a cross-platform game's web build is put together
Problem: The web version ships as compiled WebAssembly, which you cannot read directly.
Outcome: A decoded view of the WASM imports, exports and sections, plus the agent's notes on what they suggest.

Steps:
1. Run npx rea-agents setup and restart your agent.
2. Download or locate the .wasm file from the game you are allowed to inspect.
3. Ask your agent to inspect the WASM artifact with REA and decode it.
4. Ask it to explain the notable imports and exports.

Prompt:

```text
Use REA to inspect the WASM artifact at <path to .wasm>, decode its sections and imports/exports, and explain what stands out. Verify against the decoded output and flag any guesses.
```

Caveat: WASM decoding needs the caller-supplied WABT 1.0.42 toolchain. Only inspect builds you have the right to analyze.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112166529236357176
URL: https://dedupedai.com/use-cases/morluto-rea/explain-game-wasm-build/

### How to understand traffic from a saved HAR or SAZ file with rea

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Developer debugging how an app talks to its server using a capture they already recorded
Problem: A raw capture has hundreds of requests and no clear picture of what the app actually sends.
Outcome: A readable breakdown of requests, responses and exposed payloads tied to source locations.

Steps:
1. Export your traffic as a HAR file or a Fiddler Everywhere SAZ file.
2. Run npx rea-agents setup and restart your agent.
3. Ask the agent to analyze the capture with REA.
4. Ask it to explain the calls behind the feature you are tracing.

Prompt:

```text
Use REA to analyze the network capture at <path to .har or .saz>, list the key requests and responses, and explain which calls drive <feature>. Verify each claim against a specific request in the capture.
```

Caveat: Captures may contain tokens and personal data, so scrub them before sharing. On Linux, native mitmproxy captures need mitmdump installed.
URL: https://dedupedai.com/use-cases/morluto-rea/replay-saved-network-capture/

### How to list modules and IPC in an Electron app with rea

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Developer vetting or learning from an Electron desktop app they have installed
Problem: Packaged Electron apps hide their structure inside bundled files, so you cannot easily see what talks to what.
Outcome: A JSON report of modules, imports, Electron boundaries and the evidence for each.

Steps:
1. Locate the extracted app directory or ASAR file on disk.
2. Run npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json
3. Read the report for modules, imports and Electron boundaries.
4. Feed the JSON to your agent and ask it to explain the feature you care about.

Prompt:

```text
Run REA's analyze-javascript-application on <path to extracted Electron app> and explain the main modules, imports and IPC boundaries. Verify each finding cites evidence from the report.
```

Caveat: On Linux you need a procps-compatible ps on PATH. Replace the example path with your own, such as a Windows path like D:/apps/example.
URL: https://dedupedai.com/use-cases/morluto-rea/analyze-electron-app-directory/

### How to list types and methods in a Unity game with rea

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Game modder or QA engineer who needs the class and method names in a shipped Unity game
Problem: IL2CPP compiles game code to native, hiding the original type and method names.
Outcome: A list of assembly images, types and methods with index ranges from the metadata file.

Steps:
1. Locate the global-metadata.dat file from the game you are allowed to inspect.
2. Run npx rea-agents setup and restart your agent.
3. Ask the agent to inspect the IL2CPP metadata with REA.
4. Ask it to summarize the types and methods related to the system you care about.

Prompt:

```text
Use REA to decode the IL2CPP metadata at <path to global-metadata.dat> and list assembly images, types and methods related to <system>. Verify names come from the decoded output.
```

Caveat: Static decoding supports metadata versions 29, 31 and 39 only. Check the game's terms before analyzing it.
URL: https://dedupedai.com/use-cases/morluto-rea/decode-unity-il2cpp-metadata/

### How to get readable pseudocode from a native binary with rea

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Engineer inheriting an old compiled tool whose source is lost, needing to know what one routine does
Problem: You only have the compiled binary and cannot read assembly fluently.
Outcome: Pseudocode, strings, symbols and call references for the routine, explained in plain words.

Steps:
1. Install Hopper, Ghidra or IDA locally and configure it as the provider.
2. Run npx rea-agents setup and restart your agent.
3. Ask the agent to open the binary and explain the function you care about.
4. Ask it to show the pseudocode and references it relied on.

Prompt:

```text
Use REA with my installed <Hopper, Ghidra or IDA> to analyze the binary at <path>, explain what <function or behavior> does, and show the pseudocode and references. Verify claims against the shown output.
```

Caveat: Needs a native analysis engine installed and configured; setup can optionally install Hopper with your approval. Only analyze binaries you own or are authorized to inspect.

Seen in the wild:
- Reddit: https://www.reddit.com/r/singularity/comments/1x2rrsi/reverse_engineer_anything_is_a_great_toolkit_what/
URL: https://dedupedai.com/use-cases/morluto-rea/understand-native-binary-behavior/

### How to check what an Android APK declares and does with rea

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: IT admin or security reviewer vetting an Android app before approving it for staff devices
Problem: You cannot tell what permissions and components an APK declares or how its key methods behave.
Outcome: A report of manifest declarations, classes and decompiled methods you can review.

Steps:
1. Install headless JADX if you do not have it.
2. Run npx rea-agents setup and restart your agent.
3. Ask the agent to analyze the APK with REA and list manifest declarations.
4. Ask it to decompile and explain the methods that handle the behavior you worry about.

Prompt:

```text
Use REA to analyze the APK at <path to apk>, list its manifest declarations and explain what <suspicious behavior> does in the decompiled methods. Verify each claim cites a class or method.
```

Caveat: APK analysis depends on JADX being available. Only inspect apps you are authorized to review; decompiled output is an approximation of the original code.
URL: https://dedupedai.com/use-cases/morluto-rea/audit-android-apk-manifest/

## 2. google-research/harness2

GitHub: https://github.com/google-research/harness2
Page: https://dedupedai.com/use-cases/google-research-harness2/

A framework that lets an AI agent keep improving its own setup (prompts, tools, memory, skills) while the model itself stays unchanged.

Audience: For builders who run LLM agents on professional tasks and want to improve the prompts, tools, memory and skills around a fixed model without fine-tuning it.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Requirements:
- Linux, Python 3.12 and uv for installation
- No credentials needed for the local demo (harness2-demo)
- Model-backed runs need Node.js 20+, the Google Cloud CLI, a Vertex AI project and model IDs in .env, and gcloud application-default login
- LAB needs Pandoc and Poppler; WorkBuddy-Bench needs Docker
- Model-backed benchmark runs incur API costs

### How to audit which harness edits were adopted and why with harness2

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Agent builder who wants to copy the winning edits into a hand-maintained harness instead of re-running refinement
Problem: You get a better score but do not know which of the eight editable components changed or what lesson justified it.
Outcome: A short list of concrete edits (system prompt, guardrails, memory, tool guidance and so on) with their stated evidence, ready to port by hand.

Steps:
1. Finish a refinement run, for example: harness2 --bench lab --k 1 --mode parallel --only-domains antitrust-competition --max-tasks 1
2. Open the benchmark folder under runs/ and find the adopted harnesses and reflection notes.
3. Compare the adopted harness against the base harness, component by component.
4. Note which edits came from the general candidate versus the domain-specific candidate.
5. Copy the edits you trust into your own agent setup.

Prompt:

```text
After a google-research/harness2 run on <benchmark>, open the runs/ folder and list every adopted harness edit grouped by component (system prompt, guardrails, memory, tool guidance, subagents, skills, scripts, plugins). Verify each edit has a matching reflection note before recommending I port it.
```

Caveat: The README does not document the exact file layout inside runs/, so inspect the actual output folders rather than assuming a structure, and treat a single run's lessons as hypotheses.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112193309238329415
- X (Oct 2026): https://x.com/i/web/status/2112219976056914081
URL: https://dedupedai.com/use-cases/google-research-harness2/audit-which-harness-edits-actually-stuck/

### How to watch an agent improve its own setup in 5 minutes, no API key with harness2

Difficulty: Beginner | Time: 15 minutes | Basis: Seen in the wild

Who: Curious developer who saw Harness2 trending and wants proof it runs before investing in setup
Problem: You cannot tell whether a self-improving harness framework actually works without wiring up models and paying for API calls.
Outcome: A runs/demo folder showing parallel and sequential recursion with deterministic editors, produced locally in seconds.

Steps:
1. Create the environment: uv venv --python 3.12 .venv
2. Activate it: source .venv/bin/activate
3. Install the package: uv pip install -e '.[render]'
4. Run the demo: harness2-demo --output runs/demo --k 2
5. Open the runs/demo folder and read the adopted harnesses and reflection notes.

Prompt:

```text
Clone google-research/harness2, set up a Python 3.12 uv environment, install it, and run harness2-demo with --k 2 into runs/demo. Summarize what files were produced and verify the demo ran without any model credentials.
```

Caveat: The demo uses deterministic editors, not real models, so it shows the mechanics of the loop and says nothing about real-world score gains.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112227371847729175
URL: https://dedupedai.com/use-cases/google-research-harness2/try-self-improving-agent-demo-no-keys/

### How to boost an office, web or coding agent on WorkBuddy tasks with harness2

Difficulty: Advanced | Time: 2 hours | Basis: Seen in the wild

Who: Builder of an internal assistant that edits documents, browses, or writes code and wants a measurable harness upgrade
Problem: Hand-tuning prompts for office, web and code tasks is guesswork with no consistent score to compare against.
Outcome: A judged WorkBuddy run for one subset showing whether a Propose-Probe-Compose step beat the base harness.

Steps:
1. Install the benchmark (needs Docker): harness2-setup wb
2. Check prerequisites: harness2-check --bench wb --subset office
3. Refine one task (inferred, adapting the LAB example to WorkBuddy): harness2 --bench wb --subset office --k 1 --mode parallel --max-tasks 1
4. Judge and report with matching flags: harness2-judge --bench wb --subset office --k 1 --mode parallel
5. Read the report: harness2-report --bench wb --subset office --k 1 --mode parallel

Prompt:

```text
In google-research/harness2, set up WorkBuddy-Bench with harness2-setup wb and run one task from --subset office with --k 1 --mode parallel, then judge and report with identical flags. Verify Docker is running first and that the subset flag is passed on every command after setup.
```

Caveat: WorkBuddy-Bench needs Docker and the --subset flag on every command after setup, and the README guide for WorkBuddy should be checked for the exact task-selection flags before running.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112341275932586114
URL: https://dedupedai.com/use-cases/google-research-harness2/improve-office-web-code-agent-workbuddy/

### How to test whether harness edits lift your agent on legal tasks with harness2

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Legal-tech engineer whose agent drafts antitrust or competition analysis and who wants evidence that prompt and tool edits help
Problem: You cannot tell if rewriting your agent's prompts and guardrails improves legal output without a repeatable before/after run.
Outcome: A judged and reported result for one LAB task, with the adopted harness and reflection notes saved under runs/.

Steps:
1. Install the benchmark: harness2-setup lab
2. Check prerequisites: harness2-check --bench lab
3. Refine one task: harness2 --bench lab --k 1 --mode parallel --only-domains antitrust-competition --max-tasks 1
4. Judge the result: harness2-judge --bench lab --k 1 --mode parallel
5. Read the summary: harness2-report --bench lab --k 1 --mode parallel

Prompt:

```text
In google-research/harness2, run the LAB benchmark for one antitrust-competition task with --k 1 --mode parallel, then run harness2-judge and harness2-report with the same flags. Confirm judge and report used identical benchmark, k, mode and seed as the refinement run.
```

Caveat: Judge and report must use the same benchmark, executor, subset, --k, --mode and seed as the refinement run, and model-backed runs cost real API money, so keep --max-tasks at 1.
URL: https://dedupedai.com/use-cases/google-research-harness2/test-harness-refinement-on-legal-tasks/

### How to run a clean benchmark with network limits against rubric leaks with harness2

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Researcher reporting harness-improvement numbers who must show the agent could not read public rubrics
Problem: Executors have open web access and public rubrics may exist online, so scores can be inflated by looking up answers.
Outcome: A benchmark run done under network restrictions, giving numbers you can defend as not contaminated by leaked grading criteria.

Steps:
1. Read the web access section of docs/EXPERIMENTS.md and apply its network restrictions.
2. Preview task selection with no model calls by adding --dry-run to your harness2 command.
3. Run the real refinement: harness2 --bench lab --k 1 --mode parallel --only-domains antitrust-competition --max-tasks 1
4. Judge: harness2-judge --bench lab --k 1 --mode parallel
5. Report: harness2-report --bench lab --k 1 --mode parallel

Prompt:

```text
Before running any model-backed benchmark in google-research/harness2, read the web access section in docs/EXPERIMENTS.md and tell me what network restrictions to configure for <benchmark>. Then run a --dry-run preview and verify task selection looks right.
```

Caveat: Authorized use only: run this only inside infrastructure you control, since the README states executors have unrestricted network access and Codex runs with its sandbox disabled, and public rubrics may be online.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112265188091265326
- X (Oct 2026): https://x.com/i/web/status/2112254069184344121
URL: https://dedupedai.com/use-cases/google-research-harness2/benchmark-agent-harness-without-answer-leaks/

### How to compare parallel and sequential refinement on the same task with harness2

Difficulty: Intermediate | Time: 2 hours | Basis: From the README

Who: ML engineer deciding how to spend an agent-refinement compute budget on a recurring task type
Problem: It is unclear whether exploring many candidates at once or refining step by step gives better results per dollar for your task.
Outcome: Two reports for the same task, one per mode, that you can compare side by side to choose a strategy.

Steps:
1. Run parallel mode: harness2 --bench lab --k 2 --mode parallel --only-domains antitrust-competition --max-tasks 1
2. Run sequential mode: harness2 --bench lab --k 2 --mode sequential --only-domains antitrust-competition --max-tasks 1
3. Judge each run: harness2-judge --bench lab --k 2 --mode parallel and harness2-judge --bench lab --k 2 --mode sequential
4. Report each run: harness2-report --bench lab --k 2 --mode parallel and harness2-report --bench lab --k 2 --mode sequential
5. Compare the two reports and the adopted harnesses.

Prompt:

```text
Using google-research/harness2, run LAB on one task with --k 2 in both parallel and sequential modes, judge and report each, and tabulate the scores side by side. Verify both runs used the same task selection and seed before comparing.
```

Caveat: A single task is a very noisy comparison, and the README ties each judge and report call to its own mode, k and seed, so run the full command set once per mode.
URL: https://dedupedai.com/use-cases/google-research-harness2/compare-parallel-vs-sequential-recursion/

### How to run harness refinement with the Codex executor with harness2

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Developer who already uses Codex as a coding agent and wants harness improvements tuned to that executor
Problem: Harness edits that help one executor may not carry over to another, and you have no way to check without a controlled run.
Outcome: A refinement run on Codex whose results are stored separately so you can compare it against an OpenCode run.

Steps:
1. Read the Codex executor section in docs/SETUP.md and finish its prerequisites.
2. Install a benchmark: harness2-setup jb
3. Run with Codex: harness2 --bench jb --k 1 --mode parallel --substrate cx --max-tasks 1
4. Use a fresh HARNESS2_RUNS_DIR when changing models or task selection.
5. Judge and report with matching flags: harness2-judge --bench jb --k 1 --mode parallel --substrate cx

Prompt:

```text
In google-research/harness2, run one JobBench task with --substrate cx and --k 1 --mode parallel, then judge it with matching flags. Verify the run completes under its own runs directory and that network restrictions are configured first.
```

Caveat: Codex runs with its sandbox disabled and executors get open web access, so run it only in an isolated environment, and confirm whether judge and report also need the substrate flag in the experiment guide.
URL: https://dedupedai.com/use-cases/google-research-harness2/swap-codex-executor-into-agent-loop/

### How to resume a long refinement run after it stops midway with harness2

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Researcher running a larger JobBench or LAB sweep that was interrupted by a crash or quota limit
Problem: Long model-backed runs cost money, and restarting from scratch after an interruption wastes both time and API spend.
Outcome: A completed run that picked up where it stopped, with results kept under the same runs directory.

Steps:
1. Note the exact command you used, including --bench, --k, --mode, any subset flags and seed.
2. Re-run the identical harness2 command to resume.
3. Use a new HARNESS2_RUNS_DIR only if you changed models or task selection.
4. Run harness2-judge and harness2-report with the same flags once refinement finishes.
5. Check each command's --help for extra options.

Prompt:

```text
My google-research/harness2 run on <benchmark> stopped partway. Reconstruct the exact original command, re-run it to resume, and verify that previously finished tasks were not repeated by checking the runs/ folder.
```

Caveat: Resume only works when you repeat the same benchmark, executor, subset, --k, --mode and seed, and changing models or task selection requires a new HARNESS2_RUNS_DIR.
URL: https://dedupedai.com/use-cases/google-research-harness2/resume-interrupted-multi-task-refinement-run/

## 3. debpalash/VoiceStudio

GitHub: https://github.com/debpalash/VoiceStudio
Page: https://dedupedai.com/use-cases/debpalash-voicestudio/

A free local app for voice cloning, dubbing, transcription and audiobooks in 646 languages.

Audience: For creators, small teams and privacy-minded builders who want voice cloning, dubbing and audiobooks on their own machine instead of a paid cloud voice service.

Requirements:
- macOS, Windows or Linux desktop (Intel Mac runs the UI only and needs a remote backend)
- NVIDIA GPU (CUDA) or Apple Silicon (Metal) recommended; CPU-only works but is slower and needs about 5 GB free disk
- Git, Node.js 22+, Bun and Rust/Cargo only if building from source
- Speech models are downloaded on demand through the app; no paid keys or accounts required

### How to replace a paid cloud voice tool with a free local one with VoiceStudio

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Solo creator paying monthly for a cloud voice-cloning service and uneasy about uploading voice recordings
Problem: Cloud voice tools charge monthly and send your voice data to someone else's servers.
Outcome: A working local app that turns typed text into speech in a cloned or designed voice, with nothing leaving your machine.

Steps:
1. Run `curl -fsSL https://voicestudio.sh/install | sh` on macOS or Linux, or `irm https://voicestudio.sh/install | iex` in PowerShell on Windows.
2. Open the app and go to the Voice cloning workspace.
3. Choose a bundled voice or add a clean reference recording, then install the required model when prompted.
4. Type your text and generate the audio.

Prompt:

```text
Install the VoiceStudio Electron app on this device and verify it works, following https://github.com/debpalash/VoiceStudio/blob/main/docs/install/agent.md. Confirm a test generation produces audio, and ask me before any model download.
```

Caveat: The app is AGPL-3.0 but model weights carry separate terms (some reports cite non-commercial licenses), so check the model notices in Model Manager before any paid work.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111832943140438047
- X (Oct 2026): https://x.com/i/web/status/2111704011988688976
- Reddit: https://i.redd.it/8lsmr26tdwrh1.png
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/replace-paid-cloud-voice-service-locally/

### How to dub a video into another language with timed speech with VoiceStudio

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: YouTuber or course maker who wants one video to reach viewers in another language
Problem: Hiring dubbing or paying per minute for cloud dubbing is expensive for a small channel.
Outcome: A dubbed version of the video with speech timed to the original, made locally.

Steps:
1. Install the app from the latest release or with the one-command installer.
2. Open the Video dubbing workspace and load your video file.
3. Pick the target language and a voice, then install any model the app asks for.
4. Run the dub and review the result against the original.

Prompt:

```text
Using debpalash/VoiceStudio, dub <video file> into <target language> through the Video dubbing workspace. Check that the dubbed speech stays in sync with the original and report any segments that drift.
```

Caveat: Dubbing quality varies by language and engine, and a CPU-only run will be noticeably slower on long videos.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112357058704273439
- X (Oct 2026): https://x.com/i/web/status/2111397103067087134
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/dub-video-into-another-language/

### How to give your AI agent a local text-to-speech tool through MCP with VoiceStudio

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Developer building an agent workflow that needs to speak or produce voiceovers without a paid API
Problem: Hosted speech APIs add cost, keys and data exposure to an agent pipeline.
Outcome: An agent that calls your local VoiceStudio to produce audio files on request.

Steps:
1. Install and run the app, and make sure a speech model is installed.
2. Read docs/mcp.md and docs/speech-platform.md in the repo for the local API and MCP setup.
3. Register the local MCP server in your agent's config using the details from those docs.
4. Ask the agent to generate a short clip and confirm the audio file appears.

Prompt:

```text
Set up debpalash/VoiceStudio's local MCP server for this agent by following docs/mcp.md in the repo, then generate a short spoken clip of <text>. Verify the audio file exists and plays.
```

Caveat: The README only points to the MCP and API docs, so exact config keys and ports must come from those docs, not from guesses.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111832943140438047
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/let-an-agent-call-local-voice-api-or-mcp/

### How to run voice generation on an older laptop with no graphics card with VoiceStudio

Difficulty: Beginner | Time: 45 minutes | Basis: Seen in the wild

Who: Student or hobbyist on an older laptop who wants to try local voice AI without buying a GPU
Problem: Most local AI voice tools assume an expensive NVIDIA card.
Outcome: A working, if slower, local voice setup on integrated graphics or an older PC.

Steps:
1. Make sure you have about 5 GB of free disk space.
2. Install with `curl -fsSL https://voicestudio.sh/install | sh` (or the PowerShell command on Windows).
3. Let setup install the small CPU build of PyTorch.
4. Generate a short test clip and note how long it takes.

Prompt:

```text
Install debpalash/VoiceStudio on this CPU-only machine and generate a 10-second test clip from <text>. Report the generation time and confirm the audio plays.
```

Caveat: CPU mode is slower, Windows on ARM is experimental, and Intel Macs only run the UI against a remote backend.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112357058704273439
- X (Oct 2026): https://x.com/i/web/status/2112063488189509922
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/run-voice-work-on-a-laptop-without-a-gpu/

### How to turn a finished manuscript into an audiobook with VoiceStudio

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: Self-publishing author with a finished manuscript and no budget for a narrator
Problem: Professional narration costs far more than a first-time author can spend.
Outcome: A narrated audiobook rendered locally from the manuscript text.

Steps:
1. Install the app and open the Stories and audiobooks area.
2. Paste or load your manuscript and choose a voice.
3. Start the render and let it run to completion.
4. Listen through the output and fix any chapters that read badly.

Prompt:

```text
Use debpalash/VoiceStudio to render <manuscript file> as an audiobook with <voice>. Verify that every chapter produced audio and that the final file plays through without gaps.
```

Caveat: Long renders are heavy; users have reported progress-on-resume bugs and overlapping renders deleting each other's audio, so render one book at a time and keep a backup of finished chapters.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112357058704273439
- X (Oct 2026): https://x.com/i/web/status/2112031088268693966
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/turn-a-manuscript-into-an-audiobook/

### How to design a brand-new voice from a text description with VoiceStudio

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Indie game developer or narrator who needs a distinct character voice and has no actor
Problem: Without a recorded sample, there is no easy way to get a custom character voice.
Outcome: A usable generated voice that fits the character, produced locally.

Steps:
1. Install the app and open the Voice design workspace.
2. Describe the voice you want in plain words.
3. Generate sample lines and adjust the description until it fits.
4. Use the voice for your script in the generation workspace.

Prompt:

```text
With debpalash/VoiceStudio, design a voice matching <voice description> and generate <script line>. Check that the voice stays consistent across two different lines.
```

Caveat: Designed voices can drift between generations, so test consistency before committing a whole script.
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/design-a-new-voice-from-a-description/

### How to batch-produce voiceovers from a watched folder with VoiceStudio

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Content team producing weekly narration for dozens of short scripts
Problem: Rendering each script by hand in a GUI is slow and repetitive.
Outcome: Scripts dropped into a folder come out as finished audio using a saved recipe.

Steps:
1. Install the app and set up one voice and settings you like.
2. Save that setup as a reusable recipe, as described in the repo docs.
3. Point a watch folder at your scripts directory.
4. Drop in a few scripts and check that each produces an audio file.

Prompt:

```text
Using debpalash/VoiceStudio, configure a recipe and watch folder for <scripts directory> so each new script renders to audio. Verify one test script produces output with the expected voice.
```

Caveat: The README names recipes and watch folders but gives no setup commands here, so follow the in-repo docs and expect to experiment.
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/batch-voiceovers-with-recipes-and-watch-folders/

### How to transcribe interviews and dictate text without the cloud with VoiceStudio

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Journalist or researcher with sensitive interview audio that cannot go to a cloud transcriber
Problem: Uploading private recordings to a hosted transcription service is a privacy risk.
Outcome: Text transcripts of your audio, plus dictated text, produced entirely on your own hardware.

Steps:
1. Install the app and open the transcription workspace.
2. Load an audio or video file, or start the floating dictation widget.
3. Install the speech model when prompted and run the transcription.
4. Copy the transcript out and proofread it against the audio.

Prompt:

```text
Use debpalash/VoiceStudio to transcribe <audio file> locally. Return the transcript and verify a few spot-checked passages against the recording.
```

Caveat: The README lists transcription and dictation as features but does not publish accuracy figures, so always proofread names and numbers.
URL: https://dedupedai.com/use-cases/debpalash-voicestudio/transcribe-recordings-and-dictate-offline/

## 4. wheresryan22/anatomy

GitHub: https://github.com/wheresryan22/anatomy
Page: https://dedupedai.com/use-cases/wheresryan22-anatomy/

An agent skill that builds interactive illustrations of machines and complex systems to explain an idea.

Audience: Anyone who explains technical ideas or physical systems and wants an interactive diagram instead of a static chart, mainly people already using Claude Code or a similar coding agent.

Requirements:
- An agent that supports Agent Skills: Claude Code, Antigravity, OpenCode, Codex or MiniMax Code
- Node.js 20.10 or later (the skills CLI itself may need a newer Node, 22.20 or later for version 1.7.1)
- Model usage costs from your agent account; the kit has no extra API keys or npm dependencies
- A browser to open the finished HTML pages (WebGL for the effects layer)

### How to read and sandbox a brand new skill before you install it with anatomy

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: Cautious developer about to install a viral agent skill from a days-old repo
Problem: New skills run code with your agent's access, and a trending repo can still hide risky scripts.
Outcome: A checked install where you have read the install scripts and hooks and ran it in an isolated environment first.

Steps:
1. Clone or download the repo and read SKILL.md and any install scripts first.
2. Look for auto-run hooks, odd obfuscation or hidden characters in the files.
3. Install in a throwaway project or sandbox: npx skills add wheresryan22/anatomy
4. Only install globally with -g after you are comfortable.

Prompt:

```text
Review the wheresryan22/anatomy repo for install scripts, auto-run hooks, hidden Unicode and obfuscation, and summarize anything risky before I install it. List the files you checked.
```

Caveat: A review is only as good as what you read, and the README says the kit uses no npm dependencies, so confirm that yourself.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111608344611844268
- X (Oct 2026): https://x.com/i/web/status/2111459791780401180
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/vet-a-new-agent-skill-before-installing/

### How to publish an interactive explainer of how a network works with anatomy

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: Community organizer or maintainer who wants newcomers to understand how their network moves a message
Problem: Newcomers do not grasp what happens between pressing send and the message arriving.
Outcome: A public interactive explainer page, in more than one language if you ask for it.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. Describe the flow you want explained with /anatomy and ask for a standalone HTML page.
3. Test the page and fix unclear labels with follow-up requests.
4. Host the HTML file on any static site.

Prompt:

```text
Using wheresryan22/anatomy, build an interactive explainer of how <message or data flow> travels through <network>. Output a hostable HTML page and verify each step in the flow is clickable.
```

Caveat: Review the technical claims in the figure before publishing, since the agent may simplify or misstate protocol details.

Seen in the wild:
- Reddit: https://v.redd.it/xg6nyvw8bbvh1
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/build-an-interactive-network-explainer/

### How to show a client how a process works with a 3D figure with anatomy

Difficulty: Beginner | Time: 45 minutes | Basis: Seen in the wild

Who: Consultant or architect who struggles to explain a process to a client in words
Problem: Clients lose the thread in text-only explanations of multi-step systems.
Outcome: An interactive figure the client can rotate and click through, shared as an HTML page.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g -a claude-code
2. Describe the process in one sentence with /anatomy and name the key stages.
3. Open the generated page and walk the client through the parts.
4. Export or share the HTML page after checking the labels.

Prompt:

```text
Use wheresryan22/anatomy to build an interactive figure that explains <client process> as a machine with clickable parts. Confirm every stage is labeled and the readout makes sense to a non-technical viewer.
```

Caveat: Invented metaphors can mislead a client if a detail is wrong, so review each label against your real process before showing it.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111850650791555179
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/explain-a-process-to-a-client-visually/

### How to turn a one-line question into a clickable machine cutaway with anatomy

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Curious learner or teacher who wants to see how a real machine works after reading a trending post
Problem: Text explanations of engines, locks and other mechanisms are hard to picture.
Outcome: A standalone interactive HTML page showing the machine in cutaway, with parts you can inspect and a live readout.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g -a claude-code
2. Open Claude Code in an empty folder.
3. Run: /anatomy explain how a door lock works, interactive
4. Open the generated HTML page in your browser and hover or click the parts.

Prompt:

```text
Use the anatomy skill from wheresryan22/anatomy to build an interactive isometric figure explaining how <machine, e.g. a turbofan engine> works. Save it as a standalone HTML page, then check that hovering a part updates the live readout.
```

Caveat: Long runs are reported, so expect around half an hour for a detailed figure, and the model's idea of how the machine works is not an engineering reference.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112075586260857265
- X (Oct 2026): https://x.com/i/web/status/2111608344611844268
- X (Oct 2026): https://x.com/i/web/status/2111760807197356259
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/explain-how-a-machine-works-interactively/

### How to draw a teardown of a product from its public specs with anatomy

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Tech blogger or hobbyist who read a launch claim and wants a visual explainer of what is inside
Problem: Specs and press claims about internals are hard to follow without a picture.
Outcome: An interactive isometric figure of the device with its main parts, built from the specs you supply.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. Run: /anatomy <the machine you want>, listing the parts and spec numbers you want modeled.
3. Open the page and use the exploded view to inspect the assemblies.
4. Ask for fixes where a part or number looks wrong.

Prompt:

```text
Use the anatomy skill from wheresryan22/anatomy to build an exploded interactive figure of <product>, using these specs: <specs>. Verify every number shown in the figure matches the specs I gave.
```

Caveat: The figure is an illustration based on the specs you provide and the model's guesses, not a verified engineering drawing.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111459589107470640
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/visualize-a-product-or-vehicle-teardown/

### How to give a hobby app an isometric machine-style interface with anatomy

Difficulty: Advanced | Time: 2 hours | Basis: Seen in the wild

Who: Hobbyist building a small web remote or dashboard who wants a distinctive visual style
Problem: Plain buttons and sliders make a hobby project look generic.
Outcome: A web interface where controls look like parts of an isometric machine, built with the skill's shading and camera.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. Ask Claude Code to use /anatomy to design the control panel for your project.
3. Wire the generated figure to your app's real actions.
4. Test each control and fix mismatches between the drawing and behavior.

Prompt:

```text
Use the anatomy skill from wheresryan22/anatomy to design an isometric control panel for <my small app>. Make sure each drawn control triggers the right action.
```

Caveat: The skill makes figures to explain things, so connecting it to real app logic is custom work by you and the agent.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111471785946562815
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/design-an-isometric-ui-for-a-small-app/

### How to export an explainer figure as SVG or React components with anatomy

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Frontend developer adding an interactive diagram to a docs site or landing page
Problem: A diagram made in a design tool is static and hard to keep in sync with the page.
Outcome: A figure delivered as an SVG file with embedded styles, or as React components you drop into your site.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g -a claude-code
2. Run /anatomy with your idea and ask for the output format you need, SVG or React.
3. Place the exported file or components in your project.
4. Load the page and check the figure renders and responds to hover.

Prompt:

```text
Use wheresryan22/anatomy to create a figure explaining <idea> and export it as <SVG or React components>. Verify it renders correctly inside <my site or framework>.
```

Caveat: The README lists HTML, SVG and React and Next.js outputs, but how a figure fits into your build setup is up to you.
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/export-a-figure-as-svg-or-react/

### How to build a figure with a dial or part that turns in 3D with anatomy

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Tinkerer who wants an explainer where one moving part rotates in true 3D
Problem: Static isometric art cannot show a part spinning or flexing.
Outcome: A figure where the moving parts are re-projected and re-shaded every frame as you drag, like the README's turning dial.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. Ask /anatomy for a figure with a dial or turntable that spins in 3D.
3. Drag the part in the browser and watch the shading update.
4. Keep the rest of the figure static so it stays light.

Prompt:

```text
Use the 3D mode of wheresryan22/anatomy to build a figure of <object with a rotating part>. Verify the part turns smoothly when dragged.
```

Caveat: The README marks 3D as beta and only the moving parts are re-projected each frame, so expect rough edges.
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/make-a-spinnable-3d-part-in-a-figure/

### How to explain a software concept as a working physical object with anatomy

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Developer or technical writer preparing docs or a blog post on an abstract concept such as a token bucket
Problem: Abstract ideas like caching or rate limiting are hard to show in a plain diagram.
Outcome: An interactive figure where a physical mechanism (the README gives a pin-tumbler lock for a cache key) stands in for the concept, ready to embed.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. In Claude Code run: /anatomy explain how a token bucket rate limiter works, interactive
3. Interact with the result and check that the figure's numbers change as you play with it.
4. Ask the agent to adjust the metaphor if it does not match your concept, then regenerate.

Prompt:

```text
Using wheresryan22/anatomy, build an interactive figure that explains <software concept> as a physical mechanism. Output a single HTML page and verify the live readout matches the concept's real behavior.
```

Caveat: The mechanism is an invented analogy, so review it for accuracy before publishing it as documentation.
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/explain-a-software-concept-as-a-physical-object/

### How to add live fire, water or light effects to a figure with anatomy

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Educator or designer making a physics or engineering explainer that needs motion effects
Problem: Flat vector drawings cannot show fire, fluid or light in motion.
Outcome: A figure whose WebGL layer draws the effect in the same isometric camera as the SVG parts, like the README's engine plume and ripple tank.

Steps:
1. Install the skill: npx skills add wheresryan22/anatomy -g
2. Describe a machine that needs an effect, for example a rocket engine firing.
3. Open the page and trigger the effect; check it sits inside the drawing.
4. Test in a browser with WebGL enabled, since the SVG alone shows no effect.

Prompt:

```text
Use wheresryan22/anatomy to build a figure of <machine with fire, water or light> with a WebGL effect layer. Verify the effect lines up with the SVG parts and the figure still reads without WebGL.
```

Caveat: Shader effects need a browser with WebGL and can be slower on weak hardware.
URL: https://dedupedai.com/use-cases/wheresryan22-anatomy/add-fire-water-and-glow-effects-to-a-diagram/

## 5. stablyai/orca

GitHub: https://github.com/stablyai/orca
Page: https://dedupedai.com/use-cases/stablyai-orca/

A desktop and mobile app to run Claude Code, Codex, OpenCode and other coding agents side by side, each in its own workspace, on your own subscriptions.

Audience: Developers who already pay for one or more coding agent CLIs (Claude Code, Codex, OpenCode and others) and want to run several at once without them stepping on each other's files.

Requirements:
- macOS, Windows or Linux desktop (README badge lists all three)
- At least one coding agent CLI installed and signed in with your own subscription, such as Claude Code, Codex or OpenCode
- A git repository to work in, since each agent runs in its own git worktree
- Optional: iPhone or Android phone for the mobile companion app
- Optional: a remote machine reachable over SSH for SSH worktrees

### How to turn a GitHub PR or Linear issue into its own agent workspace with orca

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Developer triaging a backlog who wants each ticket handled in a clean, separate checkout
Problem: Switching branches for every ticket leaves half-finished work behind and mixes agent changes together.
Outcome: Each task gets its own worktree and agent, and you review the result without leaving the app.

Steps:
1. Connect GitHub or Linear in Orca following the review docs.
2. Pick a PR, issue or board item from the in-app list.
3. Open a worktree from that task and start your preferred agent in it.
4. Review the agent's changes in the diff view when it finishes.

Prompt:

```text
Using stablyai/orca, open a worktree from the GitHub issue or Linear task <issue link> and start Claude Code on it. Report which branch the worktree is on and verify it does not touch my main checkout.
```

Caveat: The README only says GitHub and Linear are supported natively, so other trackers such as Jira are not covered.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112362647803031874
- Reddit: https://i.redd.it/evl3b17jb7rh1.png
URL: https://dedupedai.com/use-cases/stablyai-orca/work-pr-and-linear-tasks-in-worktrees/

### How to get a phone alert when an agent finishes and send follow-ups with orca

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Developer who kicks off long agent runs, then walks away from the desk
Problem: You keep checking a terminal to see if an agent is done or waiting on you.
Outcome: Your phone notifies you when an agent finishes, and you send the next instruction without going back to your computer.

Steps:
1. Install the Orca desktop app and start an agent on a task.
2. Install the Orca mobile app from the iOS App Store or the Android APK link in the README.
3. Pair the phone with your desktop by following the mobile docs.
4. Walk away, wait for the finish notification, then send a follow-up from the phone.

Prompt:

```text
Using stablyai/orca, walk me through pairing the mobile companion app with my desktop Orca on <my OS>. Confirm what I should see on the phone when an agent finishes, and tell me how to verify notifications are enabled.
```

Caveat: The desktop app must stay running for the phone to reach your agents, and one issue thread suggests updating both phone and desktop if the companion misbehaves.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112362647803031874
- X (Oct 2026): https://x.com/i/web/status/2112156299580649725
URL: https://dedupedai.com/use-cases/stablyai-orca/steer-agents-from-your-phone/

### How to run agents on a bigger remote machine over SSH with orca

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Developer whose laptop is too slow or too small to run several agents and their builds at once
Problem: Parallel agents plus test runs overwhelm a laptop, but plain SSH sessions are fiddly to keep alive.
Outcome: Agents work in worktrees on the remote machine while you edit, review and use terminals locally, with reconnects handled for you.

Steps:
1. Make sure you can SSH into the remote machine and that your agent CLI is installed there.
2. Add the remote host as an SSH worktree in Orca by following the SSH docs.
3. Start an agent in a remote worktree and watch it from the Orca window.
4. Use port forwarding to preview any dev server the agent starts.

Prompt:

```text
Using stablyai/orca, help me set up an SSH worktree for <user@host> and repo <path on remote>. Tell me how to confirm auto-reconnect works after I drop the connection.
```

Caveat: One HN user reported trouble installing on a headless server and fell back to a machine with a desktop, so a pure headless box may need extra effort.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112067084913942686
- Hacker News (Sep 2026): https://news.ycombinator.com/item?id=49606598
URL: https://dedupedai.com/use-cases/stablyai-orca/run-agents-on-remote-ssh-box/

### How to fan one prompt across five agents and merge the best result with orca

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Developer stuck on a tricky refactor who wants more than one agent's attempt before committing
Problem: Trying one agent at a time is slow, and agents sharing one checkout overwrite each other's changes.
Outcome: You get several independent attempts at the same task, each on its own branch, and merge only the one you like.

Steps:
1. Install Orca and open your repo in it.
2. Start Claude Code, Codex and OpenCode, each in its own worktree.
3. Paste the same prompt into each agent.
4. Review each worktree's diff side by side, then merge the winner.

Prompt:

```text
Using stablyai/orca, set up parallel worktrees in <my repo> and run Claude Code, Codex and OpenCode on this task: <task description>. Show me each agent's diff so I can compare, and verify no agent touched files outside its own worktree.
```

Caveat: Each agent burns tokens on your own subscription, so fanning one prompt across five agents multiplies usage and can hit rate limits fast.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112088192568738199
- Reddit: https://i.redd.it/cuhji7c09ovh1.png
URL: https://dedupedai.com/use-cases/stablyai-orca/compare-agents-on-one-prompt/

### How to comment on an agent's diff lines and send fixes back with orca

Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Who: Reviewer who got a mostly right agent change and wants to correct a few lines without retyping context
Problem: Describing 'fix the third function in that file' in chat is vague and the agent often changes the wrong thing.
Outcome: The agent receives line-level comments, revises the code, and you commit from the same window.

Steps:
1. Open the agent's worktree and view its diff in Orca.
2. Click a changed line and write a comment saying what to fix.
3. Send the comments back to the agent.
4. Check the updated diff, then commit when it looks right.

Prompt:

```text
Using stablyai/orca, show me how to annotate lines in the AI diff for <worktree name> and send the comments back to the agent. Verify the agent's next diff addresses each comment.
```

Caveat: Annotations are only as good as the agent's willingness to follow them, so recheck the new diff instead of assuming every comment was applied.
URL: https://dedupedai.com/use-cases/stablyai-orca/annotate-agent-diff-and-send-back/

### How to point at a UI element and send its HTML and CSS to an agent with orca

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Front-end developer fixing a visual bug who cannot easily describe which element is wrong
Problem: Telling an agent 'the button in the header looks off' leads to guesses about the wrong component.
Outcome: The agent gets the element's real HTML, CSS and a cropped screenshot, so its fix targets the right code.

Steps:
1. Run your web app and open it in Orca's embedded Chromium browser.
2. Turn on Design Mode and click the misbehaving element.
3. Send the captured HTML, CSS and screenshot into an agent prompt.
4. Ask the agent to fix the issue and check the result in the same browser.

Prompt:

```text
Using stablyai/orca, open <local dev URL> in Design Mode, capture the element <describe element>, and send it to Claude Code with the request: <what to change>. Verify the agent edited the component that renders that element.
```

Caveat: Design Mode captures what the browser renders, so framework-generated class names may not map obviously to source files and the agent may still need to search.
URL: https://dedupedai.com/use-cases/stablyai-orca/click-ui-element-into-agent-prompt/

### How to let an agent operate a desktop app when a task needs real clicks with orca

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Developer whose task requires poking at a native or visual app that has no API
Problem: Some checks, like confirming a desktop app renders correctly, cannot be done from a terminal alone.
Outcome: The agent operates the visible UI as part of the workflow and reports what it saw.

Steps:
1. Read the Computer Use docs linked from the README.
2. Enable the feature for the agent you want to use.
3. Give the agent a narrow task on a specific app.
4. Watch its actions and stop it if it goes off track.

Prompt:

```text
Using stablyai/orca's Computer Use feature, have an agent open <app name> and perform <specific check>. Verify by reading back what the agent reports it clicked and saw.
```

Caveat: Computer Use lets an agent control visible apps on your machine, so run it only on non-sensitive sessions and watch what it clicks.
URL: https://dedupedai.com/use-cases/stablyai-orca/let-agents-operate-desktop-apps/

### How to let an agent create worktrees and drive the app via Orca CLI with orca

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Advanced builder automating a repeatable agent workflow instead of clicking through the app
Problem: Manually creating worktrees and prompting each agent does not scale when you run the same setup daily.
Outcome: A script or agent creates worktrees and drives the browser using Orca's own commands.

Steps:
1. Read the Orca CLI overview docs to see the available commands.
2. Run orca worktree create for a new task branch.
3. Use the snapshot, click and fill commands to drive a page from a script or an agent.
4. Wire the commands into your own automation once one run works.

Prompt:

```text
Using stablyai/orca's CLI, write a short script that runs orca worktree create for <branch name> and then uses snapshot, click and fill on <local page URL>. Verify each command's output before chaining them.
```

Caveat: Only the command names worktree create, snapshot, click and fill appear in the README excerpt, so check the CLI docs for exact arguments before scripting.
URL: https://dedupedai.com/use-cases/stablyai-orca/script-orca-with-agent-driven-cli/

### How to watch Claude and Codex usage and swap accounts at limits with orca

Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Who: Heavy agent user who keeps hitting subscription limits in the middle of a task
Problem: You only learn a limit is hit when an agent stops, and re-logging into another account wastes time.
Outcome: You see usage and reset times in one place and hot-swap to a second account to keep working.

Steps:
1. Open Orca's account switcher and add your Claude or Codex accounts per the usage tracking docs.
2. Run your agents as usual and watch the usage readout.
3. When a limit is near, switch to the other account.
4. Resume the agent without a fresh login.

Prompt:

```text
Using stablyai/orca, explain how to add a second Claude or Codex account to the account switcher and read the usage and reset information. Verify which account an active agent is currently using.
```

Caveat: The README names Claude and Codex for usage tracking only, and swapping accounts to dodge limits may conflict with a provider's terms, so check your plan's rules.
URL: https://dedupedai.com/use-cases/stablyai-orca/watch-claude-codex-usage-and-swap/

## 6. tangency-labs/solidcraft

GitHub: https://github.com/tangency-labs/solidcraft
Page: https://dedupedai.com/use-cases/tangency-labs-solidcraft/

An open-source 3D CAD app written in Rust that agents can drive.

Audience: For makers, hobbyists and small hardware teams who want a free parametric CAD tool they can also hand to an AI agent, with no install needed to try it.

Requirements:
- Windows, macOS or Linux desktop, or just a modern web browser (no install needed)
- Rust toolchain only if building from source
- An MCP-capable agent such as Claude Code only for the agent-driven uses
- No paid keys or accounts

### How to let an AI agent model a part you can still edit with solidcraft

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Maker who tried text-to-3D tools and got meshes they could not adjust
Problem: Text-to-3D tools give you a frozen mesh, so a wrong hole size or wall thickness means starting over.
Outcome: You get a feature-timeline model where every dimension is still editable after the agent is done.

Steps:
1. Download the app for your OS from the README, or use the browser version.
2. Register the MCP server with Claude Code: claude mcp add solidcraft -- solidcraft-cli mcp
3. Ask the agent to model your part and describe the key dimensions.
4. Open the result and change a dimension in Parameters to confirm it rebuilds.

Prompt:

```text
Using the solidcraft MCP server, model <part description with dimensions> as a parametric design. Expose the key sizes as parameters and tell me which ones to change. Verify the model rebuilds when one parameter changes.
```

Caveat: The README calls SolidCraft early but usable for simple parts, so complex assemblies from an agent may need manual cleanup.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111283785711124637
- X (Oct 2026): https://x.com/i/web/status/2111446678045593675
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/let-an-ai-agent-model-an-editable-part/

### How to open and re-export STEP, STL and 3MF files with solidcraft

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Maker handed a model in the wrong format for their printer or viewer
Problem: A file in one format will not load in the tool you need next.
Outcome: The model opens in SolidCraft and exports in the format your next tool accepts.

Steps:
1. Open the desktop or browser app.
2. Import your file (STEP, IGES, 3MF, STL, OBJ or glTF, where supported).
3. Check the Properties panel for volume and mass.
4. Export to the target format.

Prompt:

```text
Help me move <file name> from <source format> to <target format> using SolidCraft. List the import and export formats the README supports and tell me what to verify, such as volume and bounding box, after conversion.
```

Caveat: The README says formats are supported only 'where supported', so check that your specific import or export path works before relying on it for production.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/convert-and-inspect-cad-files-between-formats/

### How to check how a small assembly moves before building it with solidcraft

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Hobbyist designing a hinge, linkage or small mechanism
Problem: Parts that look fine alone can collide or bind once assembled.
Outcome: You see where parts interfere and can fix dimensions before making a physical copy.

Steps:
1. Model or import the individual parts.
2. Assemble them and add joints.
3. Run a motion study and an interference check.
4. Adjust parameters and rerun until the motion is clear.

Prompt:

```text
Using SolidCraft's assemblies, joints and interference tools, walk me through checking <mechanism> for collisions. Tell me what parameter to change if two parts interfere.
```

Caveat: Motion studies and contact sets are listed as features but the project is early, so validate results with a physical test fit.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/study-motion-in-a-small-mechanical-assembly/

### How to design a 3D-printable case for a dev board with solidcraft

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Hobbyist who needs a custom case for a Raspberry Pi or similar board
Problem: Off-the-shelf cases rarely fit your exact board layout, and mesh editors make small tweaks painful.
Outcome: A parametric case where changing one height value rebuilds the whole part, exported as a printable file.

Steps:
1. Open the desktop app and create a sketch using your board's dimensions as parameters.
2. Extrude, then use fillet and shell to form the case walls.
3. Pattern standoffs over the mounting holes and cut ports and vents.
4. Export as STL or 3MF for your slicer.

Prompt:

```text
Using SolidCraft, walk me through building a case for <board name> with parameters for board length, width and wall thickness, and tell me which export format to use for 3D printing. Verify the wall thickness is a named parameter.
```

Caveat: The README demo is a Pi 4 case; matching a different board means you must supply its real hole positions and port locations yourself.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/design-a-3d-printable-enclosure-for-a-board/

### How to design a bent sheet metal bracket and get its flat pattern with solidcraft

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Small fabricator or hobbyist ordering laser-cut and bent metal parts
Problem: A shop wants a flat pattern and you only have a 3D idea of the bent part.
Outcome: A bent sheet metal model with a flat pattern you can send to a cutting service.

Steps:
1. Open the app and sketch the base profile.
2. Add flanges and hems using the sheet metal features.
3. Unfold the part to get the flat pattern.
4. Export the flat pattern in a supported format.

Prompt:

```text
Using SolidCraft's sheet metal features, outline how to model <bracket description> with flanges and get a flat pattern. Verify bend allowances against what my fabricator expects before I order.
```

Caveat: Early software: confirm the flat pattern dimensions against your fabricator's bend rules before cutting any metal.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/design-sheet-metal-part-and-flat-pattern/

### How to try parametric 3D CAD in your browser, no install with solidcraft

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Curious beginner who heard about free CAD and does not want to install anything
Problem: Trying a CAD program usually means a large install and an unfamiliar interface.
Outcome: You sketch, extrude and resize a simple solid in a browser tab within minutes.

Steps:
1. Open the browser app linked from the README.
2. Start a new design and draw a sketch on a plane.
3. Extrude the sketch into a solid.
4. Edit a dimension in Parameters and watch the solid rebuild.

Prompt:

```text
I want to learn the basics of SolidCraft in the browser. Give me a 5-step exercise to sketch, dimension and extrude a small box with a hole, using only features listed in its README.
```

Caveat: The browser build runs the same commands as desktop, but very large designs may feel slower in a tab than in the desktop app.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/try-parametric-cad-in-the-browser/

### How to watch an agent build a model live in the open app with solidcraft

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Builder who wants to supervise an agent instead of trusting a headless run
Problem: A headless agent gives you only a final file, so you cannot catch a bad step as it happens.
Outcome: You watch the agent's commands appear in the app and can stop or correct it mid-build.

Steps:
1. Open the SolidCraft desktop app.
2. Register the server: claude mcp add solidcraft -- solidcraft-cli mcp
3. Configure the server with the --connect option described in docs/mcp.md so it drives the running app.
4. Give the agent a modeling task and watch the timeline fill in.

Prompt:

```text
Connect to the running SolidCraft app via its MCP server as described in docs/mcp.md and build <simple part> step by step. After each step, tell me what feature you added so I can follow along.
```

Caveat: The exact flags for connecting to the running app are in docs/mcp.md, not the main README, so read that page before setting it up.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/watch-an-agent-drive-the-live-cad-app/

### How to generate a STEP file from a JSON command script with solidcraft

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Developer or engineer who wants repeatable CAD output in a build pipeline
Problem: Clicking through a CAD GUI cannot be versioned, reviewed or automated.
Outcome: A text script in git that deterministically produces a STEP file you can hand to a manufacturer.

Steps:
1. Build from source: cargo run --release -p solidcraft-cli -- commands to list available commands.
2. Study the example script at examples/bracket.json.
3. Run it: cargo run --release -p solidcraft-cli -- run examples/bracket.json --out bracket.step
4. Edit a dimension in the JSON and rerun to confirm the output changes.

Prompt:

```text
In the solidcraft repo, read docs/scripts.md and examples/bracket.json, then write a new script for <part description> and run it with solidcraft-cli to produce a STEP file. Verify the output file exists and opens.
```

Caveat: Scripts are a list of the same commands the UI runs, so you need to look up command names from the registry rather than guess them.
URL: https://dedupedai.com/use-cases/tangency-labs-solidcraft/batch-build-a-part-from-a-json-script/

## 7. rehan-remade/universal-modder

GitHub: https://github.com/rehan-remade/universal-modder
Page: https://dedupedai.com/use-cases/rehan-remade-universal-modder/

Skills that let a coding agent mod almost any PC game you own.

Audience: For gamers and hobbyist modders who own PC games and have a coding agent, and want to add custom content or cross-game mashups without learning each engine from scratch.

Dual-use notice: only use this on software, sites and systems you own or are authorized to test.

Requirements:
- A coding agent such as Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot or OpenCode
- A PC game you own, run single-player or offline
- Git, Python 3.10+ and ffmpeg (uv recommended)
- A fal API key for generated art, 3D and audio (or a local ComfyUI server for images)
- Blender for 3D to sprite renders
- Windows games run natively or from WSL

### How to turn a finished mod into a reusable field note with universal-modder

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Modder who finished a game mod and wants to help the next person avoid the same dead ends
Problem: Hard-won details like which version worked or why a crash happened get lost, and others redo the same reverse engineering.
Outcome: A checked field note in the shared knowledge base with versions, route, verification and gotchas.

Steps:
1. Run `um kb new --game "Hades II" --title "A new boon god" --from-scan hades --agent "Codex (gpt-6)"`, using your own game, title and agent.
2. Fill in the note honestly, then validate it with `um kb check knowledge/games/hades-ii/a-new-boon-god.md`.
3. After your human says OK, open the PR with `um kb pr knowledge/games/hades-ii/a-new-boon-god.md --yes`.

Prompt:

```text
Use universal-modder's share-field-notes skill to write a field note for the <game> mod we just finished. Include versions, route, verification and gotchas, run the check, and wait for my approval before opening the pull request.
```

Caveat: Notes must not include game files or decompiled dumps, and must state an honest status and verification; the repo is alpha.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111468525550449028
- X (Oct 2026): https://x.com/i/web/status/2106032707029610854
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/write-up-modding-field-notes/

### How to add a custom weapon or boss to a game you own with universal-modder

Difficulty: Beginner | Time: 1 hour | Basis: Seen in the wild

Who: Terraria player who wants a homing missile launcher and a custom boss but has never written a mod
Problem: Writing a mod means learning the game's engine, code layout and asset formats before anything shows up on screen.
Outcome: A working mod with generated sprites, tested in the real game, plus a recorded showcase clip.

Steps:
1. Install the plugin for your agent, for example `/plugin marketplace add rehan-remade/universal-modder` then `/plugin install universal-modder@universal-modder` in Claude Code.
2. Store your fal key with `um fal key set` and start your agent with FAL_KEY set.
3. Tell the agent what to add, for example a homing missile launcher and a tactical nuke for Terraria, with sprites made by fal.
4. Let it run the mod-any-game loop: recon, read the code, build one slice, generate assets, verify in game.
5. Review the result and the showcase video it cuts.

Prompt:

```text
Use universal-modder to mod <game name> installed at <path to game folder>: add <new item or boss>. Generate the art with fal, test it in the running game, and tell me which route and engine you used.
```

Caveat: Targets games you own, single-player or offline only. The README says it refuses to bypass anti-cheat or write multiplayer cheats.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2110084405306011842
- Reddit: https://www.reddit.com/r/ClaudeAI/comments/1wug3lx/new_opensource_project_tries_to_let_claude_code/
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/add-custom-items-to-owned-game/

### How to cut a showcase video of your finished mod with universal-modder

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Modder who finished a mod and needs a trailer for Discord or social posts
Problem: Screen recording picks up desktop noise, and editing highlights by hand takes longer than building the mod.
Outcome: A short, cut video of the mod running in the real game with clean audio.

Steps:
1. Have a mod that already runs in the game.
2. Ask the agent to use the showcase-video skill to record the window with only the game's audio.
3. Let it pick moments and cut the clip from an edit decision list.
4. Check the result against the actual gameplay before posting.

Prompt:

```text
Use universal-modder's showcase-video skill to record <game> running my mod <mod name>. Pick the best moments and cut a short video with game audio only, and tell me the file path.
```

Caveat: Needs ffmpeg and a game that can run in a window; GPU-heavy games may need the screenshot and windowed-mode steps from game-automation.
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/record-showcase-video-of-mod/

### How to find a game's engine and see if it was modded before with universal-modder

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Hobbyist who just bought an older PC game and wants to know whether modding it is realistic
Problem: You cannot tell what engine a game uses or whether anyone has already worked out how to mod it.
Outcome: A MODDING_PLAN.md with engine, version, managed or native code, anti-cheat status, save folders and the best known route.

Steps:
1. Install the plugin or the skills with `npx skills add https://github.com/rehan-remade/universal-modder`.
2. Search prior art first with `um kb search "grand theft auto"`, swapping in your game's name.
3. Ask the agent to run the game-recon skill on your install folder.
4. Read the generated MODDING_PLAN.md before deciding to build anything.

Prompt:

```text
Use universal-modder's game-recon skill on <path to game folder>. Tell me the engine, whether it is managed or native, any anti-cheat, and whether the knowledge base already has notes on it. Write the result to MODDING_PLAN.md.
```

Caveat: Recon output is the agent's reading of files on disk; confirm anti-cheat status yourself before launching an online game with any mod.
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/identify-game-engine-and-prior-mods/

### How to put one game's content inside another game with universal-modder

Difficulty: Advanced | Time: A few hours to days | Basis: Seen in the wild

Who: Fan with a mashup idea, such as a Warthog from Halo driving around Minecraft
Problem: Combining two games means extracting assets from one and wiring them into the other's engine, a project few people finish alone.
Outcome: A playable mashup mod where content from game A runs inside game B, with a showcase video.

Steps:
1. Install the plugin and set up your fal key for any new art or audio.
2. Describe the mashup to the agent, naming both games and the one thing to bring over first.
3. Let the mashup-mods skill pick an approach: content port, passthrough mod, or reimplementation.
4. Build and verify one working slice in the running game before adding more.

Prompt:

```text
Use universal-modder's mashup-mods skill to bring <thing from game A> into <game B> installed at <path>. Start with one working slice and show me a screenshot from the running game as proof.
```

Caveat: Mashups reuse other studios' assets; the README's contribution rules forbid sharing game files or decompiled dumps, so publish only your own code and generated art.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2108619116982702135
- X (Oct 2026): https://x.com/i/web/status/2107364006482616440
- Reddit: https://www.reddit.com/r/starbound/comments/1wz2h40/starbound_and_terraria_together_with_modding/
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/mash-up-two-games-into-one/

### How to make sprites, 3D models and sound for a mod with fal with universal-modder

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Solo modder who can code a little but cannot draw or make audio
Problem: Mod ideas stall because every new unit, item or sound needs original art that fits the game's format.
Outcome: A set of transparent sprites, rendered 3D headings or audio files sized and named to match the target game.

Steps:
1. Create a fal API key and store it with `um fal key set`.
2. Start your agent with FAL_KEY set, for example `export FAL_KEY="$(secret-tool lookup service fal.ai key api)"` on Linux.
3. Ask the fal-assets skill for the asset, such as a unit rendered from 3D into 8 or 16 headings.
4. Use the asset-pipeline skill to cut out, fit and pack frames into the sheet size the game expects.

Prompt:

```text
Use universal-modder's fal-assets and asset-pipeline skills to make <asset description> for <game>. Output engine-ready frames at <size> and show me the sheet.
```

Caveat: fal is a paid service billed to your key, and 3D to sprite rendering needs Blender installed.
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/generate-game-art-3d-and-audio/

### How to port an existing mod to a newer game version or loader with universal-modder

Difficulty: Advanced | Time: A few hours to days | Basis: From the README

Who: Minecraft mod maintainer whose favorite old mod stopped working after an update
Problem: A manual port loses behavior along the way and nobody notices until players report bugs.
Outcome: A ported mod built unit by unit from one pinned source, with audits and status docs you can resume.

Steps:
1. Install the plugin and open your agent in the project.
2. Pin the source mod version and let the agent decompile it privately.
3. Ask the port-a-mod skill to extract data by script and port unit by unit with tests.
4. Review the layer audits and the status docs before releasing.

Prompt:

```text
Use universal-modder's port-a-mod skill to port <mod name> from <old version and loader> to <new version and loader>. Pin one source, port unit by unit with tests, and keep a resumable status doc.
```

Caveat: Check the original mod's license before porting and publishing; the README's example mapping covers Forge 1.7.10 to Fabric 1.20.1 only.
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/port-old-mod-to-newer-version/

### How to reverse engineer an unknown game file format with universal-modder

Difficulty: Advanced | Time: A few hours | Basis: From the README

Who: Tinkerer who wants to swap textures or data in an older game but cannot open its files
Problem: Proprietary archives and formats have no documentation, so editing assets is impossible without reading the binary.
Outcome: A working reader and writer for the format, proven by unpacking and repacking a file and getting the same game behavior.

Steps:
1. Install the plugin and point the agent at the game folder and the file type.
2. Ask the reverse-engineering skill to analyze the format with its tools such as ILSpy, Ghidra or Cheat Engine as appropriate.
3. Have it write a script that reads the format and a writer that rebuilds it.
4. Verify with a round trip: unpack, repack, and load the result in the game.

Prompt:

```text
Use universal-modder's reverse-engineering skill on the <file type> files in <path to game>. Work out the format, write a reader and writer, and prove it with a round trip that still loads in the game.
```

Caveat: Only for games you own and local single-player use. Do not redistribute extracted game assets, and do not use it to defeat anti-cheat or cheat other players.
URL: https://dedupedai.com/use-cases/rehan-remade-universal-modder/reverse-engineer-game-file-format/

## 8. cathrynlavery/diagram-design

GitHub: https://github.com/cathrynlavery/diagram-design
Page: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/

An agent skill that draws clean diagrams as a single HTML and SVG file in your brand.

Audience: Developers and non-designers who already work inside an AI coding agent and want presentable diagrams without opening a drawing app or settling for default Mermaid output.

Requirements:
- An Agent Skills compatible host such as Claude Code, Codex, Cursor, Qoder, GitHub Copilot, Gemini CLI, Cline, Windsurf or Amp
- Node.js for the npx install command
- A browser to open the generated HTML file
- Optional: a public website URL for brand onboarding

### How to draw an architecture diagram for your README without a design tool with diagram-design

Difficulty: Beginner | Time: 15 minutes | Basis: Seen in the wild

Who: Solo developer about to publish a repo who needs an architecture picture and does not want to open Figma or fight Mermaid
Problem: README diagrams either look like default Mermaid output or take an hour in a drawing app.
Outcome: One self-contained HTML file with an architecture diagram (frontend, backend, database, cache) you can open by double-clicking and export as PNG or SVG.

Steps:
1. Run: npx skills add cathrynlavery/diagram-design
2. Ask your agent in plain words, for example: Make me an architecture diagram of my app: frontend, backend, database, Redis cache.
3. Open the generated .html file in your browser and check the labels and arrows.
4. Ask the agent to export a PNG or SVG and add it to your README.

Prompt:

```text
Using the diagram-design skill, draw an architecture diagram of <my project: components and how they connect> as a single HTML and SVG file. Then export it as SVG so I can embed it in the README, and tell me which diagram type you picked and why.
```

Caveat: The skill works from your description, so any component you forget to mention will be missing from the diagram. Check it against your real code before publishing.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2110268087534755891
- X (Oct 2026): https://x.com/i/web/status/2110194985379492140
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/architecture-diagram-for-readme/

### How to draw the plan before your agent writes the code with diagram-design

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Developer about to hand a multi-step feature to a coding agent who wants to catch design mistakes early
Problem: Agents start coding from a vague plan and the wrong design only shows up after many files change.
Outcome: A sequence or flow diagram of the planned change that you read, correct and approve before any code is written.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. Describe the feature, for example: Give me a sequence of a bearer call with token refresh on 401.
3. Read the diagram and fix any wrong step by telling the agent what to change.
4. Once the diagram matches your intent, ask the agent to implement it.

Prompt:

```text
Before writing code for <feature>, use the diagram-design skill to draw the planned flow as one HTML diagram. Wait for my approval of the diagram, and flag any step where you made an assumption.
```

Caveat: The diagram only helps if you actually read it before the agent continues. Tell the agent explicitly to stop and wait for approval.

Seen in the wild:
- Reddit: https://i.redd.it/scj22allyuvh1.jpeg
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/review-plan-diagram-before-coding/

### How to draw your agent setup: tools, data flows and approval points with diagram-design

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Team lead documenting how an internal AI agent is wired before a security or ops review
Problem: Reviewers ask where data goes and who approves actions, and nobody has a single picture to point at.
Outcome: A diagram showing the agent, its tools, data flows and approval points that can be attached to a review document.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. List your agent's tools, data sources and approval steps in a short prompt.
3. Ask for a diagram that shows data flows and where a human approves actions.
4. Walk the reviewers through the HTML file and correct anything they spot.

Prompt:

```text
Using diagram-design, draw our agent setup for <agent name>: the tools it can call, where data flows, and where a person must approve. Mark any boundary where data leaves our systems so I can double-check it.
```

Caveat: The diagram shows what you tell it, not what the agent actually does at runtime. Do not use it as proof of a security boundary without verifying the real config.

Seen in the wild:
- Reddit: https://i.redd.it/scj22allyuvh1.jpeg
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/visualize-your-agent-setup/

### How to map an unfamiliar repo's components before you change it with diagram-design

Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Who: Developer joining a project or reviewing a pull request who needs a quick mental map of an unfamiliar repo
Problem: Reading folders and files one by one makes it hard to see how the pieces connect.
Outcome: A component and data-flow diagram of the repo that you can review with teammates before approving or writing code.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. Point your agent at the repo and ask it to map the main components and how they talk to each other.
3. Open the HTML file and compare each box and arrow with the actual code paths.
4. Ask for corrections where the diagram is wrong, then keep the final version in the project docs.

Prompt:

```text
Use the diagram-design skill to map the components and connections in <repo path or URL> as one HTML and SVG diagram. List any connection you were unsure about so I can verify it against the code.
```

Caveat: The diagram reflects what the agent inferred from the code it read, so it can miss runtime wiring or hidden dependencies. Treat it as a first draft to verify.
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/map-unfamiliar-repo-for-review/

### How to pair diagrams with a video skill to explain a GitHub repo with diagram-design

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Maintainer or creator who wants a quick explainer video for a GitHub project without editing footage
Problem: Explaining how a repo works takes a written walkthrough most visitors never read.
Outcome: A short explainer video for a repo where the architecture scenes come from diagrams drawn by the skill.

Steps:
1. Install the video tooling the way the field post describes: claude plugin marketplace add heygen-com/hyperframes
2. Run: claude plugin install hyperframes@hyperframes
3. Run: npx skills add cathrynlavery/diagram-design
4. Ask Claude Code to read the repo README, plan the scenes and draw the diagrams, then render the video.

Prompt:

```text
Make a 45-second explainer video for this GitHub repo: <repo URL>. Read the README, state in one sentence what it does, use diagram-design for the architecture scenes, and tell me which scenes you were least sure about.
```

Caveat: The video side depends on a separate project (HyperFrames) with its own requirements. The prompt shape comes from a community post, not this README, so expect to adjust it.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2110683351489409207
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/turn-repo-into-explainer-video-with-diagram/

### How to make every diagram match your website's colors and fonts with diagram-design

Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Who: Founder or marketer who needs diagrams for decks, docs and blog posts that look like their own brand
Problem: Generic diagrams clash with a branded site or deck and need manual recoloring each time.
Outcome: A saved brand profile so each new diagram comes out in your palette and typography without extra prompting.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. Ask your agent: Onboard diagram-design to https://yoursite.com
3. Let it pull your palette and fonts, then request a first diagram and compare it with your site.
4. Ask for tweaks to the style if a color or font is off, then keep using the same profile.

Prompt:

```text
Onboard diagram-design to <my website URL>, then draw a <diagram type> of <topic> in that brand. Tell me which colors and fonts you picked up so I can confirm they match.
```

Caveat: The skill sends your site URL over the network during onboarding, and the README points to PRIVACY.md for exactly what leaves your machine. Read it before onboarding a private or staging site.
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/match-diagrams-to-your-brand/

### How to redraw an old Mermaid or draw.io diagram in a cleaner style with diagram-design

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Docs maintainer with a folder of ugly Mermaid or draw.io diagrams in their README and wiki
Problem: Existing diagrams use default theme styling that looks dated and inconsistent across pages.
Outcome: The same diagrams redrawn in one consistent editorial style, exported as PNG or SVG for the docs.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. Hand your agent the Mermaid, draw.io or Excalidraw source and ask it to redraw it with the skill.
3. Open the new HTML file and check that every node and edge from the original survived.
4. Export to PNG or SVG and replace the old image in your docs.

Prompt:

```text
Use the diagram-design skill to import <path to mermaid, drawio or excalidraw file> and redraw it as a clean HTML and SVG diagram. Confirm that the node and edge counts match the original and export an SVG.
```

Caveat: Import is described in the README, but complex layouts may be re-arranged by the skill, so compare the result against the original instead of assuming it is identical.
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/replace-mermaid-diagrams-with-cleaner-ones/

### How to add light motion to a diagram that explains steps in order with diagram-design

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Technical writer or educator presenting a process (request flow, pipeline) where order matters
Problem: A static diagram shows all steps at once, which makes sequences harder to follow in a talk or doc.
Outcome: An HTML diagram with optional motion that walks a viewer through the steps in order, with a static version still available.

Steps:
1. Install the skill with: npx skills add cathrynlavery/diagram-design
2. Ask your agent to draw an ordered process and request optional motion for it.
3. Open the HTML file in a browser and check that the steps appear in the intended order.
4. Keep the static version as the default for places where motion is not wanted.

Prompt:

```text
Use diagram-design to draw <process name> as an ordered diagram with the optional motion enabled. Confirm the step order is right and keep a static version alongside it.
```

Caveat: The README says static HTML is the default and motion is optional for ordered explanations only, so it will not suit every diagram type.
URL: https://dedupedai.com/use-cases/cathrynlavery-diagram-design/add-motion-to-ordered-explanations/

## 9. yetone/magpie

GitHub: https://github.com/yetone/magpie
Page: https://dedupedai.com/use-cases/yetone-magpie/

A menu bar app to pair any coding agent with any model, like Codex on DeepSeek.

Audience: Developers who run more than one coding agent, provider or account and are tired of editing separate config files and hitting quota walls mid-task.

Requirements:
- macOS, Windows, Linux, Docker or Termux
- At least one coding agent already installed (for example Claude Code, Codex or Gemini CLI)
- At least one provider: an API key, a local model server, or a signed-in subscription such as Claude, ChatGPT, Copilot, Gemini or Grok
- Bun is downloaded automatically the first time a plugin needs it

### How to send quick questions to a cheap model and hard tasks to a strong one with magpie

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Developer whose big model gets burned on simple questions like "what does this do?"
Problem: Every turn goes to the same expensive model, even trivial ones, which wastes quota.
Outcome: Simple questions go to a fast model while test-writing and heavier work go to the strong model.

Steps:
1. Create a routing group containing a fast model and a strong model
2. Turn on intent routing for the group using the setup in the intent docs at usemagpie.ai/docs/intent
3. Point your agent at the group and ask one quick question, then one bigger task
4. Open the Routing view to see which model handled each turn

Prompt:

```text
Set up yetone/magpie intent routing so <FAST_MODEL> handles simple questions and <STRONG_MODEL> handles test writing. Confirm in the Routing view that two different turns went to different models.
```

Caveat: Intent routing needs a small model of your choice to classify each turn, which adds a call per turn. Exact setup steps are in the linked docs, not the truncated README.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111671879291613637
URL: https://dedupedai.com/use-cases/yetone-magpie/route-quick-questions-to-cheap-models/

### How to run your coding agent on a cheaper or different model with magpie

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Developer who likes Codex or Claude Code but wants to try a cheaper model for everyday edits
Problem: Each agent stores its model, keys and base URL in its own file and format, so trying another model means editing configs by hand.
Outcome: One of your installed agents answers on the model you picked, chosen from a searchable list, with its config rewritten safely.

Steps:
1. Download the app from usemagpie.ai, or run: curl -fsSL https://usemagpie.ai/install.sh | sh
2. Run: magpie provider add deepseek sk-<your-key>
3. Run: magpie codex moonshot/kimi-k2.5 (or: magpie claude deepseek/deepseek-v4-pro)
4. Start a new agent session and ask it to explain a file in your repo

Prompt:

```text
Install yetone/magpie, add a DeepSeek provider with the key in <DEEPSEEK_KEY_ENV_VAR>, then point Claude Code at deepseek/deepseek-v4-pro. Show me the command output, and verify by starting a new session that it is now on the new model.
```

Caveat: Changes apply to new agent sessions, not one already running. Preset names like deepseek are used in the README examples; confirm the exact model IDs in your picker.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2110467223437689251
- X (Oct 2026): https://x.com/i/web/status/2109913028397609091
- X (Oct 2026): https://x.com/i/web/status/2110142525914644785
URL: https://dedupedai.com/use-cases/yetone-magpie/run-codex-on-deepseek-or-kimi/

### How to keep coding when one account hits its rate limit with magpie

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Developer with two Claude or ChatGPT accounts who keeps getting cut off mid-task by a 5-hour limit
Problem: When one subscription hits its limit, the agent stops with an error and you lose your flow.
Outcome: The agent keeps answering because requests move to the next account or model in your routing group, with no error shown.

Steps:
1. Add each account or provider under Providers in the app
2. Run: magpie group add "Opus anywhere" models=claude/claude-opus-5-5,copilot/claude-opus-5.5 routing=smart
3. Run: magpie claude group/opus-anywhere
4. Run: magpie quota to see what is left on every plan

Prompt:

```text
Using yetone/magpie, create a routing group from my <PROVIDER_A> and <PROVIDER_B> models with smart routing and point Claude Code at it. Then run magpie quota and confirm both accounts show up as group members.
```

Caveat: Failover only helps if you really have more than one account or model available. Using several accounts may conflict with a vendor's terms, so check them first.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111205002471411818
- X (Oct 2026): https://x.com/i/web/status/2108382559138648570
- X (Oct 2026): https://x.com/i/web/status/2106983366541353218
URL: https://dedupedai.com/use-cases/yetone-magpie/fail-over-between-accounts-on-rate-limits/

### How to point any base-URL tool at one local gateway with magpie

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Builder with a script or editor tool that reads OPENAI_BASE_URL and wants it to use a different model
Problem: Tools that call one vendor's API cannot easily use other models or your pooled accounts.
Outcome: The tool sends requests to 127.0.0.1:3425 and gets answers from whichever model magpie routes to.

Steps:
1. Make sure magpie is running with at least one provider added
2. Run: export OPENAI_BASE_URL=http://127.0.0.1:3425/v1 OPENAI_API_KEY=magpie
3. Run your tool or script as usual
4. Check the Routing view to see the request arrive and which provider answered

Prompt:

```text
Using yetone/magpie, configure <TOOL_NAME> to use the local gateway at 127.0.0.1:3425 via its base URL environment variables. Run one request and verify it shows up in magpie's Routing view.
```

Caveat: A tool that hard-codes its API host or rejects custom base URLs will not work. One user also reported that some apps do not accept magpie as a provider.
URL: https://dedupedai.com/use-cases/yetone-magpie/point-any-base-url-tool-at-local-gateway/

### How to use a plan you already pay for inside other agents with magpie

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Developer paying for a ChatGPT or Claude plan who wants those models in a second agent without buying API credits
Problem: A subscription works in only one agent, so paying for it twice or switching tools is the only way to reuse it elsewhere.
Outcome: A second agent runs on the models from your existing subscription, listed as a normal provider.

Steps:
1. Sign in to your existing agent so magpie can find the subscription
2. Open the app and go to Providers, then Add provider, and pick the subscription
3. Open the Agents page and pick a model from that subscription for another agent
4. Start a new session in that agent and run a small task to confirm it answers

Prompt:

```text
Use yetone/magpie to expose my signed-in <SUBSCRIPTION_NAME> plan as a provider and assign one of its models to <TARGET_AGENT>. Verify the agent answers a short test prompt on that model.
```

Caveat: magpie reads local sign-in files and the Keychain to find subscriptions. Turn that off in Settings > Privacy > Subscription accounts, or run: magpie accounts discovery off.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2109913028397609091
- X (Oct 2026): https://x.com/i/web/status/2108382559138648570
URL: https://dedupedai.com/use-cases/yetone-magpie/use-your-chatgpt-plan-in-other-agents/

### How to switch every agent's model setup with one named profile with magpie

Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Who: Developer who runs several agents and changes models by mood, deadline or budget
Problem: Changing models across three agents means repeating the same edits three times.
Outcome: One command swaps every agent between saved setups, such as a cheap Budget profile and a strong Focus profile.

Steps:
1. Set each agent to the models you want for your budget setup
2. Run: magpie save work
3. Change the models, then run: magpie save focus
4. Run: magpie use work to switch every agent back at once

Prompt:

```text
With yetone/magpie, save my current agent setup as a profile named <PROFILE_NAME>, then change one agent's model and save a second profile. Show that magpie use switches back and the agent config reflects it.
```

Caveat: Profiles cover model choices for agents magpie manages. A running agent session keeps its model until you start a new one.
URL: https://dedupedai.com/use-cases/yetone-magpie/save-and-switch-model-profiles-per-task/

### How to move your existing provider setup into one app with magpie

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Developer already juggling provider configs across several tools who wants to consolidate
Problem: Re-typing keys, base URLs and model lists into a new tool is slow and easy to get wrong.
Outcome: Your existing providers appear in magpie ready to assign to any agent.

Steps:
1. Open the app and go to Providers
2. Choose the import option and pick the source tool
3. Review the imported providers and their model lists
4. Assign one imported provider's model to an agent on the Agents page

Prompt:

```text
Use yetone/magpie to import my providers from <SOURCE_TOOL>, then list which ones were brought in. Verify at least one appears in the model picker for an installed agent.
```

Caveat: Import covers only the four named sources. Imported keys are stored by magpie, so review them before relying on them.
URL: https://dedupedai.com/use-cases/yetone-magpie/import-existing-providers-from-cc-switch/

### How to add a model login through an npm plugin with magpie

Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Who: Advanced user who wants Gemini or Antigravity models that need a plugin-based login
Problem: Some providers only offer sign-in through agent plugins, which other agents cannot use directly.
Outcome: The plugin's models show up in magpie and any agent can run on them like a normal provider.

Steps:
1. Run: magpie plugin add opencode-gemini-auth
2. Run: magpie plugin login google-plugin
3. Open Agents and pick a model from the plugin's provider
4. Start a new session and send a short prompt to confirm it responds

Prompt:

```text
Using yetone/magpie, install the plugin <PLUGIN_NAME> and complete its login. Verify its models appear in the model picker and answer a test prompt in <TARGET_AGENT>.
```

Caveat: Plugins run on Bun, which is downloaded on first use, and plugin code runs on your machine. Only install plugins you trust.
URL: https://dedupedai.com/use-cases/yetone-magpie/add-gemini-or-pi-login-via-npm-plugin/

## 10. ifixai-ai/iFixAi

GitHub: https://github.com/ifixai-ai/iFixAi
Page: https://dedupedai.com/use-cases/ifixai-ai-ifixai/

An auditing tool that checks whether an AI agent is doing what it is supposed to do.

Audience: For teams and solo builders who have an AI agent running or about to ship and want an independent check that it follows business rules, roles and permissions, not only that its answers look right.

Requirements:
- Python 3.10+
- An API key for the model provider you want to test or to act as judge (the engine is free, model calls cost extra)
- An agent or model endpoint to audit (any supported provider, or your agent's own HTTP endpoint)
- Optional: uv, only for the zero-install skill route

### How to have a different vendor's model judge your agent's behavior with iFixAi

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Team lead who does not trust a model to score its own output
Problem: If the same vendor's model both runs and grades the agent, blind spots can go unnoticed.
Outcome: An audit graded by a separate vendor's judge (or a multi-judge ensemble), giving a more independent score.

Steps:
1. Install extras for both the tested and judge providers, e.g. pip install "ifixai[openai]"
2. Run ifixai setup and pick a self, single independent vendor, or ensemble judge
3. Run: ifixai run --dry-run to inspect the call estimate first
4. Run: ifixai run and compare the scorecard to a self-graded run if you have one

Prompt:

```text
Use ifixai-ai/iFixAi to audit <my agent> with <vendor A> as the tested model and <vendor B> as the judge. Do a --dry-run first, then a full run, and note any category where the independent judge scored lower. Verify the judge vendor in the report matches what I chose.
```

Caveat: Using a second vendor means a second API key and added model-call cost on top of the tested model.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2110626308019659207
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/use-independent-judge-model/

### How to grade a new AI agent against your business rules before launch with iFixAi

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Founder or engineer about to put a support or ops agent in front of real customers
Problem: Your tests check that answers look good, but nobody has checked whether the agent stays inside the rules it was given.
Outcome: A graded scorecard (A to F, broken down by category) that shows where the agent breaks policy before users find out.

Steps:
1. Install the package with the extra for the provider you test: pip install "ifixai[openai]"
2. Run the guided wizard: ifixai setup
3. Run the audit with no flags: ifixai run
4. Open the reports in ./ifixai-results/ and read the scorecard by category

Prompt:

```text
Use the ifixai-ai/iFixAi repo to audit my agent at <agent endpoint or provider and model>. Run the guided setup, then a default run, and summarize the scorecard by category. Verify the report files were written to ./ifixai-results/ before you report results.
```

Caveat: The engine is free but every check makes paid model calls, so use --dry-run first to see the estimated call count.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111897900028674049
- X (Oct 2026): https://x.com/i/web/status/2110506583478120875
- X (Oct 2026): https://x.com/i/web/status/2110392965147283848
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/audit-agent-before-launch/

### How to let Claude Code or Codex run the audit and explain the results with iFixAi

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Developer already working in Claude Code or Codex who wants a guided, explained audit without learning flags
Problem: You do not want to hand-write configs or decode raw JSON reports just to learn whether your agent behaves.
Outcome: A completed audit with an interactive scorecard and a plain-English walkthrough of what failed.

Steps:
1. In Claude Code run: /plugin marketplace add ifixai-ai/iFixAi
2. Then run: /plugin install ifixai@ifixai-community
3. Ask the agent: run iFixAi on my setup (or type /ifixai:ifixai)
4. Confirm the stated cost, let it run, then read the scorecard walkthrough

Prompt:

```text
Use the ifixai plugin from ifixai-ai/iFixAi to audit <my agent or provider>. Discover my config, tell me the cost before anything is billed, run the diagnostic, then explain the scorecard. Verify the final result file exists and cite which categories scored worst.
```

Caveat: Restart Claude Code or run /reload-plugins if the plugin does not appear; on Codex you must approve the plugin's hook once.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111729447426486672
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/audit-from-claude-code-plugin/

### How to quickly grade a coding agent on whether it does the job it should with iFixAi

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Engineering manager evaluating whether a coding agent is safe to trust with team repos
Problem: You can't tell from demos whether the agent silently fails, fakes tool use or falls for injected instructions.
Outcome: A quick graded scorecard covering checks like prompt injection, fake tool use and silent failures.

Steps:
1. Install your provider extra: pip install "ifixai[anthropic]"
2. Run the wizard: ifixai setup
3. Run the default 10-inspection suite: ifixai run
4. Read which categories lost points and decide what to fix first

Prompt:

```text
Use ifixai-ai/iFixAi to run the default audit on my coding agent <agent or model name>. Summarize the grade and the three weakest categories. Verify the run used the default suite and not a full run by checking the report.
```

Caveat: The default run covers 10 inspections; a full run of all 60 takes longer and costs more in model calls.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111729447426486672
- X (Oct 2026): https://x.com/i/web/status/2110626308019659207
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/audit-coding-agent-quick-grade/

### How to test an agent's permission boundaries before granting it delete access with iFixAi

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Engineer about to give an internal agent write or delete rights on real systems
Problem: Most agent testing checks answers and never checks whether the agent stays within what it is allowed to do.
Outcome: Evidence on whether the agent's permission-related checks pass, so you can decide to grant or withhold access.

Steps:
1. Install the extra for your setup: pip install "ifixai[openai]"
2. Run ifixai setup and choose your agent's real endpoint
3. Run: ifixai run
4. Review the permission and policy categories in the scorecard before changing any access

Prompt:

```text
Use ifixai-ai/iFixAi against my agent's HTTP endpoint <endpoint URL> to check whether it respects role and permission limits. Report the permission-related check results from ./ifixai-results/ and verify which checks failed before I grant it delete rights.
```

Caveat: A passing audit is not proof of safety; it is one independent check, so keep human approval on destructive actions.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111897900028674049
- X (Oct 2026): https://x.com/i/web/status/2110376885670576535
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/check-permissions-before-delete-rights/

### How to add an audit slash command to Cursor, Gemini or Zed in one step with iFixAi

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Developer using Cursor, VS Code, Windsurf, Gemini or another agent that lacks the Claude Code plugin
Problem: You want the guided, agent-driven audit but your editor has no plugin install path.
Outcome: A working /ifixai-skill command in your agent that reads your setup, shows the cost, and runs the audit after you approve.

Steps:
1. Scaffold the skill for your agent: uvx ifixai install --agents cursor
2. Or scaffold every agent: uvx ifixai install --agents all
3. Check supported agents and file locations: uvx ifixai install --list
4. Run /ifixai-skill in your agent and approve the cost shown by the free --dry-run

Prompt:

```text
Scaffold the iFixAi skill for my agent from ifixai-ai/iFixAi using uvx ifixai install --agents <agent slug>, then run /ifixai-skill. Show me the --dry-run cost before running. Verify the skill file landed where uvx ifixai install --list says it should.
```

Caveat: Auto-detect only finds agents whose folder already exists, so on a fresh project name the agent explicitly with --agents.
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/scaffold-audit-skill-in-any-agent/

### How to fail your CI build when an agent audit regresses with iFixAi

Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Who: Platform or DevOps engineer who ships agent changes weekly and wants a repeatable policy check
Problem: Prompt or tool changes can quietly break permission rules, and nobody notices until production.
Outcome: A scripted, flag-driven audit run in CI that writes JSON and Markdown reports for every change.

Steps:
1. Install the provider extra in your CI image: pip install "ifixai[anthropic]"
2. Export the provider API key as an environment variable in CI secrets
3. Run an explicit-flag audit (see the Explicit flags section of the README for the exact options)
4. Upload ./ifixai-results/ as a build artifact and fail the job on a low grade

Prompt:

```text
Add an ifixai-ai/iFixAi audit step to the CI config in <repo path>, using explicit CLI flags and an API key from secrets. Save the reports from ./ifixai-results/ as an artifact. Verify with a --dry-run that the step works before enabling it.
```

Caveat: The README's explicit-flag example was cut off in the text provided, so check the repo docs for the exact flag names before wiring up CI.
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/gate-ci-on-agent-audit/

### How to find harmful chains of allowed actions with Policy Lab with iFixAi

Difficulty: Advanced | Time: 1.5 hours | Basis: From the README

Who: Security-minded engineer reviewing a refund or payout workflow where each step is allowed but the combination is not
Problem: Single permissions look fine, yet a chain of permitted actions can still cause harm.
Outcome: A shortest harmful sequence found offline, plus a check that your permission repair still allows legitimate work.

Steps:
1. Open the Policy Lab doc at docs/business-policy-lab.md in the repo
2. Follow its offline refund-store example
3. Adapt the example's policy and actions to your own workflow
4. Replay with an explicit local callable to confirm the repair holds

Prompt:

```text
Read docs/business-policy-lab.md in ifixai-ai/iFixAi and run the offline refund-store example. Then adapt it to <my workflow>, report the shortest harmful sequence, and verify the proposed permission repair still allows the legitimate completion goal.
```

Caveat: The README only introduces Policy Lab briefly, so details and commands live in docs/business-policy-lab.md and should be confirmed there.
URL: https://dedupedai.com/use-cases/ifixai-ai-ifixai/find-harmful-action-sequences-policy-lab/

## 11. feder-cr/git-ai

GitHub: https://github.com/feder-cr/git-ai
Page: https://dedupedai.com/use-cases/feder-cr-git-ai/

Version control built for coding agents instead of humans, so many agents can work on one codebase without stepping on each other.

Audience: Builders who run several coding agents against one repository and are hitting merge queue and rebase-retry bottlenecks, plus infrastructure people curious about agent-native source control.

Requirements:
- Linux or macOS
- Go 1.26, a C toolchain, Meson and Ninja (the build compiles a bundled Git)
- No paid keys needed; conflict resolution can use any LLM provider, a deterministic tool, or none
- SQLite or PostgreSQL plus object storage (file, S3, GCS, Azure) only if you move the repo state off local Git

### How to give every coding agent its own token and branch limits with git-ai

Difficulty: Intermediate | Time: 1 hour | Basis: Seen in the wild

Who: Engineering manager who just discovered an agent pushed to a protected branch and wants accountability per agent
Problem: With shared credentials you cannot tell which agent broke something or stop one from touching branches it should not.
Outcome: Each agent has its own identity and permitted actions, and each landed change is logged with the agent that made it.

Steps:
1. Read doc/graft/AGENT-SECURITY.md to see how tokens, the RPC allowlist and branch policies are set
2. Add per-agent tokens and branch policies to your config.toml
3. Restart the server and have two agents land changes under different identities
4. Use the graft CLI to list the changeset log and check each entry shows its actor

Prompt:

```text
In feder-cr/git-ai, follow doc/graft/AGENT-SECURITY.md to create two agent tokens in <config.toml> with different branch policies. Show that one agent is denied on a protected branch, and verify the changeset log records which agent landed each accepted change.
```

Caveat: Exact config keys for tokens and policies live in the docs, not the README; follow the docs instead of guessing the TOML.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112319865218314452
- X (Oct 2026): https://x.com/i/web/status/2112080627617202280
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/give-each-agent-its-own-token/

### How to reproduce the 50-agent landing benchmark on your own machine with git-ai

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Engineer evaluating gitai who does not want to trust published numbers without running them
Problem: The README claims 200 landed changes versus about 100 for classic landing, but you need to see it on your hardware.
Outcome: You get your own landed-count, attempts-per-change and latency figures for 50 agents landing 250 changes with planned conflicts.

Steps:
1. Build the repo with: make build
2. Run the benchmark script at examples/graft/demo/acceptance-phase4.sh
3. Compare the classic and gitai columns for changes landed and attempts per landed change
4. Read doc/graft/BENCH.md for the other agent counts

Prompt:

```text
In feder-cr/git-ai, run examples/graft/demo/acceptance-phase4.sh after make build and report changes landed, attempts per landed change and p99 latency for classic versus gitai. Verify that the roughly 50 unlanded changes in the gitai run are the planned conflicts.
```

Caveat: The README numbers come from one 16-core machine and a run without a conflict resolver; a smaller machine will show different lands per minute.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111611970294255692
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/reproduce-the-50-agent-benchmark/

### How to watch many agents land changes on one branch in minutes with git-ai

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Developer running several coding agents who wants to see if a shared branch can survive them before changing their setup
Problem: Several agents pushing to the same branch collide, retry and waste time, and you cannot tell if a different approach would help.
Outcome: You have a running server, a cache daemon, two agents and one landed change in a temporary directory, so you can judge the model first-hand.

Steps:
1. Clone the repo and enter it: git clone https://github.com/feder-cr/git-ai.git then cd git-ai
2. Build everything with: make build
3. Run the demo with: examples/graft/quickstart.sh
4. Inspect the CLI with: ./_build/bin/graft

Prompt:

```text
Clone feder-cr/git-ai, run make build, then run examples/graft/quickstart.sh and summarize what the two agents did and how their change landed. Verify the build finished and the script exited without errors.
```

Caveat: The build compiles a bundled Git and needs Go 1.26, Meson and Ninja, so the first build can be slow or fail on a missing toolchain.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111611970294255692
- X (Oct 2026): https://x.com/i/web/status/2111793549817860328
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/try-multi-agent-landing-locally/

### How to stand up a shared server for a fleet of coding agents with git-ai

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Team lead whose parallel coding agents keep rebasing and retrying against one main branch
Problem: A normal Git host makes every agent clone fully and fight over pushes, so throughput collapses as agent count grows.
Outcome: You have a gitai server running from a config file, with agents landing on it through the graft CLI instead of pushing to a classic host.

Steps:
1. Copy examples/graft/config.toml and adapt it to your paths
2. Start the server with: _build/bin/gitaly serve config.toml
3. Use the graft CLI (./_build/bin/graft) from each agent to clone and land
4. Read doc/graft/AGENT-SECURITY.md for tokens and the RPC allowlist

Prompt:

```text
Using feder-cr/git-ai, adapt examples/graft/config.toml for a server at <data-dir> and start it with _build/bin/gitaly serve. Show how an agent clones and lands one change, and verify the server accepted it.
```

Caveat: The README states version 0.2.0 and says interfaces may change before 1.0, so treat a real production repo with caution.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112080627617202280
- X (Oct 2026): https://x.com/i/web/status/2111828392513274064
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/host-a-shared-repo-for-agent-fleet/

### How to resolve conflicting agent changes automatically with a chosen resolver with git-ai

Difficulty: Advanced | Time: 1 hour | Basis: From the README

Who: Developer whose agents touch overlapping files and keep getting conflicts returned
Problem: Conflicting changes are sent back to their agents, and without a resolver those changes simply do not land.
Outcome: Conflicts are resolved through the versioned resolver protocol and all 250 changes in the demo land, as the README describes for the deterministic resolver.

Steps:
1. Read doc/graft/RESOLVE.md for the resolver protocol
2. Open examples/graft/demo/resolve.toml, the deterministic resolver the README points to
3. Run the benchmark again using that resolver config
4. Compare landed counts with the earlier run without a resolver

Prompt:

```text
In feder-cr/git-ai, run the acceptance demo with examples/graft/demo/resolve.toml and report how many of the 250 changes landed. Verify the planned conflicts were resolved rather than returned.
```

Caveat: The README confirms the deterministic resolver in the demo; how to wire an LLM provider is covered in doc/graft/RESOLVE.md, and a model resolving real code conflicts can still produce wrong merges.
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/auto-resolve-agent-merge-conflicts/

### How to give an agent only the folders it needs in a huge repo with git-ai

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Platform engineer whose agents each edit a few files in a large monorepo and waste time on full clones
Problem: Cloning the whole repository for a task that touches three files makes each agent slow to start.
Outcome: The agent fetches only the requested paths and can still land its change through the server.

Steps:
1. Build with: make build
2. Run ./_build/bin/graft to list the CLI commands
3. Use graft sparse or graft clone with the paths <paths> the task needs
4. Land the resulting change and confirm it appears in the changeset log

Prompt:

```text
Using feder-cr/git-ai, run ./_build/bin/graft to find the sparse and clone commands, then materialize only <paths> from <repo> and land one edit. Verify that unrelated directories were not downloaded.
```

Caveat: The README names graft clone and graft sparse but not their flags, so read the CLI help or docs before running them.
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/sparse-checkout-for-short-lived-agent-tasks/

### How to test the branch tip after landing and revert the culprit with git-ai

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Maintainer whose agents land fast and who needs broken builds caught after the fact, not before every land
Problem: When many changes land at once, finding which one broke the tests means manual bisecting while main stays red.
Outcome: A failure on the tip is bisected to the offending change, which is reverted automatically.

Steps:
1. Read doc/graft/VERIFY.md for how graft-verify is configured
2. Point graft-verify at your repository and test command
3. Land a deliberately failing change from one agent
4. Check that graft-verify identifies and reverts that change

Prompt:

```text
In feder-cr/git-ai, set up graft-verify per doc/graft/VERIFY.md against <repo-path> with the test command <test-cmd>. Land one change that fails the tests and verify it gets reverted.
```

Caveat: An automatic revert rewrites your branch, so only point it at a throwaway or fully backed-up repo first.
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/auto-revert-the-change-that-broke-main/

### How to follow the live changeset log with a monitoring agent with git-ai

Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Who: Tech lead who wants to know which agent changed what in a repo receiving hundreds of changes a day
Problem: On a busy shared branch nobody can read every landed change, so risky edits go unnoticed.
Outcome: A monitoring agent follows the changeset stream and posts a short report per component, optionally to Slack.

Steps:
1. Read doc/graft/SUPERFAN.md for how monitoring agents follow the changeset stream
2. Read doc/graft/SUPERFAN-CHAT.md for the Slack setup
3. Start the server and land a few changes from different agents
4. Use the graft CLI to list or watch the changeset log and confirm each entry shows its operation and actor

Prompt:

```text
In feder-cr/git-ai, follow doc/graft/SUPERFAN.md to set up a monitoring agent on a running server and have it summarize the last <n> landed changes by component. Verify each summary names the agent that made the change.
```

Caveat: Superfan agents and Slack chat have their own docs and config; the README only lists them, so expect to read those pages before it works.
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/watch-live-changeset-log-for-regressions/

### How to move repo state into PostgreSQL and object storage for scale-out with git-ai

Difficulty: Advanced | Time: 2 hours | Basis: From the README

Who: Infrastructure engineer planning to run several gitai nodes behind one repository
Problem: Repository state tied to one node's disk means you cannot add nodes or recover one that dies.
Outcome: Your repositories are imported and served in authoritative mode from a database and object storage, with nodes acting as rebuildable caches.

Steps:
1. Read doc/graft/STORAGE.md
2. Add a [graft.storage] section to your config.toml
3. Start in shadow mode and import your repositories
4. Switch to authoritative mode once imports check out

Prompt:

```text
In feder-cr/git-ai, follow doc/graft/STORAGE.md to add a [graft.storage] section using <database-url> and <object-store>, start in shadow mode and import <repo>. Verify the import completed before suggesting the switch to authoritative.
```

Caveat: The README lists garbage collection of packs in the storage core as a known gap, so storage can grow without cleanup.
URL: https://dedupedai.com/use-cases/feder-cr-git-ai/scale-repo-state-into-postgres-and-object-storage/

## 12. Leonxlnx/earshot

GitHub: https://github.com/Leonxlnx/earshot
Page: https://dedupedai.com/use-cases/leonxlnx-earshot/

Gives coding agents ears: they can listen to audio, review it and generate sound. Runs on a plain CPU and is open source.

Audience: Built for people who use coding agents to make films, product demos and games in code, and need the agent to actually hear and judge the sound it produces.

Requirements:
- Python
- CPU only, no GPU needed
- Local models load on first call (about 20 to 40 seconds per CLI call)
- No account or paid key for core features
- Optional Gemini key only for the `llm` command
- Reference recordings for `forge --refset` are not in the repo; bring your own with `--refs DIR`

### How to synthesize a new sound in code and refine it by ear with earshot

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Sound-curious developer who wants a custom click, whoosh or key press made entirely in code
Problem: Stock effects never quite fit, and an agent cannot judge a synthesized sound without hearing it.
Outcome: A folder of rendered WAVs, a report in the critic's words, spectrogram comparisons and an audition file.

Steps:
1. Run `earshot forge --list` to see recipes like click, impact, keypress and whoosh.
2. Run `earshot forge keypress --refs path/to/real/keypresses/ --budget 144 --variants 4 --dir made/keypress` with your own reference folder.
3. Open report.md and compare.png in the output folder and listen to audition.wav.
4. Re-render a pick with `earshot forge --render keypress --params made/keypress/report.json --seeds 1 2 3 --dir made/again`.

Prompt:

```text
Use earshot forge to make four variants of a <sound type> against my reference folder <refs dir>, then read report.md and tell me which pick is closest to the references. Verify by listening to audition.wav, not just the scores.
```

Caveat: The search optimizes earshot's own models and can fool them (the README notes this), so check spectrograms and listen; the v1 blind test was a coin flip on one listener and 15 trials.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112336745945788688
- X (Oct 2026): https://x.com/i/web/status/2111927730933575857
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/synthesize-new-sound-with-forge/

### How to pick the best sound from a pile of downloads with earshot

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Game or video maker who downloaded several candidate sound effects and needs to pick one
Problem: Choosing among many similar files by ear is slow, and long recordings hide the one good hit.
Outcome: A ranked list of files for your description, plus start and end seconds for the best moment in a long file.

Steps:
1. Run `earshot rank QUERY PATHS...` with a text description and your candidate files.
2. Run `earshot find keys.ogg "a single mechanical key press" --top 4` on a long file to get trim points.
3. Check a top pick with `earshot match key.ogg "a deep thocky mechanical keyboard press" --alts "a clicky blue switch keyboard" "a mouse click"`.
4. Trim the file at the returned start and end seconds.

Prompt:

```text
Use earshot rank to order the files in <folder> by <description>, then run earshot find on the top file to give me trim start and end seconds. Verify the top pick with earshot match against two alternative descriptions.
```

Caveat: Matching quality depends on the built-in vocabulary of 322 descriptions, so unusual sounds may rank loosely.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112336745945788688
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/rank-downloaded-sounds-by-description/

### How to get a written description of any audio file with earshot

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Builder with a folder of unlabeled sound files who needs to know what each one actually sounds like
Problem: An agent cannot open a .wav or .ogg and tell what it is, how long it rings or how bright it is.
Outcome: A short text reading with calibrated tags, closest alternative readings and numbers like peak level and brightness.

Steps:
1. Install earshot and run `earshot doctor`.
2. Run `earshot describe enter.ogg` (swap in your file).
3. Add `--json` if the agent needs the full structured result, or `--out f.json` to save it.
4. Use the description to label or sort the file in your project.

Prompt:

```text
Use earshot to describe every audio file in <folder> and write a one-line label per file from the tags. Verify one label by listening or by running `earshot match` on it.
```

Caveat: Tags are model readings with a confidence score (z), so treat low-confidence results as hints, not facts.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112336745945788688
- X (Oct 2026): https://x.com/i/web/status/2112319873074241886
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/get-written-description-of-audio/

### How to score a launch film's audio against pro launch films with earshot

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Founder or motion designer finishing a launch video and unsure if the mix is up to standard
Problem: There is no objective way to know if the soundtrack is too quiet, too thin or late compared to professional launch films.
Outcome: A verdict with scored metrics and a numbered list of timestamped fixes, worst first.

Steps:
1. Export your film as a video file with audio.
2. Run `earshot critique film.mp4` on it.
3. Read the VERDICT and the FIX FIRST list.
4. Apply the top fixes in your audio code or editor, then run the critique again.

Prompt:

```text
Run earshot critique on <film.mp4> and summarize the verdict and the top three timestamped fixes. Verify by re-running critique after the changes and comparing how many metrics are in range.
```

Caveat: The scorecard compares against a profile of 7 professional launch films, so it suits launch and promo styles, not every genre.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112336745945788688
- X (Oct 2026): https://x.com/i/web/status/2111936264475910524
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/score-launch-film-audio-with-critique/

### How to turn a recording into code you can vary with earshot

Difficulty: Advanced | Time: 1 hour | Basis: Seen in the wild

Who: Developer who has one good sound and wants endless variations or a blend of two sounds
Problem: A fixed audio file cannot be resized, retuned or varied, so repeated use sounds identical.
Outcome: A recipe module that re-renders the sound with new takes, readable knobs and morphs between two recordings.

Steps:
1. Run `earshot fit click.wav -o made/click_fit.py --report` on your recording.
2. Run the module with `python made/click_fit.py 3 take3.wav` to render a new take.
3. Blend two sounds with `earshot fit --morph a.wav b.wav --amount 0.5 -o made/ab_morph.py`.
4. Explore variations with `earshot fit --forge made/click_fit.py --budget 96 --dir made/click_variations`.

Prompt:

```text
Use earshot fit to convert <recording.wav> into a recipe module, then render three new takes and describe how they differ. Verify the fit by comparing the side-by-side spectrogram in the report.
```

Caveat: The fit stores the structure of the sound, not its samples, so very complex or noisy recordings may reproduce only approximately.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111362487345971409
- X (Oct 2026): https://x.com/i/web/status/2111229504874246441
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/turn-recording-into-editable-sound-recipe/

### How to build a sound kit for a code-made film with earshot

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Developer making a code-rendered film or app demo who needs whooshes, hits and clicks fast, with no recordings
Problem: Hunting for and syncing sound effects by hand is slow, and the agent cannot hear what it picked.
Outcome: A kit.json plus rendered takes for every role, each with measured onset, peak and end times.

Steps:
1. Run `earshot sfx list` to see the bank of 201 sounds.
2. Run `earshot kit init` to start a kit and choose a sound and level per role in kit.json.
3. Run `earshot kit render` to render the cached takes, then `earshot kit check` to read the measured sync points.
4. Run `earshot sfx render ID -o x.wav` to aim any single sound at a moment with `--dur`, `--apex` or `--pitch`.

Prompt:

```text
Use earshot kit to build a sound kit for <film description> with one bank sound per role, render it, and report the measured onset and peak of each. Verify with `earshot kit check` that no role is missing.
```

Caveat: The sfx and kit commands need no models and no network, but the v0.3 bank is new and the README says no blind-test score for v2 sounds is published yet.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112231563429843295
- X (Oct 2026): https://x.com/i/web/status/2112182102477484332
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/build-sound-kit-for-code-made-film/

### How to give Claude Code ears with the MCP server with earshot

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Developer using Claude Code or another MCP-capable agent on audio-heavy projects like films and games
Problem: Calling the CLI repeatedly reloads models for 20 to 40 seconds each time, which makes listening loops painfully slow.
Outcome: The agent calls describe, match, timeline and critique as tools with models kept loaded.

Steps:
1. Install earshot and run `earshot doctor --load` to confirm models load.
2. Start the server with `earshot mcp`.
3. Register it in your agent's MCP settings (inferred, follows your agent's usual MCP config).
4. Ask the agent to listen to a file and describe it to confirm the tools respond.

Prompt:

```text
Connect to the earshot MCP server and use its tools to describe <audio file> and critique <video file>. Verify the tool list shows the listening tools before relying on them.
```

Caveat: The README says the MCP server works for Claude Code and other agents but does not give a config snippet, so the registration step depends on your agent.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112319873074241886
- X (Oct 2026): https://x.com/i/web/status/2111718127440433210
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/let-agent-listen-via-mcp-server/

### How to check that sound hits land on your video cuts with earshot

Difficulty: Intermediate | Time: 45 minutes | Basis: Seen in the wild

Who: Developer whose coding agent renders a product demo video and wants the audio to line up with the cuts
Problem: The agent can render a film in code but cannot hear whether a hit lands 80 ms after the cut.
Outcome: A timeline of sound events, loudness and sync results against the cuts, so the agent can adjust timings.

Steps:
1. Install earshot and run `earshot doctor` to confirm models and data load.
2. Run `earshot timeline FILE --video V` on the rendered film (replace FILE and V with your paths).
3. Read the events and sync section, then have the agent shift the offending cues.
4. Re-render and run the timeline again to confirm the offsets shrank.

Prompt:

```text
Use earshot to run a timeline on <film.mp4> with its audio and video, then list every sound event that misses a picture cut and by how many milliseconds. Verify by re-running the timeline after your fix.
```

Caveat: Each CLI call reloads the models (about 20 to 40 seconds), so use the MCP server or one Python script for repeated checks.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2112336745945788688
- X (Oct 2026): https://x.com/i/web/status/2111718127440433210
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/check-sound-lands-on-video-cuts/

### How to tell a real recording from a code-made sound with earshot

Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Who: Audio-minded builder checking whether a sound in a project reads as a real recording or an obvious synthesis
Problem: It is hard to tell, without careful listening, whether a sound will pass as real or give itself away.
Outcome: A real versus synthesized verdict with evidence and per-window scores, plus a plain-words A/B of two sounds.

Steps:
1. Run `earshot realness FILE...` on the files you want to check.
2. Run `earshot ab A B` to compare two sounds or two trims in words.
3. Run `earshot compare FILE --refs DIR` to see the nearest reference recordings.
4. Use the findings to decide which sound to rework.

Prompt:

```text
Use earshot realness on <files> and earshot ab on the two closest candidates, then tell me which one reads as most real and why. Verify with a listening check, since the realness model can be fooled.
```

Caveat: The README warns the realness model is easy to fool (a modal resonator plus a room and noise floor reads as real), so do not treat the verdict as proof.
URL: https://dedupedai.com/use-cases/leonxlnx-earshot/detect-real-vs-synthesized-audio/

## 13. heygen-com/hyperframes

GitHub: https://github.com/heygen-com/hyperframes
Page: https://dedupedai.com/use-cases/heygen-com-hyperframes/

Write ordinary HTML and get a rendered video out. Built so agents can make videos without a video model.

Audience: For anyone with a coding agent (Claude Code, Codex, Cursor and similar) who wants finished MP4s from a text prompt, and for developers who prefer editing video as HTML instead of a timeline.

Requirements:
- Node.js 22 or newer
- FFmpeg installed locally
- A coding agent that supports skills (Claude Code, Codex, Cursor, Gemini CLI, OpenCode and others)
- No GPU or paid API key is stated in the README for local rendering

### How to build an animated chart or stat clip for social with hyperframes

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Analyst who wants a 10-second animated number or chart for a post or slide
Problem: Static charts get scrolled past, and making an animated version in an editor takes hours.
Outcome: A short unnarrated motion graphic as an MP4 (or a transparent overlay) with kinetic type or a chart reveal.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /motion-graphics and describe the stat or chart plus the numbers to show.
4. Choose MP4 or transparent overlay when asked.
5. Check the rendered numbers against your source data.

Prompt:

```text
Use /motion-graphics from heygen-com/hyperframes to make a 8-second animated chart showing <data description>. Verify every number on screen matches the values I gave you.
```

Caveat: The agent writes the numbers into the animation itself, so wrong or rounded values will render confidently and must be checked by you.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111745594092097630
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/build-animated-chart-or-stat-video/

### How to fix a date or price in a finished video by editing HTML with hyperframes

Difficulty: Beginner | Time: 15 minutes | Basis: Seen in the wild

Who: Marketing manager whose launch date just moved from Friday to Monday
Problem: A last-minute text change in a launch video usually means reopening a project and re-exporting by hand.
Outcome: The same animation re-rendered locally as a new MP4 with the corrected text.

Steps:
1. Open the HyperFrames project folder your agent created for the video.
2. Ask the agent to change the text (for example Friday to Monday) in the HTML.
3. Have the agent re-render the video locally.
4. Play the new MP4 and confirm the animation timing is unchanged.

Prompt:

```text
In my HyperFrames project for <video name>, change the text '<old text>' to '<new text>' and re-render the MP4 locally. Verify the animation timing matches the previous render.
```

Caveat: This only works if the video was built as a HyperFrames HTML project, so an MP4 made in another editor cannot be changed this way.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111819591567479080
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/edit-video-text-with-one-html-change/

### How to make a 10-second product intro from one prompt with hyperframes

Difficulty: Beginner | Time: 30 minutes | Basis: Seen in the wild

Who: Solo founder who needs a launch clip for tomorrow and has no video editing skills
Problem: A short product intro normally means learning an editor or paying a motion designer.
Outcome: A rendered 10-second MP4 with a fade-in title, background video and subtle music, built by your agent from HTML.

Steps:
1. Install Node 22 and FFmpeg on your machine.
2. In Claude Code, run: claude plugin marketplace add heygen-com/hyperframes
3. Then run: claude plugin install hyperframes@hyperframes
4. Run /hyperframes:hyperframes and prompt: create a 10-second product intro with a fade-in title, a background video, and subtle background music.
5. Open the rendered MP4 and ask the agent to adjust anything you dislike.

Prompt:

```text
Using the heygen-com/hyperframes skills, create a 10-second product intro for <product name> with a fade-in title, a background video and subtle music. Render it to MP4 and tell me where the file is so I can check the title timing.
```

Caveat: Local rendering needs Node 22+ and FFmpeg, and the background video and music still have to come from files or sources you have rights to use.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111925536851390581
- X (Oct 2026): https://x.com/i/web/status/2111793849056293254
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/make-10-second-product-intro-video/

### How to turn a merged pull request into a changelog video with hyperframes

Difficulty: Intermediate | Time: 30 minutes | Basis: Seen in the wild

Who: Developer who wants a release note people will actually watch after merging a feature
Problem: Changelogs in text get skipped, and nobody has time to storyboard a clip for every PR.
Outcome: A short changelog, feature-reveal or fix explainer video generated from the PR contents.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills in the picker, then restart your agent.
3. Make sure the gh CLI is set up so the agent can read the PR.
4. Run /pr-to-video with a PR URL or owner/repo#N reference.
5. Review the rendered MP4 against the PR description.

Prompt:

```text
Use /pr-to-video from heygen-com/hyperframes on <owner/repo#N> and render a short changelog video. Verify every claim in the video matches the PR description and diff.
```

Caveat: The skill reads the PR through the gh CLI, so it needs gh installed and authenticated, and a private repo's code will be read by your agent.

Seen in the wild:
- X (Oct 2026): https://x.com/i/web/status/2111841891989770443
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/turn-merged-pull-request-into-changelog-video/

### How to make a launch video from your product's website URL with hyperframes

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Indie maker with a live landing page and no budget for a promo video
Problem: Turning a website into a launch clip usually means screen recording, cutting and animating by hand.
Outcome: A 30 to 90 second launch or site-tour video built from the site's own visuals and your brief.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /product-launch-video with your site URL and a one-line brief.
4. Confirm the creation brief the agent proposes, then let it render.
5. Watch the MP4 and ask for edits to pacing or copy.

Prompt:

```text
Use /product-launch-video from heygen-com/hyperframes on <website URL> to make a 45-second launch video. Verify the features shown on screen match what the site actually offers.
```

Caveat: The skill captures visuals from the site, so only point it at sites you own or have permission to feature.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/make-launch-video-from-product-website/

### How to add designed captions to a talking-head video with hyperframes

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Creator with a recorded talk or podcast clip who needs captions that look designed
Problem: Auto-captions are plain, and styling them in an editor eats an evening.
Outcome: The original footage with verbatim captions, or captions embedded behind the subject, rendered as a new MP4.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /embedded-captions and point it at your video file.
4. Pick a caption style (verbatim rail, embedded climax, or pure-cinematic embed).
5. Read through the rendered video and fix any misheard words.

Prompt:

```text
Use /embedded-captions from heygen-com/hyperframes on <video file> with a verbatim rail style. Verify the captions match what is said word for word.
```

Caveat: Caption accuracy depends on transcription of your audio, so noisy audio or names and jargon will need a manual proofread.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/add-designed-captions-to-talking-head-video/

### How to explain a topic in a faceless video from plain text with hyperframes

Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Who: Educator or newsletter writer who wants a short explainer without filming or sourcing stock clips
Problem: Explaining a concept visually usually needs footage, a presenter or an illustrator.
Outcome: A faceless explainer MP4 where every visual is generated as typography, abstract motion, diagram or data-viz.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /faceless-explainer and paste the text or topic you want explained.
4. Confirm the brief the agent proposes, then let it render.
5. Check the video for factual accuracy before publishing.

Prompt:

```text
Use /faceless-explainer from heygen-com/hyperframes to turn this text into a 60-second explainer video: <paste text>. Verify each on-screen claim against my source text.
```

Caveat: All visuals are invented by the agent, so diagrams and data shown can be wrong and need a fact check against your source text.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/explain-a-concept-with-faceless-video/

### How to build a pitch deck that is an interactive HTML deck with hyperframes

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Founder preparing a pitch who wants branching or clickable sections instead of a flat PDF
Problem: Standard slide tools make linear decks, and interactive navigation means custom front-end work.
Outcome: A navigable presentation with discrete slides, fragment reveals, hotspot navigation and presenter mode.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /slideshow and describe the deck, audience and sections.
4. Open the generated deck and click through every slide and hotspot.
5. Ask the agent to fix any navigation that does not behave as expected.

Prompt:

```text
Use /slideshow from heygen-com/hyperframes to build a 10-slide pitch deck for <company> with fragment reveals and presenter mode. Verify every hotspot link goes to the right slide.
```

Caveat: The README says the slideshow output is a navigable deck, not a rendered video, so use a video skill instead if you need an MP4.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/build-slide-deck-as-navigable-html/

### How to turn a music track into a beat-synced lyric or promo video with hyperframes

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Musician or small label with a finished track and no budget for a music video
Problem: Syncing visuals to a beat by hand is tedious, and most free tools give generic results.
Outcome: A beat-synced lyric, slideshow or kinetic promo video where the music drives the cuts.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /music-to-video with your audio file and a short style brief.
4. Choose lyric, slideshow or kinetic promo when asked.
5. Watch the render and check that cuts land on the beat.

Prompt:

```text
Use /music-to-video from heygen-com/hyperframes on <audio file> to make a kinetic promo video. Verify the main visual changes land on the beat.
```

Caveat: Only use tracks you own or are licensed to use, and the visual quality is limited to what an agent can build from HTML, CSS and your own media.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/turn-music-track-into-beat-synced-video/

### How to add lower-thirds and pull-quotes to an interview recording with hyperframes

Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Who: Podcaster repackaging a long interview into a polished clip for social
Problem: A plain interview recording looks flat, and adding overlays one by one in an editor is slow.
Outcome: The same footage with designed lower-thirds, kinetic titles, pull-quotes and side panels rendered into a new MP4.

Steps:
1. Install the skills with: npx skills add heygen-com/hyperframes
2. Pick Core Skills and restart your agent.
3. Run /talking-head-recut and point it at the interview file.
4. Tell it which speaker names, stats and quotes to feature.
5. Review the render for text that covers the speaker's face.

Prompt:

```text
Use /talking-head-recut from heygen-com/hyperframes on <interview video> to add a lower-third for <speaker name> and two pull-quotes. Verify names and quotes are spelled and attributed correctly.
```

Caveat: The README describes this as packaging footage you already have, so it does not fix poor audio or video quality in the source.
URL: https://dedupedai.com/use-cases/heygen-com-hyperframes/package-interview-with-graphic-overlays/

## Disclaimer

Deduped lists open-source repositories that belong to other people. We do not own, maintain, audit, or vouch for any of them, and a repo appearing here is not an endorsement or a safety check. The use cases, steps, and prompts are written by AI and may be incomplete, outdated, or just wrong. Where a use case is marked "Seen in the wild", we link to public posts where someone described something similar, but we have not verified those posts and the use case itself is still our AI's own write-up. Use all of this at your own risk. Only run code, commands, or agents on systems and accounts you are authorized to use, and read the code and every command before you run it, especially anything that touches credentials, files, or the network. Nothing here is professional, security, legal, or financial advice. All trademarks and project names belong to their respective owners, and their use here does not imply affiliation. Content is provided as is, without warranties of any kind. Found a mistake, a safety problem, or something you want removed? Email hello@dedupedai.com and we will look at it promptly.