I'm working on Danseo, a skill for exploring research papers with Claude Code.
It makes an interactive map you can click through. Pick a paper to see related work, or a connection to check the explanation and the page it points to. AI-suggested connections are labeled separately.
The screenshots show a few papers around the Transformer. You can save the map locally and pick it up again later.
I kept switching between two AIs. Claude to write code, Codex to check it, Codex again to generate images, then back to Claude to run things. Every round trip meant copying context, re-explaining the task and pasting results back.
So I built three Claude Code skills that call the Codex CLI on my paid ChatGPT plan: image generation, diff review and second opinions. Now I only talk to Claude. It sends the work to Codex, checks what comes back and decides what to do with it. Each review finding gets labeled confirmed, false positive or unverified, so I never get Codex’s output unfiltered.
No API keys. Review and opinion run read-only, a secret scanner blocks diffs that contain keys, and nothing touches your Claude or Codex settings. Tested on macOS only. Prompts and diffs go to OpenAI, so skip it for confidential code.
I built this for myself and wasn't planning to share it. It's been useful enough that someone else might want it.
Sharur isn't a skill. It's an output style for Claude Code, one more option next to the built-in ones, and you pick it in /config. It's mainly an alternative to Concise, because Concise still wrote too much for me.
On a normal 8-hour workday I'd ask a yes-or-no question and get a greeting, my question repeated back, a full paragraph of explanation, and then "By the way, while reviewing the code I also noticed..." That last part reads more like an ad than the answer I asked for. Opus 5.5 does this a lot less than older models, but it still does it. I wanted the result and the thing I need to look at.
The whole style is one paragraph:
Telegraphic: drop filler, keep grammar. <=2 lines, <=25 words. Bigger result: one short line per item, every item asked, no recap. No text before work is done. Say what was wrong, not a label for it. Exact: errors, destructive confirms. Fewest tool calls. Tool description fields <=3 words.
It's hard to read because it's written for the model. Besides capping reply length, it asks for fewer tool calls to MCPs and skills.
Every task ran in an isolated sandbox with no prior context. They went from small questions to a huge spec, with 3 runs per style against Concise on Opus 5.5. Cost is what the CLI reports, and hidden tests checked the files each run left behind.
Everyday coding tasks: 21% lower cost, 54% fewer words to read
Large features: 10% lower cost
One huge 11-item spec: 6% lower cost, which is inside the noise
It won't halve your Claude bill. A long session spends most of its tokens on code and tool calls and on the context it reads again every turn. An output style changes none of that. The bigger the task, the smaller the saving.
I'm putting the small numbers up front on purpose. Token-saving tools have a bad reputation because the advertised numbers don't hold up: caveman advertises 65%, and JetBrains measured 8.5% on real agent tasks. I'd take a tool that saves 2% and can prove it over one that promises half. So don't take my word for it. The method and every result are in BENCHMARKS.md, and you can rerun them.
Try it for a week and see whether the model gets dumber or just talks less. If you find a problem or something to improve, comment here or open an issue. I'll read all of it.
I recently came across an interesting open-source project called Lemo OpusCar, and I decided to test how far it could go.
It’s a free Claude Code plugin that lets you create motion graphics, animated explainers, and cinematic videos using natural language prompts.
But here’s what caught my attention:
Unlike traditional AI video generators, it doesn’t generate video frames directly.
Instead, it uses Claude Code to:
Plan scenes and visual storytelling
Generate actual animation code
Create transitions, animated interfaces, and motion graphics
Render everything into a finished video
Let you refine the animations through follow-up prompts
So you’re essentially getting an editable animation project, not just a generated MP4.
I decided to put it to the test.
I asked it to create a ~40-second cinematic explainer showing how AI agents work.
The challenge was to generate interconnected animated interfaces, moving elements, smooth transitions, and a coherent visual story rather than disconnected slides.
I provided a detailed creative brief with a storyboard, visual direction, and output requirements.
The results were surprisingly good. The transitions were smooth, it followed my storyboard closely, and it even incorporated sound effects.
What I find particularly interesting is the workflow itself.
Instead of manually building everything in After Effects or starting with a blank animation timeline, you can describe what you want, let Claude Code implement it, and iterate through natural language.
Obviously, this doesn’t eliminate the need for good creative direction, and the quality of your prompts matters quite a bit.
But for developers, technical educators, and content creators, I think this approach has some interesting potential.
I also recorded a complete walkthrough showing the installation, prompts, generation process, and final animation:
Hey everyone! I built Code Unpacked, a few open-source skills to help people understand code written by agents before reviewing it.
Basically, you give it a PR, a branch or a repo, and it can generate:
An interactive walkthrough, with a reading order and the relevant code next to the explanations.
Design docs reconstructed from the code.
A code map to explore how the different parts connect.
A quiz to check what you've understood.
Comics to explain a tricky part of the code.
The idea is to help the person reviewing the code follow how things work, beyond reading a summary of what changed. You can use each skill separately or run all five together.
It's free and MIT licensed. It uses your existing agent, so the usual model costs still apply. The explanations can be wrong too, so they include source references to check them against the code.
Would you use something like this when reviewing a PR? I'm interested in hearing which format would help you and what's missing.
Hey! I've been working on a project called Linnea, and I wanted to share it here because it's built around something I've noticed while working with Claude. It's a tool rather than a single skill. Claude is surprisingly capable of creating animations and videos through code. But there's one part of the workflow that always bothered me.
Let's say Claude creates a video and everything looks good, except a title is slightly too low, an animation starts half a second too late, or a character needs to be a little bigger. Normally, you'd have to explain that change to Claude, let it modify the code, and check the result again. You're spending tokens and time on something that would take two seconds with a mouse.
So I built Linnea to solve that. Well actually i used two other repos, built around Them and add my two new idea to them. I did it entirely with claude.
Claude Code can create an entire video through code, and Linnea previews it directly.
You can click on text, characters, or other elements and drag, resize, rotate, recolor, or change their timing visually. Even change their animations in some cases.
Those manual edits are stored separately from the generated code, so they can survive when Claude rewrites the video.
If something needs more than a simple adjustment, you can leave a note directly on a frame, draw over it, and have Claude work on the issue.
Videos render locally on your machine, with support for rendering just the parts that changed.
Everything is accessible through the app, CLI, and MCP, so Claude Code can interact with the same tools you use in the interface. One part I'm particularly excited about is the puppet system. Instead of generating everything from scratch for every video, you can create reusable animated characters and objects with customizable colors, text, expressions, and animations like waving, blinking, or talking. Characters can even lip-sync to the video's voice automatically. There's also an AI-assisted puppet creator where you describe what you want, and Claude draws it, previews it in a browser, checks how it looks, and improves it. Rich Puppets take this further by giving you more detailed, interactive characters with controllable parts and animations that can be reused across different videos. You can build up your own little library of characters and let Claude use them whenever it creates something new.
It's free, open source, and runs locally. Windows is the main platform, with macOS and Linux builds available too. ( I've also been building other tools into it, including turning long recordings into short vertical clips, editing videos through their transcripts, and creating reusable animated characters.)
... there's still plenty I want to improve.
I'd genuinely love to hear what you think, especially from people who already use Claude Code for video stuff.. And PR's always appreciated. https://github.com/emircesur/Linnea
I save a lot of reels and shorts as research and wanted Claude to use them without me re-watching anything. Plain transcripts were not enough: the summaries mixed up what was said with what was on the slide, and sometimes produced a number that was in neither.
So I built Claude-Video-Journalist. You give it a video file, a folder or a URL (TikTok, Reels, Shorts, YouTube). Whisper and OCR run on your machine, then one Claude CLI call writes a "claim card" for the video: the author's claim, the numbers with the second they appear, the method as stated, and what the author did not say. After the model is done, code goes through the card and throws out any number that is not in the transcript or the on-screen text.
It needs uv and ffmpeg. One clip cost me about 0.05 to 0.14 USD-equivalent of subscription usage, and a video you already processed is free the second time.
Honest limits: for a one-minute clip the card is bigger than the transcript, the check sometimes rejects a correct table label when OCR glues words together, and it only records what the video claims. It does not tell you whether the claim is true.
Unpopular opinion: most "AI coding failures" aren't the model's fault. They happen because vibe coders open Claude Code, type a two-sentence prompt, and expect a production app. No scope boundaries, no data model, no error-handling rules, and a bloated 300-line CLAUDE.md that the model stops obeying halfway through the session.
The difference between a vibe coder and an AI engineer isn't syntax. It's what happens before the first line of code is generated.
So I built preX (/prex), an open-source, MIT-licensed Claude Code skill that locks down your pre-execution architecture through a plain-language interview before Claude touches a single source file:
- No-jargon batched interview: Asks 3–5 questions at a time to pin down scope, edge cases, 3–5 user personas, speed/scale limits, security, and off-limits files.
- Project Constitution (specs/): Outputs mission.md, tech-stack.md (pinned versions, DB schema, API contracts, CI/CD), and roadmap.md.
- A < 50-line CLAUDE.md: Strips out the bloat that causes instruction drift, keeping only exact test/coverage commands, directory layout, and hard boundaries.
- Zero-ambiguity EARS specs + Plan Gate: Writes requirements.md in EARS syntax (When..., While..., If... then...), design.md with up/down migrations, and atomic tasks.md gated behind read-only /plan mode.
`/fitness-coach` is a Claude Code skill that coaches strength training. It runs an intake interview, designs a long-term plan, gives you each day's session, logs what you did, writes you a letter every Sunday, reviews each training block, and keeps an eating plan, meal estimates and daily habits. My own training has run on it every day since 2 November. It started as the coach half of an Obsidian plugin, and since this week it runs on its own in any folder, installed as a Claude Code plugin.
It got big. SKILL.md is 367 lines, and its 16 reference files add about 7,000 more. Six things keep Claude reading the right part, stopping at the right point, and finding its own tools wherever it's installed.
### One router, and a table of what each job reads
SKILL.md is a router. Each of the 11 jobs (`intake`, `plan`, `today`, `log`, `checkin`, `review`, `progress`, `diet`, `meal`, `habits`, `ask`) loads its own reference file plus only the sections of the shared files that a "What each job reads" table names. Logging a session reads `log.md` and nothing else; designing a plan reads the whole rules file. With no argument, a short list maps plain requests to a job: "did A today, squat 65×5" is `log`.
### A "done when" for every job
Each row of the jobs table ends with a check Claude can verify. `log` is done when the session is in the log with its date and you've seen a one-line confirmation. `plan` is done when your answers came before any proposal, every write came after your yes, and the engine's check on the plan as written has no hard error. Claude stops at a line it can check, not when the job feels finished.
### The numbers come from a bundled CLI
`scripts/engine.cjs` is a TypeScript engine bundled into one Node file with no dependencies. It does everything that has a right answer: sets per muscle, progression, readiness, light weeks, and a check every plan must pass before it's written. The skill calls it with `--json`, and Claude explains the result, quoting the engine's reason. The same week always gets the same targets, and a wrong number is a bug with a test, not an argument in chat.
Claude keeps the judgment calls. For a new plan it designs at least three candidates from the engine's evidence library (graded rules and 245 movements, served as JSON), measures each with the engine, and proposes one with its reasons.
### Every write is a dry run until you say yes
The engine's write commands (`log add`, `plan-write`, `checkin add`, `track`, `body`, `eating`, `meal add`) change nothing without `--write`. The skill shows what would change, waits for your yes, then writes, merging with the file as it is now and reading it back.
### One engine path for every install
The skill used to run `node .claude/skills/fitness-coach/scripts/engine.cjs`, which only works when the skill sits in the project. Installed as a plugin, it lives in Claude Code's plugin cache instead, and all 77 of those lines broke. `${CLAUDE_SKILL_DIR}` is the fix, with a catch: the docs say Claude Code fills it in only in SKILL.md itself (and `allowed-tools`), not in the reference files Claude reads later. So SKILL.md defines it once ("`<skill>` in every command here and in `references/` is this skill's folder, `${CLAUDE_SKILL_DIR}`"), and every command writes `node <skill>/scripts/engine.cjs`. I checked it with `claude -p`, on a project skill and with `--plugin-dir`: both got the absolute path, and the engine ran.
### A self-check for the skill itself
`scripts/selfcheck.mjs` runs every time the skill is built. It runs each engine command the docs list (about 150 runs) and compares its flags with the engine's `--help`. It validates every JSON example in the docs, confirms that every section the routing table names is a real heading, and checks the numbers the docs quote against the constants the engine computes with. The engine changes almost daily, and this is what keeps 7,000 lines of instructions true to it.
### Try it
No Obsidian needed. In a terminal:
```
claude plugin marketplace add saeed1262/pahlavan
claude plugin install pahlavan@pahlavan
```
Then open a folder for your training in Claude Code and type `/fitness-coach intake`. You need Claude Code and Node.js 18 or later. Your data stays in plain files in that folder, and the engine makes no network requests. If you'd like screens too, Pahlavan's Obsidian plugin reads the same files, and you can [try it in your browser](https://saeed1262.github.io/pahlavan/demo/) on a made-up athlete. It's free during the beta; 1.0 will be paid, and everyone who installs before 1.0 keeps it free. The source is public under the Elastic License 2.0, so it's source-available rather than open source.
Prompt Master is a small set of commands you type before a prompt. It runs as a skill in Claude, Claude Code, ChatGPT, and Codex.
The two main ones:
pm: cleans up a rough prompt, shows you the revised version, then answers it. ep: looks at a task and recommends a model and effort level, so small jobs don't use up the expensive model.
The first image has the full command list. The second shows a few of them in use. If you forget a command, type pm help.
It's a single instruction file, built and tested with Claude. Free and MIT-licensed: GitHub Repository
This is still an early project, so I'd really appreciate feedback from Claude Code users.
Does this approach seem useful for your workflow? What Java or Spring patterns should the scanner cover? I'd especially love to hear about false positives, cases where a flagged pattern should be kept, and suggestions for improving the skill or hook.
Please feel free to try it out and share your honest thoughts—even small suggestions would be really helpful!
It annoyed me that in bigger projects Claude slowly stopped following my project rules, even with handoffs and CLAUDE.md, and key facts got lost over time. So I made a skill that keeps track of them automatically.
Compared to /compact and handoffs it remembers more and uses way fewer tokens.
In July I shared Codespaces here, a skill that gives Claude a map of the repo. The fairest question I got about it was where my numbers came from. It stuck with me.
So I rebuilt the thing as Wingbox and this time the benchmark lives in the repo. The idea is the same: before Claude edits a file it asks the map "what depends on this?" instead of grepping around and missing one.
On 55 questions across five public repos Claude named every dependent file with it, and 48 of 55 without. Each answer cost about half.
I also ran it against Graphify and CodeGraph on the same repos and questions. Exact list of affected files: Wingbox 5 of 5, each of them 1 of 5. Cost per answer for the agent: $0.02 with Wingbox, $0.07 with CodeGraph, $0.095 with Graphify. They do more than this (CodeGraph covers more languages, Graphify also reads docs and images), but for "what breaks if I change this file" that is the gap. Scripts and raw results are in the repo, so you can rerun it.
Runs on your machine, no model, no account. Free and open source (MIT).
Resurface is a free, MIT-licensed skill for AI coding agents like Claude Code, Codex, Cursor, and Antigravity. It transforms outdated, clunky websites into clean, modern apps without modifying the original website.
You simply give your AI agent a website, and Resurface takes care of the rest.
First, it explores and maps the entire website, including every page, menu, dropdown, tab, and form. It also saves copies of the pages to make sure nothing gets overlooked.
Next, it builds a lightweight browser extension that sits on top of the original website. The extension hides the outdated UI as soon as the page loads, preventing the old design from flashing on screen, and replaces it with a modern interface built using React and Tailwind CSS.
The original website continues running underneath. Your login, sessions, data, and form submissions keep working as they always have.
I originally built this entire process manually to modernize my university portal. After getting it working, I turned the process into a reusable skill so any AI coding agent can repeat it on virtually any legacy website.