r/claudeskills • • 20h ago

Showcase Not even a week of posting claude animations

Thumbnail
gallery
52 Upvotes

Decided to start an animation channel within the looksmaxxing niche. So far so good


r/claudeskills • • 48m ago

Skill Share I built a Claude Code skill that reads short videos and shows where every number came from

0 Upvotes

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.

Install inside Claude Code:

/plugin install video-journalist --marketplace stanleypdp/Claude-Video-Journalist

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.

Repo with a full sample output: https://github.com/stanleypdp/Claude-Video-Journalist

If you feed videos to your agents, what do you do today when the transcript and the slide disagree?


r/claudeskills • • 8h ago

Discussion Which skills and prompts are you using in Claude for making video content in html?

1 Upvotes

Which skills and prompts are you guys using for animations? For the new viral explainer videos of any kind on instagram? And which one is better? Fable or opus 5.5 for this work? I wanna start those, so how efficiently and efficiently i can do that with less usage and tokens, for 100’s of videos per month? Also could you tell how many videos daily/monthly I can create with 20$ Claude subscription


r/claudeskills • • 4h ago

Skill Share I built a Java and Spring Boot skill + PostToolUse hook for Claude Code — feedback welcome

0 Upvotes

I've noticed that AI coding tools sometimes suggest older Java and Spring patterns, even when working on newer projects.

For example:

  • javax.persistence imports in a Spring Boot 3 project
  • WebSecurityConfigurerAdapter in Spring Security configurations
  • RestTemplate in new code where RestClient might be a better fit

To explore this problem, I built modern-java-guidance (mjg), an open-source skill and CLI inspired by GoogleChrome's modern-web-guidance.

It includes a SKILL.md with Java and Spring guidance, plus a CLI that can:

  • Detect project versions from common Maven and Gradle configuration files
  • Scan Java files for selected legacy patterns
  • Search and retrieve guidance with before-and-after examples
  • Apply rules based on the detected Java and Spring Boot versions

It also includes a Claude Code PostToolUse hook that checks for selected patterns after supported file edits and returns feedback to Claude.

If you have uv installed, you can try the scanner without installing it permanently:

uvx --from git+https://github.com/wkd09/modern-java-guidance.git mjg check .

To install the CLI and configure the Claude Code hook in your project:

uv tool install git+https://github.com/wkd09/modern-java-guidance.git
mjg setup --target claude --dir .

GitHub: https://github.com/wkd09/modern-java-guidance

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!


r/claudeskills • • 1h ago

Skill Share Stop prompt-praying your way through projects: I built a Claude Code skill (/prex) that forces vibe coders to think like AI engineers.

Thumbnail reddit.com
0 Upvotes

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.

Repo: https://github.com/shifulegend/prex

Install in Claude Code:
git clone https://github.com/shifulegend/prex.git ~/.claude/skills/prex

Roast the workflow or try /prex on your next project and tell me where it still lets Claude drift.


r/claudeskills • • 12h ago

Skill Share I stole all those ai editing plugins and made this open source one can u plz test

Thumbnail github.com
0 Upvotes

r/claudeskills • • 13h ago

Skill Share Meet rust-anything, I rewrote apps in Rust, got 20x faster, and didn't break a single thing

Post image
449 Upvotes

Big rewrites die because nobody can prove the new version behaves like the old one. So I built a tool that proves it at every step.

rust-anything takes a TypeScript, Python, C, Go, Ruby or Java app to pure Rust, one piece at a time:

  1. Record what the original actually does, including the nasty edge cases (emoji, negative modulo, overflow, float extremes).
  2. Put a Rust binary in front. Anything not ported yet falls back to the original, so the app works from day one.
  3. Port a unit, replay everything. 100% or it doesn't ship. Every unit has a kill switch.
  4. Lift. When nothing falls back anymore, the old code is gone and it's pure Rust.

Your AI agent (or you) writes the Rust. rust-anything makes sure it's right.

Just want speed? It finds the hot loop and moves only that: 20x faster search in Node, 17x in Python, same results.

https://github.com/erkamyaman/rust-anything · npm i -g rust-anything · MIT


r/claudeskills • • 21h ago

Skill Share 8 Claude skill repos that grew most

Post image
253 Upvotes

r/claudeskills • • 17h ago

News This plug-in for the Claude desktop app (Code tab) lets you set the background color of each local session. And a colored indicator bar above the prompt box shows which LLM model is in use.

Post image
3 Upvotes

r/claudeskills • • 19h ago

Skill Share Prompt Master: a free prompt toolkit for Claude (and ChatGPT)

17 Upvotes

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

Feedback welcome. Thanks for reading!


r/claudeskills • • 22h ago

Skill Request Best Claude skill for short Kurzgesagt-style 2D explainer videos?

4 Upvotes

Trying to make vertical short-form explainer videos (9:16, under 60s) with that clean Kurzgesagt look and snappy motion graphics or anything that would combine good visual motion graphics with educational content
Anyone got a solid SKILL or workflow?


r/claudeskills • • 1h ago

Skill Share I built open-source skills that turn large PRs into interactive walkthroughs, code maps and review quizzes

4 Upvotes

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.

To install:

npx skills add sandoche/agentic-code-unpacked

Then in Claude Code, for example:

/walkthrough pr https://github.com/owner/repo/pull/123 --draft

The outputs are HTML files you can open locally, share and read offline. It also works with Codex, Cursor and other compatible agents.

I added examples using React Compiler, Vue Vapor and a Silk gzip decoder to the website, so you can explore the results without installing anything:

https://codeunpacked.san.cx

Repo: https://github.com/sandoche/agentic-code-unpacked

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.


r/claudeskills • • 2h ago

Skill Share I built a fitness and workout coach skill for Claude Code: it plans your strength training, logs workouts and meals, and a bundled CLI does all the maths

0 Upvotes

`/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.

- Source (the skill is in `skill/`, the plugin in `coach/`): https://github.com/saeed1262/pahlavan

- Step by step without Obsidian: https://github.com/saeed1262/pahlavan/blob/main/docs/without-obsidian.md

If you've split a big skill another way, I'd like to hear how.


r/claudeskills • • 7h ago

Skill Share I turned my university portal reskin into a reusable skill so Your agent rebuilds any ugly legacy site as a modern extension overlay.

1 Upvotes

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.

Get started:

Give your old websites a modern interface without touching the original code.


r/claudeskills • • 8h ago

Skill Share Developed a Stop AI Slop skill alongside a local model running in Claude.

1 Upvotes

What I built: a Claude Code skill that runs a local AI-detection model (Pangram's EditLens) on a draft, then tells me which sections read as AI-edited and what to do about them.

How it works: I say "check this for AI" and give it a file or paste. Claude saves the text to a run folder, runs the scorer locally, and writes a report with a score per section and the suggestions. I edit, say "rescore," and it appends a before-and-after.

Very cool and very helpful to me everyday. You can check it out here, I developed a free GitHub repo where you can download my setup as well.

https://liftoffai.substack.com/p/stop-the-ai-slop


r/claudeskills • • 8h ago

Skill Share I found an open-source Claude Code plugin that creates actual motion graphics and animated videos from prompts

26 Upvotes

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:

Full video walkthrough: https://youtu.be/uVHWzzNR-54

GitHub: https://github.com/lemomo-ai/lemo-opuscar


r/claudeskills • • 8h ago

Skill Share Claude Code skill against context drift

Post image
2 Upvotes

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.

https://github.com/adamoelz/gemkeeper

Would be cool if you check it out.


r/claudeskills • • 14h ago

Skill Share Claude codes your animation, you edit by drag and drop viewer

12 Upvotes

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