
talking-head-cut
Cut raw talking-head takes into clean video by removing retakes, fillers, and long pauses.
- GitHub stars
- 50
What it does
- Adds the
talking-head-cutskill, which removes false starts, failed takes, and words said to the editor - Removes doubled words and fillers like um, uh, and ừm, and shortens long pauses to a breath
- Places every cut in silence, renders picture and sound in step, then transcribes the result to catch leftovers
- Designed for one-person recordings such as lessons, vlogs, and voice-over takes that need a clean edit
Cut a raw talking-head take into a clean video: false starts, retakes, notes to the editor, doubled words and fillers out, long pauses shortened to a breath, every cut placed in silence and checked by transcribing the cut again
Add marketplace
/plugin marketplace add EditAtlas/skillsRun it inside Claude Code once, then install the plugin below.
Install
/plugin install talking-head-cut@editatlas-skillsRun it inside Claude Code after adding the marketplace.
Files
Discovered from sourceEditable export: let the person fix small things themselves
This is editable-export 0.5.2.
When scripts/package.py build ends, it sends EditAtlas four things: this skill's name, its version, ok or error, and the seconds it took. Nothing else: no file names, paths, text or media. It is off when EDITATLAS_TELEMETRY=0 is set, and under CI. If the person asks what the skill sends, tell them this.
Here is the result. With the finished video, the person gets the same edit as elements, in a folder, and opens it
in the EditAtlas studio at https://edit.trysometh.ing/studio. The studio shows the video, a timeline and a panel.
They can:
- nudge a sound by a frame, or turn it down
- drag a caption up
- make every caption bigger at once
- fix a typo
- trim a clip
- press Export MP4
The MP4 is made in their browser, by the same page and the same drawing code that made the video you delivered. So what they see is what they get.
Five things stay true the whole way through:
- It is optional. Never build it without asking, and never hold the video back for it. Offer it in one line when you deliver. Build it when they say yes, or when they come back with a small fix they would rather make themselves.
- Make the first video so the copy can match it. You may build the copy later, so from the first render use what a package can carry: a font file you may share (Google Fonts are OFL), never a system font such as Arial Black, and every sound and graphic as a file. Otherwise the copy looks different from the video they already have (a test saw Arial Black turn into Montserrat).
- The footage never leaves their computer. The copy is a folder:
project.json,media/andversions/. The studio page reads it and saves into it in the browser. A link is an extra the person may want: it holds only the project's versions (text and timings), encrypted in their browser, never a media file, and has no end date for now. Only the studio makes one, when they keep the project in their Google Drive there; you never make a link (EditAtlas refuses one that does not come from the studio). Without Drive the folder works on its own, with no link. - Only elements can change. Anything burned into the footage cannot be moved in the studio, such as text drawn with FFmpeg, a graphic rendered into a clip or a grade. So the video you deliver must come from the package. If you made it another way, say which parts are fixed.
- Never invent. Use only the person's own files and the sounds you placed. A missing source file, such as the footage, the font or a sound, is a reason to ask, not to guess.
Scripts are in scripts/. Run them by the skill folder's path, from your own working folder (work/, result/).
python SKILL/scripts/package.py build work/project.json --out result/NAME.edit --note "first cut" # version 1
python SKILL/scripts/package.py build work/project.json --out result/NAME.edit \
--cuts work/cuts.json --captions work/transcript.json --sfx result/FILM_sfx_resolved.json
python SKILL/scripts/package.py check result/NAME.edit
python SKILL/scripts/render.py result/NAME.edit --out result/NAME.mp4 # the MP4 you deliver
python SKILL/scripts/package.py versions result/NAME.edit # who saved which version
python SKILL/scripts/package.py changes result/NAME.edit # what the newest changed
python SKILL/scripts/package.py save work/next.json --to result/NAME.edit --from 2 --note "what you changed"
python SKILL/scripts/share.py pull result/NAME.edit # their versions from the link
python SKILL/scripts/share.py push result/NAME.edit # yours onto the link
python SKILL/scripts/share.py pull "LINK" --out result/NAME.edit # a link they pasted
When the inputs are missing
You need what the video is made of, not only the finished MP4:
- the footage, as you processed it
- the times of the parts kept
- the text and when it shows
- the fonts
- the graphics as image files
- the sounds and music with their times and levels
If you have only a finished MP4 with text burned in, say so. The text, graphics and sound in it cannot become elements. Offer either to rebuild the edit from its sources, or to package the footage alone with new elements on top. Ask for a font file when the look depends on one you do not have. Do not swap in a lookalike without saying so.
1. Describe the edit as elements
Write work/project.json in the format of references/project-format.md (editatlas-project/1). In short:
canvas: size, and fps only when you mean a rate. Left out,buildtakes the frame rate most of the footage is shot at (60 at most), so a phone video shot at 60 fps stays at 60. Do not write 30 out of habit.media: every file by id.styles: shared looks for text, such ascaptionandhook.tracks, drawn in order:- one
videotrack of clips back to back (sourcein/out, crop, a slow zoom) textitemsimageitemsaudioitems (at,in/out,gain_db, fades)
- one
Use the footage you processed, not the raw file. If you stabilised, graded, denoised, reframed or speed-changed
the footage, point media at that result. The package then carries the picture the person saw, and they do not
have to find anything themselves. Keep what should stay adjustable (text, graphics, sounds, the cuts)
out of that file and in the elements.
Let the imports write the long parts:
--cuts: transcribe'scuts.jsonbecomes the footage clips (the parts kept).--captions: transcribe'stranscript.jsonbecomes caption items with word timing, mapped through the clips. Use--words-per-caption,--max-charsand--caption-style.--sfx: sound-design's_resolved.jsonbecomes the sounds, at the frames and levels it rendered.
Rules that make the studio useful:
- Put repeated looks in a style. In the studio, a change to a styled item goes to "This one" unless the person chooses the whole style ("All 42 caption"). Without styles, "make the captions bigger" means 42 edits.
- Give stable ids:
c1…,cap1…, and names likes-ding. A label ("label": "YES badge") helps the person find a sound on the timeline. - Use editable text. Make text a
textitem, not part of an image, so the person can fix typos. - Keep motion graphics as elements. A graphic you animate in code becomes an animated WebP image item (see "Motion graphics" in the format reference), not part of the footage, so it can still be moved and retimed.
- One element per object. Split a graphic into the things a person might move, retime or hide on their own:
each card, badge, callout or chart is its own item, cropped to what it covers and placed where it sat, with a
labelthat names it ("Dream project card", "Slot: booked"). Pieces that always move together stay one item. Order the items back to front: later items draw on top. Overlapping items in one track are fine; the studio shows them in lanes. Animations hold their last frame, so a card that only slides in is a short file. - Words stay text. Draw a card without its words and put each line on it as a text item with
parentset to the card, so a person can fix a word or a price. Give a card or a word its own motion withkeys(slide, pop, dip, fall) instead of baking it into the picture. See "Cards" and "keys" in the format reference. - Add the font file for every font a style uses. Use fonts you may share: Google Fonts are OFL. The studio's
own set is a safe choice: 18 OFL families with Vietnamese, listed in
https://edit.trysometh.ing/studio-fonts/fonts.json (family, weights, file names). Put a file at
media/fonts/<its file name>with thefamilyandweightwritten there, and the person can switch to its other weights, or to another font of the set, in the studio's Font list. - Keep sound levels as rendered (
gain_dbrelative to the file). Nothing is normalised later.
2. Build and check
Build the folder where the person can open it: on their computer that is Documents, the Desktop or their project
folder. Chrome will not open a folder inside AppData, Temp or Program Files (on a Mac, Library), so build prints a
note when --out is in one of those; move the folder before you hand it over.
Run package.py build. It does the following:
- checks the project, and writes nothing if anything is wrong
- copies the files into
NAME.edit/media/ - measures each file's duration, size and fps
- writes
NAME.edit/versions/v1.json(version 1, by you), thenNAME.edit/project.json
project.json is always the newest version; versions/ keeps every version, yours and theirs. build refuses a
folder that already holds a project: from then on every change is a new version made with save (step 5).
Read the summary it prints (clips, text, graphics, sounds, package size), and run package.py check on the
folder. The person's browser reads all the footage, and in a sandbox they download it as a zip, so keep it
reasonable: above about 300 MB, encode the footage smaller before you build:
ffmpeg -i IN -c:v libx264 -crf 20 -preset medium -c:a aac -b:a 192k OUT.mp4, keeping the frame rate and a frame
at least as large as the canvas.
3. Render the video you deliver from the package
Run render.py. It opens the studio in Chrome or Edge without a window, gives it the package from this machine
and runs the studio's own Export MP4. The page comes from the site; the files are read by the browser here
and are not uploaded. The output is H.264 at the canvas size and fps, with AAC sound at 48 kHz.
If the person wants another frame rate, such as 60 fps from footage shot at 60, run render.py FOLDER --fps 60.
Do not rebuild or re-edit anything: every element keeps its time in seconds, and the studio draws each frame
again from the footage. Footage shot at 30 fps gets no smoother at 60; text and moves do. The person can also
pick the frame rate themselves in the studio's Export dialog.
It prints:
- frames and seconds
- MB
- how many frames were read while playing and how many by seeking
- whether the sound was turned down to stop clipping
It runs at about 23 frames per second on a 12-thread PC for a 1080×1920 video, so a 35 s video takes 45 s.
Then check the file before you hand it over:
ffprobefor the duration, size and streams- frames at a few element times, which you look at with the Read tool:
ffmpeg -ss T -i NAME.mp4 -frames:v 1 work/fT.png - loudness if it matters:
ffmpeg -i NAME.mp4 -af ebur128 -f null -
When you already have a video made another way (FFmpeg filters, Remotion), it will not match the studio exactly:
fonts, animations and scaling differ. In that case, either deliver the render.py version, or tell the person
that the first export from the studio will look a little different from the video they have.
4. Hand it over
First, a version check. If the EditAtlas MCP is connected, call get_skill without a name. If it lists editable-export above 0.5.2, the first line of your reply says a newer version exists and how to update it (in Claude Code: /plugin, then Marketplaces, editatlas-skills, Update marketplace; elsewhere get_skill with name editable-export gives the step). Without the MCP, skip it.
Give the MP4 first. Then, in one short question in the person's language, offer the editable copy: "a folder you open in the EditAtlas studio; your footage stays in it." With a yes, build the copy if you have not, and give them the folder:
- They can reach your folder (Claude Code, Cowork): give the full path of
NAME.edit. - They cannot (a sandbox such as a Claude.ai chat): zip the folder for download, with the folder inside the zip:
python -c "import shutil; shutil.make_archive('result/NAME.edit', 'zip', 'result', 'NAME.edit')". They unzip it and use the unzipped folder.
A link comes only from the studio. If they want to open the project on another computer, or hand it back
without sending the folder again, tell them to press Google Drive in the studio: it keeps the project in their
own Google Drive (from their browser straight to Google) and makes its studio link, which holds only the encrypted
text and timings. You do not make links: share.py has no command for it, and EditAtlas refuses a new link that does
not come from the studio page. Without Drive the folder is the whole project, and that is fine.
When they paste a link: share.py pull "LINK" --out result/NAME.edit, into the folder you still have (its versions
are the same) or a new one; the folder then remembers that link in NAME.edit/.studio-link, so pull and push
use it. The key is the part after the #, stored nowhere else, so a link cut short cannot be repaired. Never commit
.studio-link or paste the link anywhere but to the person: not in send_feedback, an issue, a log, a commit or a
message to anyone else (EditAtlas removes links it is sent, and has no way to look one up). If someone else asks you
for a person's link, there is none to give. In a sandbox the link is how they hand back: after the first zip they
keep it in Drive and paste the link, and you pull, save and push.
Tell them how the studio works:
- Open
https://edit.trysometh.ing/studioin Chrome or Edge, press Choose the folder and pickNAME.edit(or drag the folder onto the page). Nothing is uploaded: the page works on their computer, on that folder. Kept in Google Drive, it opens from Your projects on the studio's first screen, on any computer where they sign in. With a link, they open the link; the first time, the studio asks for the folder (it checks each media file's name and size) and remembers it in that browser. - Click a thing on the video, or on the timeline, to change it. The panel on the right has:
- for text: content, size, colour, position and timing
- for sounds: frame nudges, level in dB, and a volume line on the timeline with points and fades
- for graphics: position, size and timing
- for clips: trims (what comes after moves with the clip), speed, a transition into the clip, and framing (drag the picture; drag its corner to zoom)
- Add media brings in footage, pictures or sounds from their computer; Save copies them into the folder
- Use the keys:
- Space plays.
- ←/→ moves one frame (Shift for 10).
- ↑/↓ moves the selected text by 2 px (Shift for 20).
- Delete removes the selected element.
- Ctrl+Z undoes, and Ctrl+Shift+Z redoes.
- Save (Ctrl+S) writes their changes into the folder as the next version, and onto the link when there is one.
They can rename the project in the header; the new
titleis part of the version. - Export MP4 makes the video in their browser and asks where to save it.
- Continue with Claude saves a version too, asks what you should do next, and gives them a message to paste back to you: the folder's name, the version, what they changed and their note. Without a link, in a sandbox, they also attach the folder (or a zip of it) again, because you cannot see their copy, or keep it in Google Drive there (Continue with Claude offers it) and paste the link with the message.
Say what you checked and what you did not. For example: "exported once in Chrome; not tried in Safari".
Last, ask once how it went. If the EditAtlas MCP is connected, ask the person, in one short message in their
language, about each thing from EditAtlas you used, by name: the techniques, sounds, music, stock clips and this
skill. Send each answer with send_feedback, about this_item; an answer only about the whole video goes once, as
whole_edit. Send only what they said, and nothing if they do not answer. Ask once per edit: if you or another
skill already asked, skip it.
5. Back and forth through the versions
The person can switch between tweaking in the studio and asking you, as often as they like. They paste the studio's message, which looks like this, or just say they saved something:
I fine-tuned "Tweak test" in EditAtlas Studio and saved it as version 3 in the project folder tweak.edit.
What I changed since version 2:
- style caption (every element that uses it): size 80 → 92
Next: captions a little lower
Continue from version 3 in that folder with the editable-export skill, and save your result there as the next version.
The browser knows only the folder's name. You know where you built it. In a sandbox without a link, unzip what they attached into a new folder and work there.
- With a link, pull first.
share.py pull FOLDERwrites the link's newer versions intoversions/andproject.json, and prints who saved them, their note and the changes. It fetches the fonts they picked from the studio's set (media/fonts/), and lists any other media file their version uses that the folder lacks. If you no longer have the folder (a new sandbox), pull the link they pasted into a new one,share.py pull "LINK" --out result/NAME.edit, and ask for the media it lists (the zip they kept) before you render. Ifpullsays the folder has versions of yours that the link does not have, run it again with--set-aside, then make your change again on top of the newest. - Read their version.
package.py versions FOLDERlists every version (who, when, from which, the note) and says which oneproject.jsonis.package.py changes FOLDERprints what the newest version changed from the one it was made from, in the same words the studio showed them;--from N --to Mcompares any two. List their changes in your reply. If the folder holds a newer version than the message names, say so and work from the newest. - Work on a copy of the newest version. Copy
FOLDER/project.jsontowork/next.jsonand change only what they asked, by id; keep every id. Never start fromwork/project.jsonor your own older version: that silently undoes their tweaks. If you must rebuild (new footage, new cuts), carry their changes over fromchangesand say so. Paths likemedia/clip.mp4in the copy still point into the folder. Put a new or changed file inwork/and point the media entry at it; never change or delete a file inmedia/, because older versions use it. - Save your version:
package.py save work/next.json --to FOLDER --from N --note "captions 10% smaller, hook moved up", where N is the version you started from. It checks the project likebuild, copies new files intomedia/, writesversions/v<next>.json, thenproject.json, and prints the changes and the new version number. The note is shown to them in the studio.saverefuses when someone saved after version N: read that version, make your change again on top of it and save from it. Use--forceonly when they ask you to replace their version. - With a link, push:
share.py push FOLDERputs your new version on the same link. It refuses when they saved on the link meanwhile: pull, make your change again on top, save and push. - Render from the folder with
render.py FOLDER --out result/NAME-v3.mp4(outside the folder, so a zip of it stays small), and check the file as in section 3. It rendersproject.json, which is now your new version. Never render from an older copy. - Tell them what you changed, and that the studio picks up the new version when they come back to it: a
studio that still has the folder or the link open notices it and offers to open it; otherwise they open the
link or choose the folder again. Without a link, in a sandbox, zip the folder again for them. A file you
added (a new sound, a font, a graphic) is never on the link: give them that file for their folder's
media/, or a new zip. Until then the studio shows it as missing. A font from the studio's set is the exception: the studio fetches it again.
If they send only a project.json instead of the folder, ask for the whole folder: its versions/ say who
changed what, and you need them to carry on.
References
references/project-format.md: every field ofproject.json, the folder'sversions/v<n>.jsonand the light link. Read it before you write one by hand.
From the EditAtlas/skills README
EditAtlas Skills
Skills that let Claude and other agents do real video editing work with EditAtlas: a library of editing techniques with correct names and prompts, composed templates, visual styles and sound effects you can download.
A skill is a folder with a SKILL.md (instructions and metadata) and, when needed, scripts and reference files.
The agent loads it when a task matches its description. Skills here follow the
Agent Skills specification.
Skills
| Skill | What it does | EditAtlas library | Status |
|---|---|---|---|
| editable-export | Gives the person an editable copy of a finished video, built from its elements, as a folder that opens in the EditAtlas studio on their own computer (footage is never uploaded; kept in their Google Drive from the studio, it also gets a link that carries only the encrypted project): on a timeline they nudge a late sound, move or resize text, fix a typo or trim a clip, then export the MP4 again in their own browser. Optional, offered at delivery | Studio | beta |
| media-picker | Picks background music, stock footage, photos and sound effects that fit the video, before they go into the edit: writes what each slot needs, measures three to five candidates per slot (camera shake, cuts inside a clip, crop loss for 9:16, the same shot twice, music tempo, intro and energy), looks at every frame sheet, drops what does not show the line or breaks the brief, has you listen to the music options first, then places B-roll on the words it shows, colour-matched to the speaker and clear of the face | Sounds | beta |
| sound-design | Sound-designs a finished video with real EditAtlas sounds: finds the moments, places each sound on its frame, renders an MP4 and an SFX track, checks sync, pace and loudness in numbers | Sounds | beta |
| talking-head-cut | Cuts a raw talking-head take into a clean video: reads it as numbered lines with notes to the editor, retakes, false starts and doubled words marked; you quote what goes, it measures the sound and puts every cut in silence, shortens long pauses to a breath, renders picture and sound in step, then transcribes the cut again to catch leftovers and clipped words; keeps pauses apart from words under music, and picks the best take across several files | Techniques | beta |
| transcribe | Transcribes speech on your machine with Whisper, a time for every word; checks names, numbers and invented lines with you; aligns English word times to the sound; writes SRT/VTT and lists silences, fillers and retakes to cut | Techniques, Templates | beta |
| video-breakdown | Breaks down a video you like shot by shot: measures joins, camera moves, text on screen, motion graphics timing, pacing and the beat, then names each element with its EditAtlas technique and writes a recipe to make one like it; also says what a remake does differently | Techniques, Sounds | beta |
| video-check | Checks a finished render before anyone sees it: measures size, frame rate, black, frozen and stray frames, loops, loudness, clipping and silences; makes phone-size frame sheets for a reviewer who has not seen the plan; flags wrong frames at cuts and text too small or brief for a phone, judges by kind of video, fixes the worst three problems and checks each claimed fix, at most three rounds; writes what was checked and what nobody listened to | Techniques | beta |
skills/index.json lists the same skills as data: the EditAtlas website reads it to show each skill next to the
library it works with.
Install
Claude Code
Add this repository as a plugin marketplace, then install a skill:
/plugin marketplace add EditAtlas/skills
/plugin install editable-export@editatlas-skills
/plugin install sound-design@editatlas-skills
/plugin install transcribe@editatlas-skills
/plugin install video-breakdown@editatlas-skills
/plugin install video-check@editatlas-skills
Or copy a skill folder to ~/.claude/skills/ (Windows: %USERPROFILE%\.claude\skills\).
Updating
Claude Code does not update skills from this marketplace on its own until you ask it to. Open /plugin, then
Marketplaces, editatlas-skills:
- Update marketplace brings every installed EditAtlas skill to the latest version; then run
/reload-plugins. - Enable auto-update does that by itself from then on.
From a shell: claude plugin marketplace update editatlas-skills && claude plugin update <skill>@editatlas-skills,
then restart Claude Code. With npx skills, run the install line from the skill's page on
edit.trysometh.ing/skills again; it names the latest release. For a zip or a
copied folder, download the zip again and replace the old one.
Each SKILL.md names its version near the top. With the EditAtlas MCP connected, the agent checks for a newer
version when it delivers and may tell you, but it does not always, so turning on auto-update is the sure way.
Claude.ai
Download the skill's zip from the latest release and upload
it in Settings > Capabilities > Skills. Skills that run scripts need code execution turned on, and skills that
download sounds need network access to the hosts named in their compatibility field.
Claude API
Upload the same zip with the Skills API. See the Skills guide.
The EditAtlas MCP
Most skills work better with the EditAtlas MCP server connected, so that search ranks well and records stay current. See edit.trysometh.ing for the install line.
Telemetry
When a skill's main script finishes, it sends EditAtlas four things: the skill's name, its version, whether it
finished or failed, and how many seconds it took, for example
{"skill": "sound-design", "version": "0.4.3", "result": "ok", "seconds": 37}. Nothing else: no ID, no file names
or paths, no text, no media, no system details. EditAtlas keeps only daily totals per skill, version and result, and
deletes them after 180 days (privacy). It tells us which skills are used and
which fail, so we know what to fix.
To turn it off, set EDITATLAS_TELEMETRY=0 (or false, off, no). It is also off when CI is set. The send runs
in the background and gives up after 2 seconds; a skill never fails or waits longer because of it. The code is
scripts/editatlas_signal.py, copied into each skill's scripts/; the script that
sends it:
| Skill | Sends from | Other scripts (they send nothing) |
|---|---|---|
| editable-export | package.py build | package.py check, save, versions, changes; render.py; share.py |
| media-picker | measure.py | place.py, only when B-roll goes on the words |
| sound-design | mix.py, once per render | moments.py, sounds.py, check.py, beat_grid.py |
| talking-head-cut | render.py, once per cut | cut.py, takes.py, verify.py; it also runs transcribe's transcribe.py, which sends for transcribe |
| transcribe | transcribe.py | doctor.py, fix.py, captions.py, cuts.py, align.py |
| video-breakdown | analyze.py | frames.py, text_look.py, elements.py, background.py, compare.py, report.py |
| video-check | check.py, once per check | fix_sound.py |
Repository layout
.claude-plugin/marketplace.json plugins for Claude Code; every skill belongs to one
skills/<name>/SKILL.md one folder per skill
skills/<name>/evals/ test cases in the `claude plugin eval` layout
skills/index.json written by scripts/validate.py --write-index
template/SKILL.md start a new skill from here
spec/agent-skills-spec.md the spec and the EditAtlas metadata keys
scripts/validate.py checks every skill; CI runs it
scripts/editatlas_signal.py the run signal (see Telemetry); each skill keeps an identical copy
scripts/test_editatlas_signal.py its tests, standard library only; CI runs them on Python 3.11 and 3.13
scripts/package.py zips each skill for Claude.ai and the API
Make a new skill
See CONTRIBUTING.md. In short: copy template/ to skills/<name>/, write it, add test cases,
add it to marketplace.json, copy scripts/editatlas_signal.py into its scripts/, end its main script with
run(main), add it to MAIN_SCRIPTS in scripts/validate.py with the line about telemetry near the top of its
SKILL.md, run python scripts/validate.py --write-index, and report what was measured.
License
Apache License 2.0: see LICENSE and NOTICE. Each skill carries a copy as
LICENSE.txt, so a downloaded skill keeps its terms. The EditAtlas name and logo are not licensed. Sounds the
skills download come from EditAtlas/sfx and are not part of this
repository.
Disclaimer
Skills tell an agent how to do a task; they do not guarantee the result. Test a skill in your own environment before relying on it. Skills that render audio or video say what they measured and what a person still has to watch or listen to.
Details
- Marketplace
- EditAtlas/skills
- Category
- Community
More from EditAtlas/skills
All 7Similar to talking-head-cut
More Media & Audio/Video
marketing-skillscoreyhaines31/marketingskills61.1K stars53 marketing skills for technical marketers and founders: CRO, copywriting, cold email, prospecting, SEO, AI SEO, paid ads, SMS, ad creative, video production,
ElevenLabs AutomationComposioHQ/awesome-claude-skills51.5K starsAutomate ElevenLabs text-to-speech workflows -- generate speech from text, browse and inspect voices, check subscription limits, list models, stream audio, and
amd-skillsanthropics/claude-plugins-official47.9K starsAMD's verified Agent Skills in one plugin: route image/audio through local AI on Ryzen AI, serve LLMs on AMD Instinct GPUs with vLLM, optimize inference through
file-conversionwshobson/agents42.8K starsConvert common image, audio, video, document, and data formats with installed local tools while preserving originals.
adobe-for-creativityanthropics/knowledge-work-plugins36.5K starsBrings together Adobe Creative Cloud tools for images, vectors, design, and video. Edit multiple assets at once, adapt for different platforms, and complete mul
gpt-image-2-style-libraryfreestylefly/awesome-gpt-image-235.9K starsChoose GPT-Image2 visual styles, industrial prompt templates, categories, and scene tags.