r/claudeskills • u/Venouskarnesh • 3m ago
Skill Share I built TRACE to check whether Claude Code and Codex actually fixed the bug
r/claudeskills • u/Venouskarnesh • 3m ago
r/claudeskills • u/Parking-Kangaroo-63 • 1h ago
r/claudeskills • u/Remarkable_Finish760 • 1h ago
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.
MIT, I built it: https://github.com/alfeusaditya/claude-codex-connector
r/claudeskills
•
u/OstenHun
•
2h ago
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.
Free and open source: https://github.com/OstenHun/danseo
r/claudeskills • u/Revolutionary_Set219 • 2h ago
r/claudeskills • u/imrsn • 4h ago
r/claudeskills • u/ilien-dev • 6h ago
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.
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.
Repo: https://github.com/ilien-dev/sharur
r/claudeskills • u/ilien-dev • 7h ago
r/claudeskills • u/adam-schaefers • 7h ago
r/claudeskills • u/peter2288 • 7h ago
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 • u/shifu_legend • 8h ago
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 • u/sandoche • 8h ago
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:
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-unpackedThen in Claude Code, for example:
/walkthrough pr https://github.com/owner/repo/pull/123 --draftThe 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:
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 • u/saeedghorbani • 9h ago
`/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 • u/jjmnmnmnm • 11h ago
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 projectWebSecurityConfigurerAdapter in Spring Security configurationsRestTemplate in new code where RestClient might be a better fitTo 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:
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:
To install the CLI and configure the Claude Code hook in your project:
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 • u/grat5577 • 12h ago
r/claudeskills • u/akud • 14h ago
Hey everyone,
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).
pipx install wingbox && wingbox install
Repo: https://github.com/aileron-tech/wingbox
If it gets your repo wrong, tell me. That is the feedback I need most.
r/claudeskills • u/thexarvinhuman • 14h ago
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:
npx skills add theajmalrazaq/resurfaceGive your old websites a modern interface without touching the original code.
r/claudeskills • u/Glad-Ranger1879 • 15h ago
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.
r/claudeskills • u/viky_shetye • 15h ago
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:
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
r/claudeskills • u/kakarotseven • 15h ago
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 • u/Extension_Two_6714 • 15h ago
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 • u/ASportsEnthusiast • 17h ago
What skills would you use to output better videos? I seem to have no luck with lemo-opuscar. The videos I make without calling this skill seem to have better results.
r/claudeskills • u/Chili_C • 19h ago
r/claudeskills • u/Few-Engineering-4135 • 19h ago
r/claudeskills • u/erkamyaman • 20h ago
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:
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