# 用例AI / UseCase AI > Bilingual (Chinese/English) directory of AI tools organized by real use case. Open data: https://ttqq.dev/data.json ## Categories - [coding](https://ttqq.dev/en/category/coding/) - [writing](https://ttqq.dev/en/category/writing/) - [research](https://ttqq.dev/en/category/research/) - [image](https://ttqq.dev/en/category/image/) - [video](https://ttqq.dev/en/category/video/) - [audio](https://ttqq.dev/en/category/audio/) - [design](https://ttqq.dev/en/category/design/) - [productivity](https://ttqq.dev/en/category/productivity/) - [automation](https://ttqq.dev/en/category/automation/) - [marketing](https://ttqq.dev/en/category/marketing/) ## Use cases - [Georges Petrov has Claude Code film a demo video for each docs page with open-source Screenplay, and a nightly check goes red when a button is renamed](https://ttqq.dev/en/tool/agent-screenplay-docs-videos-stale-check/): Screenplay (agent-screenplay) + Claude Code — A short video on every feature page of SaaS docs helps, but each takes an hour to make and goes stale after the next release. Georges Petrov (@georges_petrov) writes each video as a small script: an agent explores the feature in a demo account and writes the steps, and the open-source tool Screenplay clicks through them in a headless browser, films and edits the take (smoothed cursor, zooms that follow clicks, captions, optional voice). The same script is a test: check replays it fast without filming and fails when a button was renamed or removed, so a nightly CI job tells you which video is out of date. On Linux we installed Screenplay 0.1.7, filmed a 22-second 1080p video of its bundled example app, then renamed the "Take over" button; check failed at step 3 with exit code 2. (https://github.com/gmpetrov/agent-screenplay) - [MPC gave Claude Code three backend skills and cut critical mistakes on 15 hidden-check backend tasks from 25 in 150 runs to 2](https://ttqq.dev/en/tool/backendskills-hidden-checks-25-to-2-critical/): backendskills + Claude Code — AI-written backends often work in the demo and break in production on concurrency, permissions and schema changes. backendskills is three open-source skills from MPC (globalmpc): api-endpoint (scope queries to the caller, 4xx on bad input, rate-limit login and costly routes), data-integrity (locks or conditional updates for read-then-write, UNIQUE constraints, idempotency keys on anything that charges or sends) and db-migration (expand then contract, concurrent indexes, batched backfills, down migrations). The authors built 15 backend tasks, each with a hidden check the agent never sees (20 buyers at once for 5 items, reading someone else's order, old and new app versions mid-deploy), and ran Sonnet 5.5 and Haiku 5.5 five times each with and without the skills. Critical mistakes fell from 25/150 to 2/150, mostly thanks to the login-rate-limit and rename-column tasks; each run cost roughly twice as much. We recomputed the published raw runs and ran the benchmark's 22 self-tests against a local PostgreSQL. (https://github.com/globalmpc/backendskills) - [Guizang built a xianxia 3D action game, Mist-Locked Mountain Gate, in one afternoon with Claude Fable 5.2, then turned the lessons into an open-source skill](https://ttqq.dev/en/tool/guizang-game-skill-fable-3d-action-game/): 歸藏 Game Skill + Claude Code (Fable 5.2) — Guizang (@op7418) only asked for "Chinese xianxia style" and had Claude Fable 5.2 build a top-down 3D action game, Mist-Locked Mountain Gate, in one afternoon: one map, a mob fight and a two-phase boss, with a three-hit combo, dodge, block and parry, an ultimate and 8 voiced lines, packed into one ~33 MB HTML file that plays in desktop and mobile browsers. Characters started as concept art in Jimeng, became rigged 3D models in Tripo, and the music came from Suno. He then wrote the workflow and his list of pitfalls into guizang-game-skill: install it in Claude Code or Codex, describe your game, and it asks questions first, connects your asset tools, checks its own screenshots and packages the result. We inspected the repo, ran its local server script and scanned it with SkillSpector; we did not build a game. (https://github.com/op7418/guizang-game-skill) - [Oil spent one to two months having AI build Oil Studio, a Mac screen recorder and editor, in Swift he didn't know, and wrote up how he keeps the repo from falling apart](https://ttqq.dev/en/tool/oil-studio-ai-long-project-governance/): Claude + Codex (oil-delegate) + Git Worktree — Oil (@I_am_oil_oil, author of oil-ui and oil-tone) had AI build Oil Studio, a macOS screen recorder and editor, from scratch in Swift, a language he hadn't used. Left unchecked over a long project, he found five kinds of mess: every screen with its own styles, hard-coded values everywhere, the same function written twice, old code never deleted, and stale docs misleading later work. His process has six parts: have AI research open-source projects and pick the language before coding; let Claude lead the conversation and write plans while oil-delegate hands critique, coding and review to Codex; develop in parallel with Git Worktree and split tests into layers; write recurring pitfalls into AGENTS.md and Review.md; have AI periodically check docs against the code and prune them; for stubborn bugs, have two strong models investigate and give a confidence level, and gate releases with scripted checks. We ran oil-delegate's unit tests and environment check; the overall process is untested. (https://book.oiloil.org/articles/agent-long-project-management) - [Ganesh Iyer wanted to animate a story his daughter wrote, so he used Claude Code with the open-source tool REA to tear down two story-animation apps and see how they work](https://ttqq.dev/en/tool/rea-product-teardown-skill-claude-code/): REA + Claude Code (product-teardown skill) — Ganesh Iyer (@ganeshiyer316) wanted a short animated video of a story his 7-year-old daughter wrote. Existing tools were pricey and didn't fit, so he tore down two of them first. He made one story in each app while the open-source tool REA (Reverse Engineer Anything) recorded what the app sent and received, keeping only field names, and had Claude turn that into a teardown report with his product-teardown skill: front-end steps, API calls, where media comes from and which AI providers are likely. Every finding is labeled Seen (in the traffic) or Best guess. He shares the skill free on GitHub. We ran the skill's bundled domain logger on our server; we did not install REA or tear down a real product. (https://github.com/ganeshiyer316/claude-skills/tree/main/skills/product-teardown) - [KKman scans unfamiliar agent skills with NVIDIA's open-source SkillSpector before installing; Anthropic's own docx skill scored 86, and reading the flagged lines showed normal file handling](https://ttqq.dev/en/tool/skillspector-scan-skills-before-install/): SkillSpector (NVIDIA) — A skill is an instruction file for your AI assistant, so installing a stranger's skill means letting a stranger give your assistant orders. KKman (@JackLuiKK) cloned NVIDIA's open-source scanner SkillSpector (Apache-2.0) on Linux and ran static checks only on three samples: the repo's clean example scored 0, its malicious example 100, and Anthropic's official docx skill 86 with a DO NOT INSTALL verdict. Opening the flagged lines, he found normal steps for repacking Word files and launching LibreOffice. His takeaway: the score is where you start, and you still read the flagged lines. We reran the same three scans and got the same scores, issue counts and coverage, then scanned two newer skills and saw the same pattern. (https://github.com/NVIDIA/SkillSpector) - [Meng Jian built a stick-figure animation skill in Claude Code; one 15-second 60 fps explainer cost $0.54, and changing a line needs no re-generation](https://ttqq.dev/en/tool/claude-code-stickman-skill-explainer-short-054/): Claude Code + stickman-animator skill + FFmpeg — Meng Jian (@xjtumj) makes explainer shorts for overseas audiences. With video-generation models, credits ran out fast, characters drifted between shots, and changing one line meant paying to re-generate. He switched to stick-figure animation written as code with Claude Code: first, with no skill, Claude wrote a 15-second animation page in 64 seconds, but the figure's proportions and arms were off; then he had Claude build a stickman-animator skill with a spec, an engine.js that locks the main character's bone lengths, and an export-mp4.js that records the page with the local browser (about 8 minutes, 11 preset poses such as waving, pointing, thinking, panicking); in a new chat he only described the topic and three scenes, and Claude picked up the skill on its own and produced an animation with Chinese–English subtitles; adding floating text and a badge was a code edit; exporting took 52.2 seconds for a 1280×720, 60 fps, 900-frame, 0.81 MB MP4. /cost showed $0.5391 for the whole session. We did not reproduce this, and the article does not publish the skill files. (https://x.com/xjtumj/status/2120795803589775425) - [Cristian Calabro ran Google's open-source EGM plugin in Codex on a docs-only change, designing and reviewing it before coding, and it caught three things he would have shipped](https://ttqq.dev/en/tool/egm-elephant-goldfish-codex-small-feature-review/): Elephant-Goldfish Model (EGM) + Codex CLI — EGM (Elephant-Goldfish Model) is a design-review plugin Google open-sourced in November: the "elephant" agent holds project context and drafts the spec, "goldfish" reviewer subagents read only the document and referenced code with no earlier conversation, and you decide. Cristian Calabro (@c_calabro) tried it on a tiny request in a repo-checking CLI he's building: make scan --targets show JSON and YAML samples in --help and CLI.md. In Codex CLI he went through brainstorm, draft, review, implementation and a drift report. Results: the brainstorm's seven review lenses warned the four samples could drift apart, so a parity check went into the acceptance criteria; the implementation-plan review noticed the scanner check would write reports into the repo being scanned, against his AGENTS.md, so it moved to a temp folder outside the repo; the closing drift report found the docs never said commit values are compared exactly. On Linux we cloned the EGM repo (0.1.1, Apache-2.0) and ran its offline unit tests: 381 passed, 2 skipped. We did not install the plugin in Codex or Claude Code and run the workflow. (https://github.com/google/elephant-goldfish-model) - [ZinkLu had Claude review 1,050 of his agents' memory recalls one by one; about one in ten was confirmed used, and he drew practical rules for using memory better](https://ttqq.dev/en/tool/nowledge-mem-agent-memory-audit-1050-recalls/): Nowledge Mem + Codex / Claude Code / OpenCode — ZinkLu (@ZinkLu2) uses Codex, Claude Code, OpenCode, Kimi Code and Hermes across a Mac and two Linux machines, all sharing one self-hosted Nowledge Mem memory store. After installing it he wanted to know how much it actually helped. He gathered 3,230 sessions, kept the 1,078 after memory was connected, defined a "recall window" as the stretch from one recall to the next (1,050 in total), and had Claude Opus 5.5 check each one against the prior context, the returned memory and what the agent did next; every "used" verdict needed a verbatim quote, checked by a script. Results: 101 windows confirmed used, 9.6% strict or 12.4% lenient; memory took a median 4.1% of context; empty results and errors were 28% of recalls. The details are the useful part: the first recall in a session was used 19.6% of the time versus 9.5% after; queries over 60 characters were used 18.2% versus 3.3% for under 15; retrying right after an empty result or error rarely helped; memories under a day old were used more than those over 30 days; and on the same 120 real queries, memory search gave directly usable results 25.8% of the time versus 6.7% for searching past sessions. We did not reproduce this analysis. (https://mem.nowledge.co/) - [ZDNET's David Gewirtz locked OpenClaw on its own Mac Studio with Claude Code as the warden, authorized 11 escape attempts, and all failed](https://ttqq.dev/en/tool/openclaw-mac-studio-claude-code-warden-11-escape-attempts/): OpenClaw + Claude Code + Ollama Cloud — David Gewirtz (@DavidGewirtz, ZDNET columnist) wanted the local agent OpenClaw running 24/7 without letting it loose. His setup is "warden and prisoner": OpenClaw runs on an old M1 Mac Studio under its own user with no access to any of his accounts, using GLM-5.2 through a $20/month Ollama Cloud plan; Claude Code runs on his own Mac and only tunnels in over SSH to configure and check, then shuts down. Along the way Claude found two problems: its own instruction files first sat where OpenClaw could read them (the warden's notes in the prisoner's cell), and OpenClaw's file-read size limit meant it had never read his two most important rules (ask David before anything leaves the machine; never claim a failed tool call succeeded), which Claude spotted in OpenClaw's own logs. Then, with his authorization, Claude had OpenClaw actively try to break into the admin side. It tried 11 ways (writing admin files, privilege back doors, scripts and links around permissions, pointing its browser at local file URLs) and macOS permissions stopped all of them. For email, he had Claude Code write a script that only mails his one address, and OpenClaw can only drop text files into a folder. We did not reproduce this setup. (https://www.zdnet.com/innovation/openclaw-agent-claude-code-security-test/) - [Gary Zhang pinned a to-do list in cmux's side Dock that opens one Claude Code chat per item, and on day one it caught two things booked at 5 pm](https://ttqq.dev/en/tool/today-board-cmux-todo-dock-agent-workspace/): Today Board + cmux + Claude Code — Gary Zhang (@GaryZhang124) built a home assistant: an always-on Mac mini turns each day's messages into a briefing. The last step was the problem: what to start on in the morning, when every item was buried in chats. His fix is Today Board: a small local-only web list pinned in the Dock of cmux (a terminal that runs several agents side by side), with five tabs: schedule, in progress, to confirm, done, ignored. Clicking an item's "处理" (handle) opens a cmux workspace named after it, with Claude Code already given the item's text and time. Items a script extracts land in "to confirm" until he approves them. The list itself is one Markdown file. On day one it flagged a 5 pm interview from work messages and a 5 pm class from WeChat as a clash. We tested it on Linux: the 3 bundled tests passed; adding items, changing status and importing an inbox JSON (duplicates skipped) all worked; the page returned 200 and marked two 5 pm items as a time clash. Without macOS and cmux we could not test the Dock or the handle-to-workspace button. (https://github.com/zhangxingyi-sudo/today-board) - [Rajesh made a Claude Code skill that turns a tech topic into a 1080p explainer with hand-drawn animation, a cloned voice and sound effects, all on your machine](https://ttqq.dev/en/tool/under-the-hood-claude-code-narrated-explainer-video/): under the hood (Claude Code skill) — Rajesh (@royalreplaced) open-sourced under the hood: in Claude Code you say "make a video about what happens when you git push", and the skill checks your setup, asks one or two questions (which angle, which voice), shows you the narration and storyboard to approve, then writes a canvas animation, screenshots every scene and fixes overlaps itself, generates two takes per line locally with the open-source TTS model Chatterbox for you to pick, and renders a 1080p MP4 with music that ducks under the voice, a sound on every beat, and loudness at -16 LUFS for X and YouTube. You can also record 20–30 seconds of your own voice to clone. His demo is "what happens when you type cookie into Google". On Linux we rendered the repo's bundled cookie example without narration: a 33.4-second 1080p30 video in about 27 seconds, with complete frames. We did not test narration, voice cloning or Claude writing a new topic. (https://github.com/Rajesh-Royal/under-the-hood) - [TaXue spent five months building Argo, a search skill that gives Claude Code, Codex and other agents 300 sources and works without an API key](https://ttqq.dev/en/tool/argo-agent-search-skill-300-sources/): Argo (agent search skill / MCP) — Many agents search the web through one or two engines, so a question about a company returns old news and a question about a product returns advertorials. TaXue (@TaXue2025) built Argo for that: a search and deep-research tool for agents, installable as a Skill, an MCP server or a DeepSeek Harness plugin. v2.14.0 lists 300 sources and picks sources by topic and language, de-duplicates and ranks the results, and can also fetch page text, WeChat articles, PDFs and papers. Without API keys it uses only free and local sources; sources with keys join automatically. We cloned v2.14.0 (1345696) and installed only pyyaml, with no keys: 237 sources were callable on our machine; an English query returned 5 results (including the original post and blog) in about 2.8 s, and a Chinese query returned 5 Chinese results from Sogou WeChat and anysearch in about 2.7 s. We did not test deep research, logged-in search or the MCP setup. (https://github.com/taxueseek/argo) - [Hamza has Claude Code write an HTML page with a render(t) function, screenshots it frame by frame with Playwright and encodes with ffmpeg, making 30-second motion graphics at no cost beyond his Claude subscription](https://ttqq.dev/en/tool/claude-code-motion-graphics-render-t-playwright-ffmpeg/): Claude Code + HTML render(t) + Playwright + ffmpeg — In late September, X filled with Claude motion videos credited to "one prompt," and most copies came out with five fonts, a rainbow palette and every word flying in from a different direction. Hamza (@imhmxi) wrote up the process he actually uses: a brief and a timed scene list first, then a STYLE.md of restraint rules (one type pairing, one accent colour, one easing), then Claude Code writes a page that only draws the frame for a time t, Playwright screenshots it at 30 fps, and ffmpeg encodes the frames. After each render he makes a contact sheet of sampled frames for himself and Claude to review, then adds sound and captions. He says it costs nothing beyond an existing Claude subscription. Following the method, we wrote a 3-second 1080×1920 page (headline fade-in, accent rule, caption), captured 90 JPEG frames with Playwright in about 5 s, encoded a 3-second MP4 with ffmpeg and built a 3×3 contact sheet; each element appeared on schedule. We did not test sound, captions or his full prompt templates. (https://x.com/imhmxi/status/2120362086253412510) - [Rohit Kashyap built Dejo, a browser MCP that lets Claude Code learn a website task once and replay it with no model calls; he measured 78% fewer tokens on repeat runs](https://ttqq.dev/en/tool/dejo-browser-mcp-remembers-websites/): Dejo (browser MCP) — Driving websites through Playwright MCP means the agent re-reads every page each time, so a task it did yesterday costs full tokens again today. Rohit Kashyap (@rohit_jsfreaky) built Dejo, a browser MCP for agents: the first time, the agent walks the task and Dejo saves each step together with what should be true afterwards; after that the same task is one tool call, and Dejo replays it without reading the page or calling a model. When a site changes, it stops at the step that didn't land and asks the agent to relearn only that step. Against Playwright MCP on 19 tasks across 11 lesser-known sites, he reports 38% fewer tokens on the first run and 78% fewer on every run after, with the data public. We pip-installed dejo-mcp 0.5.1 and dejo doctor passed; acting as the agent through a minimal MCP client, we taught it to read the first paragraph on example.com, then replayed it twice from a fresh process with dejo run: 105 ms and 85 ms, model_calls 0. We did not reproduce his 19-task benchmark. (https://github.com/dejohq/dejo-mcp) - [caiman, a visual designer who doesn't code, used Claude Code to get an iOS app approved on the App Store in 11 days, then open-sourced the six-agent workflow as a plugin](https://ttqq.dev/en/tool/designer-app-flow-claude-code-ios-app-store/): designer-app-flow (Claude Code plugin) — caiman (@caiman__) is a brand and motion designer who doesn't write Swift. With Claude Code he built BeanDance, a native iOS app that remembers the grind size for each bag of coffee: 11 days from new project to first approval, 5 releases and 21 TestFlight builds in a month, live in 175 storefronts including mainland China, with 320 rule tests. He says the hard part wasn't code but three questions: who decides, how to know it's right, and how to ship. So he set rules: every screen starts as 2–3 directions on a canvas and code is written only after he picks one; decisions go into docs, and thinking out loud in chat doesn't count; the agent that writes code doesn't approve its own work, because a read-only review agent and a black-box tester that only taps through the simulator check it; uploading, submitting and releasing are triggered only by him. He packaged the roles, doc templates and 150+ lessons as the Claude Code plugin designer-app-flow. We cloned it and ran its init script in an empty folder: the 6 agents and 3 skills were renamed for the new app, and the script listed the placeholders still to fill (Team ID, Bundle ID and so on). We did not build an iOS app or go through App Store submission. (https://github.com/caiman001/designer-app-flow) - [Leaf paired the open-source cleaner Mole with Claude to cross-check scans, freeing about 315 GB over three and a half months on a 500 GB MacBook without losing personal files](https://ttqq.dev/en/tool/mole-claude-mac-disk-cleanup-315g/): Mole + Claude Code — Leaf (@leaf_sanren) filled a 500 GB MacBook 10 times in three and a half months. His method scans twice: first Mole, tw93's open-source cleanup CLI, with mo clean --dry-run as a preview, then Claude over the home folder, and the two lists are reconciled. Items on both lists are safe; items only Mole found mean Claude missed them (Claude's first pass skipped hidden folders like .npm, about 25 GB); items only Claude found are usually places Mole doesn't know yet, such as 83 GB of CapCut (Jianying) cache in the Movies folder. He decides before anything is deleted, quits the app, deletes one folder at a time, and trusts only the free space df reports. Ten rounds freed about 315 GB. He also sent Mole two PRs for Jianying and Feishu caches, both merged. The article lists four kinds of cache to clear and six things that look like junk but must not be deleted. On Linux we tested Mole's Linux branch: running ./mo clean --dry-run from the repo listed about 102 MB of npm, Bun, pip and uv caches in just over a second, and deleted nothing. We did not test the macOS build or the Claude reconciliation. (https://github.com/tw93/Mole) - [Chen Dahuang open-sourced his anti-AI-tone writing setup as a Skill: pick one voice card with real human examples per genre, and keep only 20–30 banned words as a guardrail](https://ttqq.dev/en/tool/open-writing-skill-voice-cards-de-ai-tone/): open-writing-skill — A common anti-AI-tone fix is to paste a list of hundreds of banned words. Chen Dahuang (@realchendahuang) argues this backfires: with only prohibitions and no good writing to imitate, the model either swaps in a synonym or strips sentences down to a manual, and putting long-form and short-post rules in one prompt mixes their voices. His setup has three layers: one "voice card" per genre, with the positive style, genre-specific don'ts and two real human-written examples; read only the one card for this piece; and an outer list of just 20–30 of the worst words and patterns. Two hard rules sit on top: don't invent facts, and when editing a draft keep its structure. He stripped personal details and open-sourced it as open-writing-skill, with four cards (long articles, short posts and tool recommendations, community questions, lessons-learned notes) plus a single-file version for web chat; he suggests Gemini with thinking set to Low. We installed it into a Claude Code project folder with npx skills add and checked the entry file and the four cards; we did not write with it or compare before and after. (https://github.com/realchendahuang/open-writing-skill) - [Huashu tests ByteDance Seedream 5.5: the person still looks like herself after 20 edits, and he open-sources the sprite-sheet → frames → GIF flow for transparent animated stickers as a skill](https://ttqq.dev/en/tool/huashu-selfie-sticker-seedream-animated-gif/): huashu-selfie-sticker + Seedream 5.5 — ByteDance's Seedream 5.5 leads with multi-turn editing: it claims untouched pixels stay put and a single image can be edited a hundred times. Huashu (@AlchainHust) skipped the hundred-turn marathon as too credit-hungry and instead edited a café-window portrait in 10 places, then reverted them one by one, uploading only the previous output each turn: at turn 20 she was still herself. Small edits scored SSIM 0.983–0.995; a moon earring, a wrist mole and a badge stayed put, while the street outside drifted slightly. He also ran multi-turn edits on a living room, a shop poster and a product shot, checked a 706-character cruise magazine spread (including accented place names) character by character with no typos, and composited the woman with a trilingual coffee bag and a wooden mannequin pose. Transparency is a native PNG alpha, not a later cutout. After reverse-engineering GPT Image 2.6's “draw a sprite sheet, then slice frames” GIF trick, he shipped the open-source skill huashu-selfie-sticker (v1.1.0): lock a character sheet from a selfie or any image, draw a 4×2 or 3×3 sprite sheet, then a script slices, aligns and writes 480px and 240px transparent GIFs plus an APNG. On Jimeng with Seedream 5.5 (16:9, 2K, transparent background) he says 9 images landed in one pass and all 64 captions across 8 sets were typo-free; installing the skill in Doubao took about 30 seconds. We cloned v1.1.0 and ran make_gif.py on a homemade 4×2 transparent sprite sheet (it printed “already a transparent original,” cut 8 frames, and wrote the 480/240 GIFs and APNG). Laying the same sheet on magenta and rerunning with --bg #FF00FF, it reported keying out solid #FF00FF (81% of the image) and again cut 8 frames. The repo has no LICENSE file. We did not call Jimeng, Doubao or the Seedream API to generate a real sticker set. (https://github.com/alchaincyf/huashu-selfie-sticker) - [Simon Willison had Claude Code build Beep Locator, turned phones and tablets into a microphone array, and found the beeping carbon-monoxide alarm with a low battery in his storage room to within 40 cm](https://ttqq.dev/en/tool/simonw-beep-locator-claude-code/): Beep Locator (Claude Code) — After a move, something in a box room started beeping at long intervals—too sparse to locate by ear, and Simon Willison (@simonw) did not want to unpack every box. On his phone he used Claude Code Cloud (Opus 5.5, Extra thinking) against an empty repo to write up the problem, then had it build a Python web app: one device opens a coordinator page, and phones, tablets and laptops join in the browser as listeners, sending audio to the server over WebAudio and WebSockets. Letting the devices locate each other by chirping was inaccurate, so he added a Rough mode for dragging icons into approximate positions, plus a clap test (a different map symbol) to check that localization worked at all. When a beep appeared he could replay each device’s clip and mark “this is the mystery beep,” after which the system tightened the estimate from frequency and interval. He reports it got within about 40 cm, and in that pile of boxes he found an old carbon-monoxide alarm that needed new batteries. Mid-project, Fable 5.2 shipped and he continued on his laptop, chatting with the model while the server ran; listener pages can also hot-swap JavaScript over the WebSocket so you don’t reload and re-grant the microphone. We cloned simonw/beep-locator 0.1.0 (449a488, Apache 2.0); uv run pytest passed all 26 tests in 2.63s (plus one Starlette/httpx deprecation warning). After uv run beep-locator serve on local port 8765, the coordinator page, /join and /sim each returned HTTP 200. We did not triangulate with real devices, and we did not start a Cloudflare tunnel. (https://github.com/simonw/beep-locator) - [Cloudflare's open-source security-audit skill keeps the hunter agent and the verifier agent separate, so the AI that wrote the code does not approve its own work](https://ttqq.dev/en/tool/cloudflare-security-audit-skill/): Cloudflare security-audit skill — Asking the same agent session that just shipped a feature to “check security once more” invites self-confirmation. Cloudflare's open-source security-audit skill (GitHub cloudflare/security-audit-skill, MIT) packages their vulnerability-discovery orchestration: six phases (recon → coverage-led hunting → candidate validation → structured output → independent record verification → target-neutral reporting), with hunter/verifier isolation and machine-checked findings.json / coverage-ledger.json via zero-dependency validators. Install with npx skills add https://github.com/cloudflare/security-audit-skill --skill security-audit (optional --global). Chinese-community post @divid_lu49394 (9 Nov 2026) summarized usage and limits (one run covers only part of the surface, static source only, NEEDS-VALIDATION must be reproduced by a human). We cloned main @ c1c8a8c and ran the shipped tests under skills/security-audit/: validate-findings.test.cjs 34/34 pass, validate-coverage-ledger.test.cjs 31/31 pass; SKILL.md confirms guidance mode by default and full six-phase runs only when the user explicitly asks for a full audit. We did not run a live Claude/Codex audit against an app repo (expensive and sandbox-sensitive). (https://github.com/cloudflare/security-audit-skill) - [Tencent's open-source TeamAI CLI syncs a team's skills, rules, agents and MCP config from one Git repo, so each person stops keeping their own set](https://ttqq.dev/en/tool/tencent-teamai-cli-team-skills-sync/): TeamAI CLI (Tencent) — When every teammate keeps their own Claude Code / Codex / Cursor skills, rules and MCP servers, configs drift fast. Tencent's open-source TeamAI CLI (npm package teamai-cli, MIT) puts those AI assets in a shared Git repo: after one teamai init, later sessions automatically pull the latest skills, rules, agents, hooks, MCP and workflows. You can also install and share through the /teamai skill inside an agent. Chinese-community account TryAI Lab (@TryAiLabHQ) ran init → pull → push locally on 10 Nov 2026 with v0.29.0: after pull, .claude/ held 1 skill, 7 rules, 76 docs, 3 agents and 21 workflows, and a hand-written my-review skill pushed back into the team repo. Two real pitfalls: the first push right after init fails until you commit the scaffold files TeamAI generated; pull also printed twenty-plus workflow schema warnings where the team's own main-branch workflows failed validation against CLI 0.29.0. We installed teamai-cli@0.29.0 from npm (teamai --version matched), confirmed doctor asks for init when uninitialized, and saw init against teamai-hub/teamai-template stop with “GitHub authentication unavailable” in a non-interactive shell without GITHUB_TOKEN. We also cloned the public template and counted 11 SKILL.md files, 11 rules under rules/common, and 3 review agents. We did not finish an authenticated pull/push, and did not open a Claude Code session to verify the auto-sync hook. (https://github.com/Tencent/teamai-cli) - [Check before you install a skill or MCP: PeepSick's USB+ uses secscan to compare a skill's claims with its body, and mcprobe to watch MCP servers without calling their tools](https://ttqq.dev/en/tool/usbplus-secscan-skill-mcp-trust-layer/): USB+ / @peepsick/usb-cli — Skills and MCP servers are copy-pasted everywhere, and it is hard to know before install whether they read .env, shell out, or delete files. PeepSick Labs' USB+ (Universal Systems Bridge, GitHub PeepSick/usbplus, npm @peepsick/usb-cli, MIT) turns “inspect then install” into a CLI: usb secscan statically compares a skill's declared contract with capability signals in the body; usb mcprobe, with explicit consent, starts MCP servers for a handshake-only observation and does not call tools by default; it can also install from a 529-skill catalog into 16 runtimes. Chinese-community posts by @wlzh (and @MirrortekUK) covered the v1.0.8 trust layer on 9 Nov 2026. We installed @peepsick/usb-cli@1.0.8: usb version reported current/latest 1.0.8 and catalog “Universal Systems Bridge Catalog”; usb search postgres returned 16 hits; usb list listed 529 skills; secscan on two local demo skills flagged a sneaky skill whose friendly frontmatter hid .env reads and rm -rf (HIGH secrets-access, MEDIUM destructive-commands, exit 1); secscan --repo cloudflare/security-audit-skill also flagged an fs.rmSync signal in tests (MEDIUM). We did not run usb install for the full 529-skill pack, and did not run mcprobe --yes against a live MCP server. (https://github.com/PeepSick/usbplus) - [Khazix's Agent Autoloop dispatches CLI agents in the background, exits when they are waiting, and only sends a Feishu or desktop card when it needs your decision](https://ttqq.dev/en/tool/agent-autoloop-background-cli-agents/): Agent Autoloop — With Claude Code or Codex, work usually stops the moment you close the terminal or walk away. Chinese-community author 数字生命卡兹克 / Digital Life Khazix (@Khazix0918, GitHub KKKKhazix) open-sourced the dispatcher he had used for a year as Agent Autoloop (MIT): a local, zero-runtime-dependency kernel that reads rules.json and hands cron jobs, GitHub issues, alerts and other events to a CLI agent you already signed into. The agent runs one round and exits. Deleting data, rebooting, spending money or messaging the outside world becomes a card on Feishu, DingTalk, WeCom, Slack, Discord or the desktop; while you decide, nothing sits around burning tokens, and answering resumes the same session. The kernel claims to do only four things—ingest events, route them, dispatch an agent, and record what happened—with zero-cost suspend, event sourcing, separating instructions from untrusted input, and a hop circuit breaker at 8 layers. Events, agents, channels and delivery are plugins. Bundled recipes cover a morning brief, GitHub issues, alerts, website watch, Feishu weekly notes, inbox triage, feedback and PR delivery. Install by handing the repo to your agent (it is told to read INSTALL.md), or run curl -fsSL https://raw.githubusercontent.com/KKKKhazix/agent-autoloop/main/install.sh | sh on macOS/Linux (irm .../install.ps1 | iex on Windows). Node 24+ is required. Windows support landed on 6 November. We cloned main on Linux (fade2ce, after the v1.6.4 release) and ran npm run test:quick with Node 24.11.0: 697 of 719 tests passed, 0 failed, 22 skipped because this machine is not Windows/macOS or has no Claude Code. We did not run the installer, agent-autoloop try against a live Claude/Codex login, or Feishu. (https://github.com/KKKKhazix/agent-autoloop) - [Waffle's clear-naming skill reads the surrounding code first, then fixes names and explanations an agent translated too literally, such as turning in_flight into a word-for-word Chinese calque](https://ttqq.dev/en/tool/clear-naming-agent-jargon-code-names/): clear-naming — When an agent writes or explains code in Chinese, you often get calques like 'wait for flying tasks to drain' for in_flight, and names that don't say whether something is a running task or a request awaiting a response. Chinese-community author Waffle (@Jiaoao1024, GitHub ox01024) open-sourced clear-naming (MIT): an instruction-only skill that reads definitions, call sites and state changes before it decides whether to rename and how. The same in_flight might become running_tasks if the set is already started and not finished, or requests_awaiting_response if those are outstanding HTTP calls; established terms such as HTTP, SQL and transactions can stay. Four modes: clarify this explanation only, review without editing, rename in a stated scope and update references, or merge two short principles into AGENTS.md. Install: npx skills add ox01024/clear-naming. We read SKILL.md and examples.md and checked that the tweet's examples appear in the docs; there is no runtime script to run, and we did not ask an agent to rename a real repo. (https://github.com/ox01024/clear-naming) - [SinFire splits clarifying a task into three steps: align terms, research facts in parallel, then settle decisions in dependency order, so flagship models stop grilling you on trivia](https://ttqq.dev/en/tool/sinfire-skills-clarify-decisions-before-plan/): sinfire-skills — The popular grill-me skill (Matt Pocock) makes an agent interview you before it plans; on today's flagship reasoning models the original 'relentlessly' often means a dozen nitpicky questions. Chinese-community author SinFire (@Sin_Yiyao) reworked grill-me plus his own requirements-clarification practice into sinfire-skills (MIT, v0.1.0): three instruction-only skills, 119 lines of Markdown, no runtime deps. $semantic-clarification (59 lines) only asks what you mean, and will not expand into requirements gathering. $facts-searching (26 lines) dispatches parallel sub-agents to search the web, dedupes, resolves conflicts, and brings back only sourced findings that affect the current decision—unverifiable items stay marked as assumptions. $clarify-decisions (34 lines) stays at the current level, defaults low-impact reversible details, asks only the most consequential frontier questions each round, and recommends an answer only when evidence and stated aims support one. Install: npx skills add SinVC/sinfire-skills --skill clarify-decisions semantic-clarification facts-searching -a codex. We cloned the repo and bun run validate passed for all three skills plus the Codex explicit-invocation policy; we did not run a live Codex/Claude session through the full loop. (https://github.com/SinVC/sinfire-skills) - [sanyam's verso redraws one piece of an existing UI as a Leonardo notebook page, changing only the look and keeping the DOM, handlers and focus order](https://ttqq.dev/en/tool/verso-leonardo-notebook-ui-skill/): verso — Overseas author sanyam (@sanyampunia) open-sourced verso, a skill for Claude Code / Codex / Cursor that redraws one named slice of your UI as a page from Leonardo's working notebooks: laid rag paper, iron gall ink faded to browns, hatching instead of shadows, hand rules, margin notes and pen sketches. Point it at a component, route or selector—/verso the settings card, or /verso app/blog/page.tsx in the forster style. It reads the project's existing Tailwind / CSS Modules / plain CSS and CLAUDE.md first, then converts using one of four papers: Windsor (forms/settings, default), Leicester (articles/release notes), Arundel (dashboards) and Forster (narrow cards/sidebars). Mirror script is decoration only and gets aria-hidden; body text is claimed at 10.3:1 or better, and every line of real text above 4.5:1. Install: npx skills add sanyampunia/verso. He later posted nine before-and-after conversions. We inspected the bundled examples and the ~30KB manuscript.css: after.html is a default Windsor 'Project settings' card (inputs, buttons, margin notes, mirror script); release-after.html uses the Leicester paper. The repo has no LICENSE file. We did not run a /verso session on a live React/Tailwind project. (https://github.com/sanyampunia/verso) - [@Feng_YQ's BeRich skill researches how indie products make money, with 1,169 site dossiers and two research methods: Timeline and Causal Chain](https://ttqq.dev/en/tool/berich-indie-product-growth-research-skill/): BeRich(发财 skill) — Competitive/indie research with agents often invents narratives. Chinese author Max Feng (@Feng_YQ / fengyiqicoder) open-sourced BeRich: 1,169 public dossiers from 闷声发大财 (msfdcszhd.com) plus two methods—Growth Timeline (month-by-month action→metric) and Causal Chain (every step to revenue needs evidence, action before effect, ≥3 peer cases for “it worked”). One-liner for Claude Code / Codex: `curl -fsSL https://raw.githubusercontent.com/fengyiqicoder/BeRich/main/install.sh | bash`. We verified 榜单.csv and data/sites both at 1,169 with 0 missing archives; install.sh symlinked into a temp HOME's .claude/.codex/.agents skills; spot-checked Postiz examples. No live “research this domain” agent session; no 发大财 Pro purchase. (https://github.com/fengyiqicoder/BeRich) - [TokenSave's 288-run study: asking for subagent search left recall almost unchanged and raised the Opus bill by up to 221%](https://ttqq.dev/en/tool/claude-code-subagent-search-cost-288-runs/): Claude Code subagent effort (TokenSave study) — Claude Code 2.1.318 added subagent effort (`CLAUDE_CODE_SUBAGENT_EFFORT`). TokenSave (dataset under johnisking; Japanese write-up by @Yunany90) ran 288 pre-registered headless trials on 12 “find every call site” questions across 6 OSS repos, Haiku 5.5 / Opus 5.5, no-instruction vs forced Explore subagents at low/medium/high. Result: recall stayed ~97–100% (<2 pt gaps); cost rose Haiku +74–116%, Opus +143–221%; with no instruction, 0/72 runs called a subagent. We recomputed the CSV: 288 rows, balanced cells, Opus C2/C0 mean cost ≈3.21× (+221%), C0 subagent_calls sum 0. We did not re-bill a live Claude Code session. (https://github.com/johnisking/token-cost-by-language/tree/main/claude-subagent-effort) - [Niaz's reanimate records the original animation, then your clone, and compares them frame by frame until the timing is within the default ~80ms](https://ttqq.dev/en/tool/reanimate-claude-skill-frame-animation-clone/): reanimate (Claude Code skill) — Ask an agent to copy a smooth site animation and it usually makes one pass, calls it done, and misses timing. Overseas author Niaz Morshed (@niazmorshed_) open-sourced reanimate (MIT, ~1.3k★): a Claude Code skill that records a reference from a live URL, screen recording, mp4/gif/Lottie, rebuilds with whatever CSS / Framer Motion / GSAP / three.js your project already uses, then films the clone the same way and compares frame by frame. Default is motion-faithful (±80ms); ask for pixel-faithful (≤2% mean mismatch). Install: `npx skills add NiazMorshed2007/reanimate -g`. On our Linux box we bun-installed deps, installed Playwright Chromium, and ran capture.ts on a local CSS-animated page: 43 frames, detected CSSAnimation rise (1200ms), 91 track samples; self-compare 0% mismatch PASS. No Claude Code session cloning a real marketing site, no full 2–5 round loop. (https://github.com/NiazMorshed2007/reanimate) - [Connect OpenAI image generation to Grok Bot / Claude / Cursor with @gofelixpy's openai-image MCP: stills and GIFs, about two minutes of pasting config](https://ttqq.dev/en/tool/felixpy-openai-image-mcp/): @felixpy/openai-image (MCP) — ChatGPT Pro/Business users get monthly API credits that cover the Images API. Overseas engineer @gofelixpy open-sourced @felixpy/openai-image (MIT, stdio MCP): tools `openai_image_generate` / `openai_image_edit`, writes absolute-path files, never returns base64; default model gpt-image-2.6-flare, GIF supported. Author says ~2 minutes to attach the MCP to Grok Bot so every agent can use it; sample meme GIF ~$0.06. On the box, npm ci + npm test: smoke 2/2 passed (shebang; after MCP initialize, tools/list exposes exactly generate and edit). No OPENAI_API_KEY set, no real image generated. (https://github.com/felixpy/openai-image) - [@jinchenma_ai open-sources 11 skills for an agent-maintained personal knowledge base: originals protected, sources traceable, Feishu recordings optionally synced](https://ttqq.dev/en/tool/jinchenma-knowledge-base-agent-skills/): jinchenma-knowledge-base (Jinchenma Knowledge Base) — The biggest trap building a knowledge base is copying someone else's heavy stack. Chinese author @jinchenma_ai open-sourced jinchenma-knowledge-base: rules in AGENTS.md, 11 skills (capture, media-ingest, meeting-ingestion, ai-dialogue-ingest, knowledge-analysis, query, enrich, entity-propagation, …) for notes, bookmarks, meetings, full AI chats, candidate insights (human confirm), query and entity links; optional Feishu recording sync and ASR. License CC BY-NC 4.0 (non-commercial). On the box with pytest/PyYAML, `scripts/run_tests.py`: 146 passed + 8 subtests; `check_project.py` reported 11 skills and no broken links; `setup.py --mode create` built a full vault template in a temp dir. No real Feishu account or end-to-end ingest. (https://github.com/jinchenma94/jinchenma-knowledge-base) - [vercel-labs/agent-desktop lets agents read and operate the desktop through the OS accessibility tree instead of screenshot pixels (@SimonObserves' hands-on notes)](https://ttqq.dev/en/tool/vercel-agent-desktop-a11y-computer-use/): agent-desktop (vercel-labs) — Agents usually drive a desktop by staring at screenshot pixels, or by reading the accessibility tree screen readers already use. Vercel Labs' agent-desktop (Apache-2.0, npm 1.2.0) is a model-free CLI/C library: `snapshot` returns JSON with @refs, then `click`/`type`; headless by default so it won't steal focus. Overseas writer @SimonObserves documented a Linux run: almost nothing works without AT-SPI; with it, listing windows and menu clicks work, and terminal typing needs `--headed`. On our headless Linux box after `npm install -g agent-desktop`, `version` was 1.2.0 and `status` reported accessibility=denied (no D-Bus session) with empty supported_surfaces—matching that write-up. We did not wire Claude/Codex MCP to drive a real desktop. (https://github.com/vercel-labs/agent-desktop) - [@GaoXiaoxiao2022 demonstrates the open-source android-ad-cleaner: with a USB cable and AGENTS.md, Codex / Claude turn off Android OEM ad switches over ADB](https://ttqq.dev/en/tool/android-ad-cleaner-ai-adb/): android-ad-cleaner (rddmwmddr/android-ad-cleaner) — Chinese Android skins bury ad, trending-search and feed toggles. Open-source android-ad-cleaner (MIT, ~6.0k★, author rddmwmddr) needs no root or unlock: ADB flips built-in switches, can suspend ad packages (with consent), ships a desktop client and 35+ device recipes. AGENTS.md tells command-capable agents (Codex, Claude Code, WorkBuddy…) the hard rules and standard flow; a separate prompt guides chat-only AIs step by step. @GaoXiaoxiao2022 posted the clone → read AGENTS.md → ask before each change workflow. We read AGENTS.md/README/CHANGELOG and ran device-free unit tests (channel classification, never-suspend, entrypoint refs); this box had no phone or adbutils, so we did not run a recipe on hardware. (https://github.com/rddmwmddr/android-ad-cleaner) - [@komereji12 shares how to batch-process local images in Claude Code with jezweb design-assets' image-processing skill: resize, convert to WebP, trim white edges](https://ttqq.dev/en/tool/jezweb-image-processing-claude-skill/): image-processing (jezweb/claude-skills design-assets) — Xiaohongshu posts and web work often need one width, WebP, and logo whitespace trimmed. Overseas repo jezweb/claude-skills (MIT, ~1.1k★) ships design-assets → image-processing: it doesn't generate images, only processes local files; `bin/img-process` (Pillow) covers resize/convert/trim/thumbnail/optimise/og-card/batch. Chinese poster @komereji12 shared the install lines and natural-language triggers. We cloned the repo and ran img-process with Pillow 13: JPG→WebP ~47KB→5KB; transparent logo trim 400×300→261×201; opaque white-canvas "whitespace" did not shrink—trim needs an alpha channel, not visual white. We did not run `/plugin install` inside a live Claude Code session. (https://github.com/jezweb/claude-skills) - [Writing X Articles in Markdown: @riba2534's Chrome extension and xap bridge turn Markdown into an X Article draft in one click (a Claude Code Skill is included)](https://ttqq.dev/en/tool/markdown-to-x-article-chrome-skill/): Markdown to X Article (riba2534/x-article-post) — X's Article editor doesn't keep pasted Markdown—code, tables and math have to be inserted by hand. Chinese author @riba2534 open-sourced Markdown to X Article (MIT, Chrome MV3): write Markdown in a side panel, then write native X headings/lists/code/tables/LaTeX into a draft; Mermaid is rendered locally and uploaded. It only creates drafts—never publishes. A local xap bridge (127.0.0.1:17345) and Claude Code Skill let an agent preflight and create drafts. Needs Chrome 116+, an X login, and X Premium for Articles. On the box after npm ci, vitest: 368/371 passed, 2 skipped; the "200 KB convert under 300ms" case failed at ~757ms here. We did not load the extension or write a real X draft. (https://github.com/riba2534/x-article-post) - [UI designer @double_asa's open-source DSH to Figma lets AI edit a Figma file from one sentence: DeepSeek Harness changes native layers directly and does not use Figma MCP quota](https://ttqq.dev/en/tool/dsh-to-figma-deepseek-harness-figma-editing/): DSH to Figma(Duoasa/DSH-to-Figma) — UI designer and indie dev asa (@double_asa) built a DeepSeek Harness (DSH) plugin (MIT): a local service talks to a Figma desktop plugin so DSH can read the selected frame and create/edit native layers, components, variables and auto layout—output you can keep editing by hand, not a flat image or code dump. The author's Oct 19 demo: three sentences took a dark UI → a light version on a new frame → a terminal-style version. We cloned v0.3.2, ran its test suite (80 tests: 79 pass, 1 skipped) and verified the release tarball SHA-256; without DSH or Figma desktop we did no end-to-end edit. (https://github.com/Duoasa/DSH-to-Figma) - [@prompt48 cloned the open-source iFixAi to check whether an AI agent oversteps before launch; we reproduced the quick start and also ran all 61 inspections](https://ttqq.dev/en/tool/ifixai-agent-audit-default-vs-full-run/): iFixAi (ifixai-ai/iFixAi) — iFixAi (Apache-2.0, Python, pip package ifixai 4.3.0) drops your agent into a simulated business, sends a real day's requests—including ones that push it to overstep, pay a declined refund or change a payout account—and a judge model grades each reply with evidence. Overseas creator @prompt48 cloned, installed and ran the 10 default inspections on video, warning that the demo agent's grade A is only a smoke test. We reproduced it on the box from the README: default 10 all pass, grade A 100%; adding --full-run for all 61, the same demo agent fails 5 and drops to 90.9%—still grade A. No real agent or real judge was connected. (https://github.com/ifixai-ai/iFixAi) - [The Photo Relic Editorial Codex skill turns one photo into a vertical piece: the photo on top and a paper print below (Paper Beijing series)](https://ttqq.dev/en/tool/photo-relic-editorial-codex-skill-paper-memory/): Photo Relic Editorial(wnby/photo-relic-editorial) — Wu Haoyang (GitHub @wnby) open-sourced a Codex image skill (MIT): give it a photo and Codex calls an image tool to make a vertical piece—the photo on top, a minimal "paper print" distilled from it below (outline, a few deep-blue ink blocks, one warm accent, a tiny title). The repo ships six "Paper Beijing" samples (Temple of Heaven, Corner Tower, Bird's Nest, China Zun, Great Wall, geese). Chinese creator @xunana1017 recommended it on Nov 1. We cloned it, read SKILL.md and the reference prompt, and inspected the six samples; we did not generate new images in Codex. (https://github.com/wnby/photo-relic-editorial) - [@wangzan101's open-source on-device Android Phone Agent, Mika, operates apps on a background virtual screen while you keep using the phone](https://ttqq.dev/en/tool/mika-android-phone-agent/): Mika (wangzan101/Mika) — Wang Zan (@wangzan101) open-sourced Mika (Apache-2.0, thousands of stars at launch, latest Release 0.1.33): a Phone Agent that lives on your Android phone. After one sentence it opens apps, taps, types and scrolls on a separate background screen (WeChat messages, group summaries, Xiaohongshu digests, job-site greets, built-in browser shopping…) while you keep using the main display; logins, OTP and payments are handed to you. No required root, no always-on PC; models use your API key or a ChatGPT / xAI / OpenRouter sign-in—the project says there is no Mika server. App control needs Android 12+ (14+ recommended) and a one-time wireless-debugging pair. We cloned commit ebb0e44, read the EN/ZH READMEs, setup guide and privacy notes, and confirmed Releases ship an APK; we had no Android device, installed no APK, and ran no end-to-end model task. (https://github.com/wangzan101/Mika) - [@I_am_oil_oil's open-source oil-diff turns a Git Diff of dozens of AI-edited files into an HTML report of 3–7 business changes that a non-coder can read](https://ttqq.dev/en/tool/oil-diff-git-change-visual-report/): oil-diff (oil-oil/oil-diff) — oil (@I_am_oil_oil, GitHub oil-oil) open-sourced oil-diff (MIT, 0.1.0), a skill for Claude Code / Codex and similar agents. When an agent touches dozens of files in minutes, raw Git Diff is hard to skim and a free-form HTML write-up from the model often fills with fluff. oil-diff collects the diff with a script, groups it into 3–7 business items, and emits a single-file `.oil-diff/index.html`: a Bento board, before/after diagrams, 🎯 must-read vs 📎 peripheral files, and a side code drawer. Output stays in an untracked `.oil-diff/` folder (built-in `*` gitignore) so the repo status is unchanged. We cloned commit 8f4b40c and ran the author's `python3 -m unittest` suite: 5/5 passed (collect→render→lint, Chinese paths and binaries, blocking scavenged fake screenshots, hype-word lint). We did not have an agent produce a full report on a real product repo. (https://github.com/oil-oil/oil-diff) - [@Fastmax_'s open-source Claude Code papercraft skill skips Meshy / Tripo: it unfolds a box net as UVs, has an image model paint it, and folds it back into a low-poly GLB in Blender](https://ttqq.dev/en/tool/origami-3dfolder-ai-papercraft-glb/): Origami-3Dfolder-ai (lejrimostfa) — Fastmax (X @Fastmax_, repo author alias lejrimostfa) open-sourced Origami-3Dfolder-ai (Apache-2.0): a Claude Code skill plus Python/Blender scripts that turn papercraft-friendly props—crates, tables, windows, stalls, water towers, trees—into textured low-poly GLBs with a Fold animation. Flow: write a spec → `net.py` unfolds a UV dieline → an image model paints the template (~$0.10–0.25, with `--dry-run`) → headless Blender folds → `glb_check.py` gates. Eleven pre-painted examples ship so you can skip the paid paint. We cloned commit 4190681, installed numpy/opencv/Pillow: `net.py`+`template.py draw` produced crate template/mask; 87 author tests passed; `glb_check` on shipped `crate.glb` / `crate_fold.glb` reported ok (41 KB / 60 KB, Fold clip with 15 morphs). No Blender on the box, no paid paint call, no Claude session to invent a new asset. (https://github.com/lejrimostfa/Origami-3Dfolder-ai) - [@kevin327g's open-source Bitwarden MCP login broker lets an agent log in without seeing the password; tested with Claude Code / Codex through GitHub 2FA](https://ttqq.dev/en/tool/agent-login-broker-bitwarden-mcp-agent-login/): agent-login-broker (qulup-app) + Bitwarden Agent Access — kevin mitsunaga of the Japanese band fhána (@kevin327g, building as qulup) uses Bitwarden, envied 1Password for Agents, and noticed Claude Code and Codex couldn't use it yet—so he built agent-login-broker (MIT, 0.1.2), an MCP server that does exactly one job: logging in. The agent just says "log in to app.example.com"; the server fetches one credential through Bitwarden Agent Access (aac) only after you approve, types it into its own headless Chromium (computing a TOTP code if the item has an authenticator key), drops it, and returns only "logged in to …" to the agent. The author says he tested it with Claude Code, Codex and omp, including GitHub switching from the passkey prompt to an authenticator code. We cloned commit e631a7f, installed deps plus Playwright's pinned Chromium, and ran the author's test suite: all 56 tests passed. We did not connect a real Bitwarden vault or log in to any real site. (https://github.com/qulup-app/agent-login-broker) - [@zhengtang364848 tested OpenMausBot, which is widely promoted on X, with DeepSeek and Zhipu GLM: delegation, memory and schedules worked for about ¥3 a round, but the app has to stay running](https://ttqq.dev/en/tool/openmausbot-deepseek-glm-local-bot-team-test/): OpenMausBot (milind-soni) + Claude Code CLI → DeepSeek / 智谱 GLM — OpenMausBot is an open-source, Grok Bot-style local bot-team UI (Apache-2.0): a roster of bots on the left, chat in the middle, and a Chief of Staff that hands work to other bots. Rather than repeat the hype, 秋/十三 (@zhengtang364848) pointed the Claude Code CLI at DeepSeek and Zhipu and tested item by item: three small tasks with one prompt, schedule accuracy and catch-up after downtime, a two-step Chief delegation checked against a known answer, long-term memory after restart—and estimated cost from token counts. Verdict: it's a management layer over the command-line AI already on your machine; quick install, punctual schedules, delegation and memory worked, but it brings no model, must stay running, and every scheduled run is a full conversation. We cloned commit 88d54eb and confirmed two behaviours in source—5-minute minimum interval and catching up only the latest missed run—without installing deps, running it or calling any model. (https://github.com/milind-soni/OpenMausBot) - [@HiTw93's open-source layout skill Kami turns text an AI has written into PDF, PNG or editable PPTX from one sentence, with handling for English, Chinese, Japanese and Korean](https://ttqq.dev/en/tool/kami-agent-document-layout-pdf-pptx/): Kami (tw93/kami) — Tw93 (@HiTw93) packaged agent document-layout rules as Kami (紙, MIT, ~12k★ on GitHub): after install on Claude Code / Codex / Cursor, natural language yields one-pagers, long docs, letters, portfolios, resumes, slides, equity reports, changelogs and landing pages—warm parchment, ink-blue accents, serif fonts—exportable as PDF, PNG and editable PPTX. V1.20.0 (published 2026-10-29) highlights cleaner reports, charts drawn from data and checked before delivery, and Chinese/Korean pages that read well on iPhone. Install with `npx skills add tw93/kami -a claude-code codex cursor -g -y`. We cloned commit e16dd6a, confirmed VERSION=1.20.0, syntax-checked mcp_server.py and related scripts, and inventoried 10 shipped demo PDFs; WeasyPrint was not installed here, so we did not render a new document. (https://github.com/tw93/kami) - [@rehan_shei open-sourced pixelfx and a Claude Code skill: 232 pixel-art effects written entirely in code with no image files, and new effects follow Hugo Duprez's draft → render → look → refine loop](https://ttqq.dev/en/tool/pixelfx-pixel-art-effects-claude-skill/): pixelfx (patch-gg/pixelfx) — Rehan Sheikh (@rehan_shei) open-sourced pixelfx (MIT): 232 pixel-art effects (fire, explosions, ice, lightning, UI, critters…) each a small JS file—play live, recolor, mirror, or export sprite sheets for Godot/Unity. A Claude Code skill follows Hugo Duprez's (@HugoDuprez) public method—code is clay, trust your eyes, feed references—so Opus drafts, renders a contact sheet, looks, and refines. Gallery: patch-gg.github.io/pixelfx. We cloned commit fe7103c, ran `npm install` then `node tools/render.mjs ice/frost-nova --sheet`, and got a 103-frame sheet plus Aseprite-style json; we did not have Claude author a new effect. (https://github.com/patch-gg/pixelfx) - [@elvar_official packed his Claude Opus workflow for turning one reference image into a take-apart 3D machine simulator into the teardown skill, with all 9 prompts public](https://ttqq.dev/en/tool/teardown-claude-skill-machine-3d-simulator/): teardown (elvarofficial/teardown) — Elvar (@elvar_official) turned "any machine with moving parts → an interactive 3D simulator" into a Claude Code skill, teardown (MIT): give Opus one reference image, insist every part is three.js code driven by one math model that also feeds the gauges; cut parts open, press subsystem buttons, auto-tour when idle, and record a 60 fps film with a procedural score. The repo ships three machines (V8, Cessna landing gear, Strandbeest). Install with `npx skills add elvarofficial/teardown -g -a claude-code`, then npm install + Playwright Chromium in the skill folder. His X Article publishes all 9 prompts; demos live at visual-learning.app. On Linux we cloned commit e7e668c, installed deps, and bundled cessna-live.html (~799 KB with three.js inlined); we did not open Claude to invent a new machine or record video. (https://github.com/elvarofficial/teardown) - [An open-source SKILL.md has your agent build a 6-layer firewall against scraping agents: it serves 200 gate pages instead of 403s, verifies Googlebot by IP, then red-teams the setup with sub-agents](https://ttqq.dev/en/tool/block-ai-scrapers-agent-firewall-skill/): block-ai-scrapers skill (Illyism/seo-skills) + Claude Code — Overseas developer @illyism saw people paste his data site into Claude Code and brag about scraping the whole database; when he returned 403s, the agents spoofed Googlebot, probed /api/ and spun up Playwright. He built a 6-layer defense and open-sourced the full SKILL.md: blocked requests get an HTTP 200 "protected dataset" gate page (zero rows + a STOP_SCRAPING directive + a product link), Googlebot is verified by IP/ASN instead of User-Agent, HTML routes require full browser navigation headers plus a JS session proof, and sub-agents red-team it until attackers stop on turn 1. We ran the skill's Googlebot check against Google's IP list published that day and found it both misses real Googlebot ranges and admits unofficial ones. (https://github.com/Illyism/seo-skills/blob/main/seo/block-ai-scrapers/SKILL.md) - [The Douyin "Vibe Knowledge" explainer-short format as an open-source Claude Code skill: give it a topic and it fact-checks, writes, voices, renders frame by frame in code and runs QA; the base tier costs zero credits](https://ttqq.dev/en/tool/vibe-knowledge-claude-code-knowledge-shorts/): vibe-knowledge skill (Claude Code) + 小米 MiMo 配音 + Renoise(可选) — Chinese creator @berryxia turned the viral Douyin #Vibe知识大赏 ("Vibe Knowledge") explainer-short format into an open-source skill, vibe-knowledge: 6 storytelling templates (guess-the-concept, dilemma, everyday-paradox, etc.), 44 visual styles, and every narration line must trace to a source in facts.md. The base tier is pure Claude Opus SVG/code animation at zero credits; the enhanced tier hands realistic shots to Renoise (quote first, then generate). The repo ships 7 sample films. We cloned the 2026-10-28 evening build on Linux: the style recommender works, but workspace setup stopped at the BGM patch added that same day; we rendered and voiced nothing. (https://github.com/andyhuo520/vibe-knowledge) - [Connect the public, key-free "AI video intel radar" MCP to Claude Code / Codex and ask which AI-video formats emerged today, where a trend started, or what a model shipped this week](https://ttqq.dev/en/tool/ai-video-intel-radar-mcp-daily-topics/): AI 情报站 MCP (lab.ytdeepsea.com) + Claude Code / Codex — Chinese creator @GaryAIytb (Gary Cao) runs an AI intel radar that scans public posts on Bilibili, YouTube, Douyin, TikTok, Xiaohongshu, X, GitHub and more every morning to flag AI-video formats that are just taking off. He had Claude build a remote MCP server; one command connects it to Claude Code / Codex, then you ask in Chinese: what's new or heating up today, when did this format start and is it too late, what did Kling ship this week. We called all 7 tools directly over the MCP protocol (no client)—anonymous and returning real data—and ran the open-source version's free collectors locally: 1 min 46 s, zero cost. (https://lab.ytdeepsea.com/radar/agent/) - [After building an 80-second animated short by hand on the Dreamina (Jimeng) canvas, Claude Code scripts the pipeline through the canvas CLI: change only the lead character, bear to penguin, and 14 images, 10 clips and the music re-run automatically](https://ttqq.dev/en/tool/dreamina-canvas-cli-claude-code-swap-protagonist/): Dreamina / 即梦 AI Canvas + dreamina-canvas CLI + Claude Code — Chinese creator @servasyy_ai (huangserva) first built an 80-second animated short by hand on the new Dreamina canvas (a bear dancing in an old-town square): lock the character with a subject + turnaround sheet, cut 4- and 9-panel storyboards into single frames, hang a Seedance 2.5 video node off each frame, then add music on the timeline and export. Then he had Claude Code turn that node graph into a script via the canvas CLI with one parameter—who the lead is—and re-ran it as a penguin; he says it cost 1,750 credits and he clicked no nodes. Note: the post carries a #DreaminaPartner tag (sponsored). On Linux we installed the official dreamina-canvas CLI 1.1.1 (China build) and confirmed the quote → confirm-with-credit-ceiling → run-with-token commands, image upscale and draft-to-final promote exist; we did not log in or generate anything. (https://dreamina.capcut.com/ai-video/ai-canvas) - [video-to-skill turns a YouTube tech talk into an agent skill: every point has an [mm:ss] timestamp and a seen / guessed / unknown evidence label, and the agent loads it when the topic comes up](https://ttqq.dev/en/tool/video-to-skill-talk-to-agent-skill/): video-to-skill (opentoolsorg/video-to-skill) + Claude Code / Codex — video-to-skill by developer @prince_twets (prince): give it a YouTube URL or local video, it gets a transcript via summarize CLI → yt-dlp captions → local Whisper, then the agent writes SKILL.md plus segment notes, a cheatsheet, glossary and timestamp jump list—every claim tagged [mm:ss] and [seen]/[guessed]/[unknown]—and validate.py checks the package. His first real test turned a video on the Vercel CEO's production AI-engineering advice into a published vercel-ceo-skill. We ran the environment check and unit tests, validated his published output (pass, 245 evidence labels), and tried fetching YouTube captions from a server (rate-limited, HTTP 429). (https://github.com/opentoolsorg/video-to-skill) - [Xian (@Xian0063), a UX designer for 10 years, made 18 animated explainer videos with Claude in 4 days, every frame drawn in code; the Van Gogh episode has one visual per line, and the voiceover was checked word by word with Whisper](https://ttqq.dev/en/tool/claude-remotion-van-gogh-explainer-animation/): Claude Code + Remotion (landscape-explainer-video skill) — Xian (@Xian0063, a self-described 10-year UX designer who doesn't code) wrote a long retrospective: 18 animated videos in 4 days with Claude, ~50 renders, including a 3-minute Van Gogh piece made "without downloading a single image or opening an editor"—the paintings are drawn by code with thousands of brush strokes. The post shares a copyable Remotion prompt template, an 8-step method (topic → emotional-arc script → voiceover checked word by word → visuals grown from the subject → one visual per line → frame-grab QA → cover frame at the start → multi-platform export), 6 design rules, and an open-sourced Claude Code skill, landscape-explainer-video. We inspected the skill repo, syntax-checked its scripts, ran its English-subtitle line-count checker, and generated a line of Xiaoxiao +8% voiceover with edge-tts as described; we did not render a video—the skill depends on the author's own Remotion project and won't run standalone. (https://github.com/xianxie6/landscape-explainer-video) - [ffmpeg-skill wraps local FFmpeg as 42 tools, so Claude Code / Codex measure duration, loudness and aspect ratio after an edit and hand in the check results with the video](https://ttqq.dev/en/tool/ffmpeg-skill-agent-video-edit-self-check/): ffmpeg-skill (kajisho5/ffmpeg-skill) — ffmpeg-skill (by kajisho5, MIT, ~3k★ on GitHub), recommended in Chinese by @ZhongRichard, is a local editing skill for Claude Code, Codex and Cursor: silence removal, cut/join, 16:9→9:16, captions/karaoke, loudness normalisation and TikTok / Reels / YouTube / X export templates—42 tools that also run as an MCP server. The point is a fixed loop—probe the footage → edit → check against the platform spec → make a contact sheet for a vision model when the picture changed—so the agent can't just say "done". On Linux we ran probe → silence removal → 9:16 crop → Reels export → check → loudness fix → re-check → contact sheet on synthetic footage straight from the repo; we did not drive it from a live agent session or test transcription. (https://github.com/kajisho5/ffmpeg-skill) - [Designer Ash (@ashdesignin) builds all app micro-animations with Claude Code: a Figma link becomes a SwiftUI first draft, 3–5 rounds of describing the feel refine it, and an iPhone screen recording becomes the promo clip](https://ttqq.dev/en/tool/figma-claude-code-swiftui-micro-animations/): Claude Code + Figma + SwiftUI — Design engineer Ash (@ashdesignin, building Yoomy) shared a ~150-like thread with their full app-animation workflow: designs live in Figma, and Claude Code writes 100% of the animation in SwiftUI. Drop the Figma link into Claude Code to rebuild the UI, give it two states (folded/expanded) to animate between, then the hard part—polishing by describing how the motion should feel (a "black hole" sucking the card in from the bottom, with blur and space distortion); replies say 3–5 rounds is typical. Finally, record on iPhone and turn the recording into a square promo with phone mockup, tap circles and slow push-ins using the open-source telegram-style-video skill. We have no Mac/iPhone and did not reproduce the SwiftUI animations; on Linux we only ran that step-4 recording skill on a synthetic screen recording. (https://x.com/ashdesignin/status/2114356364009259334) - [latent-spaces/brag adds a `/brag` command to Claude Code / Codex: it reads the repo and makes a ~20-second launch video with music and share copy (brag-slim and letsbrag.app are alternatives)](https://ttqq.dev/en/tool/brag-launch-video-skill-hyperframes/): /brag (latent-spaces/brag) — Shunit Haviv Hakimi (GitHub @shunithaviv) ships latent-spaces/brag (MIT, ~18.6k★): an agent skill where you say `let's /brag` in a project, it reads the code for angle and tone, and the classic path hands a brief to Hyperframes. On Opus 5.5 it switches to `/brag-slim` by default (no Hyperframes; the model builds the video with local tools). Output lands in `brag-output/` (plan, share copy, brag.mp4). letsbrag.app can run it from a site URL. @indie_maker_fox summarized install and deps for Chinese readers. We read the README and SKILL.md (v0.5.0); we did not install Hyperframes or render a full video here. (https://github.com/latent-spaces/brag) - [HKUDS's CLI-Anything wraps software such as Blender in command-line tools, so Claude Code / Cursor / OpenClaw can install them from CLI-Hub with one command instead of clicking through screenshots](https://ttqq.dev/en/tool/cli-anything-agent-native-software-clis/): CLI-Anything (HKUDS) — HKUDS open-sourced CLI-Anything (Apache-2.0, ~57k★, clianything.cc): make software agent-ready with stable CLIs instead of screenshot clicking. CLI-Hub (`pip install cli-anything-hub`) browses/installs community harnesses for Blender, GIMP, LibreOffice and more; a generator skill runs a 7-phase HARNESS pipeline when the registry has no match. Works with Claude Code, Cursor, Pi, OpenClaw and peers. @MirrortekUK's Chinese post framed it as dropping pixel-click automation. On our test machine we installed cli-anything-hub in a venv and ran `cli-hub list` / `search blender` / `info blender`; we did not install Blender itself or run a full `/cli-anything` generation pipeline. (https://github.com/HKUDS/CLI-Anything) - [Cathryn's (@cathrynlavery) Diagram Design has Claude Code / Codex / Cursor draw self-contained HTML+SVG architecture diagrams from one sentence, with its visual rules written as hard constraints instead of Mermaid's rounded gray-blue boxes](https://ttqq.dev/en/tool/diagram-design-agent-skill-html-svg/): Diagram Design (cathrynlavery/diagram-design) — Cathryn Lavery (@cathrynlavery) open-sourced Diagram Design (MIT, ~61k★ on GitHub, diagramdesign.dev): a diagram skill for Claude Code, Codex, Cursor, Copilot and peers. The agent picks one of 45 types (architecture, sequence, Sankey, exploded axonometric…), then writes a double-clickable .html. Defaults ban shadows, allow one accent color, and snap geometry to a 4px grid. You can onboard a site URL for palette/fonts, or import draw.io / Mermaid / Excalidraw and export PNG/SVG. Chinese posts by @Zen_with_AI and @dngzsn37461 recently shared the install line and a practical order of use. We cloned the repo, syntax-checked the Python scripts, ran self_check on a shipped example HTML, and extracted a two-node Mermaid digest; we did not open a live Claude Code session to draw a new diagram. (https://github.com/cathrynlavery/diagram-design) - [Underleveled Builder's curated list of short-drama skills: 83 skills checked by hand, plus two published rounds of Opus / GPT blind tests against a no-skill control](https://ttqq.dev/en/tool/awesome-short-drama-skills-blind-evals/): Awesome Short Drama Skills + short-drama-skill-finder — Search GitHub for short-drama skills and you get dozens of repos with no way to tell which ones actually write shootable scripts. Underleveled Builder (@UnderleveledDev) maintains Awesome Short Drama Skills (~752★, CC0): 83 hand-checked short-drama / manju skills plus 16 related open-source platforms, sorted by type, production stage and video model. The list is itself a skill (short-drama-skill-finder)—install it and ask your agent which skill to use for novel-to-drama on Codex. Rarer still: the author published two bake-offs. Round 1 put 10 screenwriting skills plus a no-skill control on the same open brief, three runs each, judged blind by Opus and GPT. Round 2 ranked 11 premise skills the same way. Full logs, outputs and judge fingerprints live in evals/ and on shortdramaskills.com. We only read the README, the evals method and some output folders; we did not re-run the Claude Code harness. (https://github.com/UnderleveledBuilder/awesome-short-drama-skills) - [Hassan's (@nutlope) Hallmark gives Claude Code / Cursor / Codex 48 themes and a browser lint that blocks the default styles that make AI-built sites look the same](https://ttqq.dev/en/tool/hallmark-anti-ai-slop-design-skill/): Hallmark (nutlope/hallmark) — Hassan at Together AI (@nutlope) open-sourced Hallmark (MIT, ~32k★ on GitHub): a design skill for Claude Code, Codex, Cursor and OpenCode. Instead of another "make it look premium" prompt, it deals three themes, builds page anatomy from the visitor's job (book, buy, subscribe…), then runs sloplint in a real browser across eight widths against empty frames, fake buttons, contrast failures, eyebrow + tracked-capital labels, purple-blue gradients and other machine-made tells—Floor gates never ship. v2 adds `/hallmark redesign` (keep content and wiring, change the system) and `/hallmark audit` (report only). His "I'm never reading IKEA instructions again" demo video drove the spike; he says the full launch stays free and open source. We checked the README, SKILL.md, theme folder and sloplint.mjs syntax; we did not run a live `/hallmark` build. (https://github.com/Nutlope/hallmark) - [@rossark0's open-source rossark-motion-skill teaches Claude Code to turn any SVG into 60 fps native animation with follow-through and breathing (React Native / SwiftUI), without Rive](https://ttqq.dev/en/tool/rossark-motion-skill-svg-animation/): rossark-motion-skill — ROSS (@rossark0) packaged the method he used to make his app illustrations feel alive into a Claude Code skill: rossark-motion-skill (MIT, ~454★). The point is not swapping expression drawings—it bans teleports, keeps amplitudes small, rotates parts on real pivots, and adds overlap/follow-through. It ships tiny engines for React Native (Reanimated) and SwiftUI, Python tools that measure sub-visible edge jiggle in a reference video, and offline demo scenes (reveal / garden / chef / orbit). Install with `npx skills@latest add rossark0/rossark-motion-skill` and invoke `/rossark-motion-skill`. A follow-up post shows him vibe-animating characters with the skill plus an internal tool, pluy. We syntax-checked track_edges.py / sample_colors.py and read motion.ts plus SKILL.md; full 60 fps demo renders need macOS 14+, which we did not run. (https://github.com/rossark0/rossark-motion-skill) - [JJ Englert had Claude Code build a "Search Radar" mod that counts empty searches and unneeded file reads in each answer and writes a shortcut doc in one click](https://ttqq.dev/en/tool/claude-code-search-radar-mod/): Claude Code Mods (function hooks) — On 2026-10-19 JJ Englert (@JJEnglert) pointed out that every time Claude Code looks for something in your project it reads files, searches and runs bash; some lookups come back empty and some read files it never needed, which is time and tokens you never see. With one prompt he had Claude build a mod (Claude Code's early-access function-hooks extensions, which can add UI above the prompt) called Search Radar: it scores the wasted lookups for each question and, when a search was wasteful, offers a button that has Claude write a shortcut note into your docs so the next agent goes straight there. He tried it with two questions on his own repo; the second showed his folder layout needed work. We haven't run it, and his public claude-mods repo doesn't contain Search Radar yet, so for now you generate it from his prompt. (https://github.com/JJenglert1/claude-mods) - [There is no Doubao IME on Linux, so Jackson wired Doubao's streaming speech recognition into Omarchy: hold F9 and speak, live text shows at the bottom of the screen, and about a second after release it lands at the cursor; Claude Code can install it from AGENTS.md](https://ttqq.dev/en/tool/omarchy-doubao-voice-dictation-linux/): 豆包流式语音识别(火山引擎)+ omarchy-doubao — Developer Jackson (@Jacksonlin945) uses DHH's Omarchy (Arch + Hyprland) as his daily desktop, but ByteDance's Doubao input method, which many Chinese users consider the best Chinese dictation, has no Linux build. Instead of the IME he calls Volcengine's public Doubao streaming ASR API from a small resident Python service, doubao-dictate: hold F9 and audio streams while you talk, a floating bar shows live captions, and on release the server does a second, non-streaming pass and the text is pasted at the cursor. v0.2 is open source (MIT), and the README and AGENTS.md describe letting Claude Code or Codex do the install. He reports that for a 17-second sentence the wait after release dropped from 2.5s+ in v0.1 to 0.7–1s. We don't have an Omarchy machine or Volcengine credentials, so we only read the code and syntax-checked it. (https://github.com/jacksonlin-infra/omarchy-doubao) - [The reel-live-edit Claude Code skill lets you edit by talking: say "put the ChatGPT logo on my right hand" on camera, and the effect appears at the moment you say it](https://ttqq.dev/en/tool/reel-live-edit-claude-code-talking-head/): reel-live-edit skill (Claude Code + ffmpeg + Chrome, runs locally) — Developer vladasanadev recorded a roughly 35-second talking-head take whose script is itself a list of edit commands (logos on hands, float away, subtitles, a movie clip, background swap, a clone). Their free Claude Code skill, reel-live-edit, transcribes word timings, finds jump cuts, tracks palms and cuts the speaker out of the background, then draws graphics and synthesizes sound in code, placing each effect on the moment the command is spoken. All footage is real, not AI-generated. The author also gave the same take to GPT and stacked both edits into a 9:16 head-to-head. We have not downloaded the skill or run it. (https://vladasana.com/blog/edit-with-vlada-ai) - [The open-source WeChatBridge sends selected WeChat group chats straight to Codex, Claude, Doubao or Obsidian, with a saved instruction for each group, so you no longer scroll back through history](https://ttqq.dev/en/tool/wechatbridge-wechat-chats-to-agents/): 微信流 WeChatBridge(macOS / Windows 测试版)+ Codex / Claude / 豆包 / Obsidian — Since WeChat 4.1.13 you can multi-select messages, choose Merge Forward and then "Forward to other apps", which exports a ZIP with a TXT transcript, images and video. WeChatBridge, an open-source tool by Chinese developer Canghe (@canghe) and core contributor Xiangming (@woniu20758393), adds 12 entries to that system share menu: send to Codex, Claude, Doubao, Qwen Office, WorkBuddy and others, or save as an Obsidian note. Each group chat can be bound to a "scene" (a saved instruction prompt) and skills, and more than 100 messages can be collected in batches and sent once. It does not read WeChat's database or inject into the process. We have no Mac or Windows test machine and did not run it; we only read the permission settings in the source. (https://github.com/freestylefly/WeChatBridge) - [Making a 41-second car ad in one afternoon with the open-source Ad Storyboarder: Opus 5.5 in Claude Code directs, Higgsfield makes the images and video, and a read-only inspector looks for faults](https://ttqq.dev/en/tool/ad-storyboarder-opus-higgsfield-ad/): 广告分镜师 Ad Storyboarder (Claude Code + Opus 5.5 + Higgsfield CLI) — Chinese creator Feicai (@zhu185178) made a 41-second self-initiated concept ad for the new Tesla Roadster. He wrote the creative script, answered a few questions, said once that "the car looks fake", and reviewed the cut; Opus 5.5 in Claude Code did the rest, generating art assets and 34 video clips through the Higgsfield CLI, using about 1,750 credits across two cuts. He released the workflow as an MIT-licensed .claude folder with six skills, a read-only inspector agent, measure-only check tools and a frame-by-frame review Studio. We did not run Higgsfield generation; we ran the free self-check, contact-sheet, loudness and delivery-gate tools on our test machine. (https://github.com/feicaiclub/ad-storyboarder) - [Anthropic engineer Felix Rieseberg's four questions make the AI go deeper on a task instead of bigger; a developer packaged the prompt as a /better skill](https://ttqq.dev/en/tool/better-skill-deeper-task-prompt/): /better skill (Claude Code / Codex, any chat model) — On 2026-10-13 Felix Rieseberg, an engineering lead on Claude, published a tutorial on being more ambitious with AI. Its "Depth" section includes a prompt he often uses: before rewriting a task, say what a top professional would add, which rawest material they'd start from, which methods and tools they'd use, and what other than you or me would show the result is right. Developer Josh (@jjpcodes) packaged it as a /better skill for Claude Code and Codex, ran it with Opus 5.5 on a home Plex security check, and said the result was much more precise and holistic than his own prompting. He also warns that models drift into "proof porn": piling up checks without testing the real result. We have not tested it yet. (https://gist.github.com/joshp123/a1443d30fa1b7c577e74882895cea61b) - [alswl's 1+N multi-agent practice: one captain agent dispatches the rest, rehearses the flow in a logbook, sets Delivery and Verify roles against each other, and deliberately breaks code to test the tests](https://ttqq.dev/en/tool/captain-logbook-multi-agent-test-the-tests/): Coding agents + lbkit (logbook) + Herdr + chatta — On 2026-10-19 Chinese engineer alswl (@alswl) wrote up how he is moving "toward Stage 8": instead of watching each agent window, he hands a whole task to one coordinator (the Captain), which starts executor agents as needed. A logbook spells out goals, constraints and deliverables, and a Preflight rehearses the whole route before work starts; Delivery and Verify roles are set against each other; and after tests pass he deliberately breaks the tested feature to confirm the tests fail. His tools lbkit, chatta and skm are open source. He reports the captain's typical continuous run at about 30–50 minutes, up to nearly two hours. We haven't run the workflow yet. (https://github.com/alswl/lbkit) - [Moving a whole HubSpot blog to WordPress with Claude Code: MCP on both sides, the owner went to meetings, it worked on its own for 6 hours and emailed a report when done](https://ttqq.dev/en/tool/hubspot-to-wordpress-claude-code-mcp-migration/): Claude Code + HubSpot MCP + WordPress.com MCP — Wil Reynolds of Seer Interactive used Claude Code to move his company's entire HubSpot blog to WordPress. He had AI pick the blog host with the most complete MCP, ran deep research on both platforms' docs during his morning run, spent an hour-plus setting up permissions, plugins and Python, then told Claude Code he'd be away from 9:30 to 4 and it had to work alone. Around 3 pm a completion email landed in his drafts; people shown the staging site couldn't tell old from new. We have not tested this. (https://developer.wordpress.com/docs/mcp/) - [Making a full WeChat sticker album that passed review with the open-source weixin-sticker skill: Codex handles generation, slicing, banner/cover/icon, checks and packaging](https://ttqq.dev/en/tool/wechat-sticker-album-skill/): weixin-sticker Skill (Codex / WorkBuddy + image generation) — Chinese creator @ZhangZhangWanAI got several AI-made sticker albums approved and listed on WeChat's sticker platform. He found that "generate 16 cute stickers" is only the start; the real time sink is the submission package: 240×240 transparent singles, a banner, cover, chat icon and tipping images, then checking sizes and counts. He turned the process into an MIT-licensed skill that Codex, WorkBuddy and other agents with image generation can run. We ran its processing, validation and packaging scripts on our test machine. (https://github.com/zxd-666/weixin-sticker) - [Three hooks, a project wiki and gates keep Claude Code from forgetting after compaction and make it prove "done" (the author's hooks are public)](https://ttqq.dev/en/tool/claude-code-hooks-wiki-memory-done-gates/): Claude Code hooks (SessionStart / UserPromptSubmit / Stop) + project wiki — Polish front-end developer Mateusz Muszarski built his portfolio site with Claude Code in about two weeks and wrote up the setup: CLAUDE.md is a 76-line router into a 33-page project wiki; a SessionStart hook re-injects the working agreement, git state and lessons on every new session and after every compaction; a UserPromptSubmit hook scores each prompt and attaches up to 5 matching wiki pages; a Stop hook blocks once when code changed but the wiki didn't. Every correction becomes a one-line rule, a rule that slips back becomes a test, and "done" is a list of commands and screenshots that must pass. His hook scripts are public on GitHub, and we ran them on our test machine. (https://github.com/MuchaSsak/muszarski.com/tree/main/.claude/hooks) - [Three ways to turn a reference clip into a video prompt, tested on the same clip: sending the whole video to Gemini 3.8 Flash and then re-checking key moves was the most accurate (open-source ai-video-prompt)](https://ttqq.dev/en/tool/video-reverse-prompt-gemini-native-video/): ai-video-prompt (Gemini 3.8 Flash via OpenRouter + DeepSeek) — Wonfull compared three ways to reverse-engineer a prompt from the same 15-second anime clip: feed screenshots one by one, feed the whole video once, or feed the whole video and then re-check the key moves. Only the third got both shots and every key action right. He packaged it as the open-source skill ai-video-prompt: in Cursor or Codex, say "video-to-prompt + path"; Gemini 3.8 Flash (via OpenRouter) watches the video, DeepSeek fact-checks and translates, and you get a bilingual Chinese/English prompt.md. We ran the pipeline's evidence step, which calls no model, on our test machine. (https://github.com/wonfull888/ai-video-prompt) - [Turning The Little Prince into an explorable 3D game with Opus 5.5, Tripo, Blender and Unity: AI makes the assets and also drives the engines](https://ttqq.dev/en/tool/opus-tripo-blender-unity-3d-game/): Claude Opus 5.5 + Tripo + Blender + Unity — Sac spent 16 days turning The Little Prince's journey between planets into a 3D story game you can play in the browser, then published the workflow: Fable 5.1 writes the PRD, GPT Image 2.5 makes scene and character references, Tripo generates 3D assets, Opus 5.5 builds scenes, rigs characters and wires animations through the Blender CLI and the official Unity MCP, and Astra fixes bugs. Reusable prompts are included for each step. (https://studio.tripo3d.ai/) - [Keeping secrets out of the AI chat when driving a coding agent from your phone: Simon Willison had Codex build web-edit and edits those files himself over Tailscale](https://ttqq.dev/en/tool/web-edit-secrets-off-llm-tailscale/): web-edit (built with Codex) + Tailscale — While working from his phone with Codex Remote, Simon Willison needed to edit a credentials file without round-tripping the credentials through the LLM. He had Codex (GPT-6 Astra Extra High) build web-edit, a small Python web app: the agent starts it on the machine and he edits files himself from his phone over Tailscale. He later added copy-to-clipboard to move logs from remote runs into a Gist. We ran version 0.1a2 on our test machine. (https://github.com/simonw/web-edit) - [Turn 1,270 of your own coding-agent sessions into a private eval set and find a setup at half the cost](https://ttqq.dev/en/tool/agent-sessions-to-personal-evals/): evals-from-sessions (Claude Code / Codex / Pi skill) + Harbor — Ibragim, who maintains SWE-rebench, had an agent read three months of his Claude Code / Codex / Pi sessions, picked episodes where the agent failed and he corrected it, turned them into 10 Harbor tasks with automated checks, and ran different models and harnesses. On his tasks, Pi + GPT-6.1 Sol solved everything at about half Codex's cost per task with the same model. (https://github.com/ibragim-bad/evals-from-sessions) - [The split of work after ~500 generations: Doubao Work plans the shots, ChatGPT draws first frames, Meta Muse renders each 10-second shot, and they are joined into a 3-minute film](https://ttqq.dev/en/tool/muse-doubao-work-chatgpt-long-video/): Meta Muse + 豆包 Work + ChatGPT — Jarvis ran 488 Meta Muse video generations and concluded that unstable long videos usually come from unsettled prompts and first frames. His final split: Doubao Work researches viral videos on the theme plus Seedance's prompting tips and writes a 10-seconds-per-shot plan, ChatGPT draws a first frame per shot, and Muse renders each clip from its frame and stitches them. (https://muse.ai) - [A 7-minute hand-drawn watercolor animation made without drawing skills: GPT writes the script, Claude builds it with a skill, and Doubao TTS does the voice](https://ttqq.dev/en/tool/storybook-animation-opus-doubao-tts/): Claude (Opus 5.5) + 豆包语音 — Hailey polishes a script and storyboard with GPT in three rounds, has Opus 5.5 build a self-drawing watercolor animation in the browser using her open-source hand-drawn-storybook-animation skill, then adds narration and character voices with Volcengine's Doubao TTS and synced bilingual subtitles. She says it took one day. (https://github.com/lhlGitHub/hand-drawn-storybook-animation-skill) - [Three prompts to have Claude Code build a LaTeX tool that lives entirely in the URL #fragment](https://ttqq.dev/en/tool/claude-code-url-fragment-latex-tool/): Claude Code — Inspired by Tiny Little Office, Simon Willison used three Claude Code prompts to build a single-page LaTeX renderer whose (optionally compressed) content lives in the URL #fragment, so the link is the document; follow-ups added an iframe sandbox against XSS and URL/Gist loading. (https://tools.simonwillison.net/latex) - [Shipping an app without coding: Claude designs and reviews, a cheaper model writes the code in OpenCode, and scripts gate the tests](https://ttqq.dev/en/tool/claude-opencode-dev-workflow/): Claude Code + OpenCode (claude-dev-workflow) — Chinese builder @niukutzu open-sourced the workflow behind an Android app (~70 task packages, shipped): Claude only designs, splits tasks and reviews; ChatGPT/DeepSeek inside OpenCode write the code; Bash scripts gate on real exit codes and bounce failures back for fixes. (https://github.com/niukutzu/claude-dev-workflow) - [Enforce agent conventions with a pre-commit hook that fails the commit and tells the agent how to fix it, instead of endlessly editing AGENTS.md](https://ttqq.dev/en/tool/pre-commit-hook-agent-guardrail/): Git pre-commit hook + any coding agent — Geoffrey Huntley (of Ralph loop fame): when the agent skips your diagnostics library, don't edit AGENTS.md — add a pre-commit hook that scans the diff, fails the commit on bypasses, and prints a fix instruction for the agent. He says it then goes "ten out of ten". (https://ghuntley.com/agency/) - [Export a Claude Code session with /export for the next agent or a custom skill](https://ttqq.dev/en/tool/claude-code-export-session/): Claude Code — Claude Code's built-in /export saves the current conversation as readable plain text (optional filename). @dani_avila7 highlights two uses: hand the transcript to another agent, or mine it to author better custom skills. (https://code.claude.com/docs/en/sessions) - [A design-discussion prompt that makes coding agents reason before they write code](https://ttqq.dev/en/tool/design-reasoning-prompt-before-code/): Claude Code / Codex — Vinh Nguyen, who builds the open-source Rust coding agent VT Code, shared the prompt he uses for design discussions: review the codebase, challenge assumptions, compare options, then recommend the simplest practical approach. (https://claude.com/product/claude-code) - [Make an LLM output a real Excel file with a Dify workflow (open-source DSL from China's 嗯哌AI)](https://ttqq.dev/en/tool/dify-llm-to-excel-workflow/): Dify + Flask — Chinese creator 嗯哌AI (Banny) open-sourced 30+ Dify workflows (≈2.7k GitHub stars). Excel_Flask_Dify pairs Dify with a tiny Flask service that turns model-generated fields and rows into an .xlsx file. (https://github.com/BannyLon/DifyAIA) - [Matt Pocock's /grill-me skill: the AI questions you about the plan before it writes code](https://ttqq.dev/en/tool/grill-me-plan-interview/): Claude Code / Codex + mattpocock/skills — Most bad agent output starts with a misread request. /grill-me makes the agent interview you round by round over a decision tree, with a recommended answer for each question, before any work starts. (https://github.com/mattpocock/skills) - [Cursor engineer poteto's pstack: /poteto-mode makes the agent verify before it edits code](https://ttqq.dev/en/tool/pstack-poteto-mode/): Cursor + pstack (poteto) — Lauren Tan (@poteto, Cursor / React Compiler) open-sourced pstack — the skills she uses daily. Entry point /poteto-mode matches one of 23 playbooks, routes supporting skills, and prioritizes less code, runtime proof, and safe parallelism. (https://github.com/cursor/plugins/tree/main/pstack) - [Running Xiaohongshu (RED) writing, layout, posting and replies as a pipeline with OpenClaw and an open-source skill](https://ttqq.dev/en/tool/xiaohongshu-ops-openclaw/): OpenClaw + xiaohongshu-ops-skill — A Chinese open-source skill (Xiangyu-CAS/xiaohongshu-ops-skill, ~2.4k stars) wires topic research, analysis, publishing, comment replies and viral-post remix into OpenClaw. Creator 程序员小饭 documented a 14-day, three-account ops rhythm and the pitfalls. (https://github.com/Xiangyu-CAS/xiaohongshu-ops-skill)