MakeMyClip Editor

[MakeMyClip Editor]

MakeMyClip Editor

FFmpeg you can talk to.
The open-source AI video editor for Claude Code and any MCP client: remove silence, edit by transcript, add captions, and export to Final Cut Pro, DaVinci Resolve or Premiere Pro. Everything runs on your machine.

[skills.sh] [License: MIT] [Node 24+] [npm] [Tests: 741 passing] [Telemetry: none]

[MakeMyClip Editor — chat-driven video editing demo (real screencast coming soon)]

MakeMyClip Editor is a free, open-source (MIT) video editor that AI agents drive. You ask Claude to edit a recording; it calls the editor's tools, and FFmpeg and a local whisper.cpp do the work on your computer. It ships as a Claude Code skill, the clip CLI, an MCP server, and a browser timeline editor. No cloud upload, no account, no API key, no telemetry, no generative AI.

"Cut the repeated takes and the pauses out of talk.mp4, caption it, and give me a DaVinci Resolve project."

Claude transcribes the recording locally, cuts the earlier take of each repeated phrase and the silences, captions the speech, flags any cut that may clip a word, and writes talk.fcpxml. Each edit is one undoable step on a timeline you can open in the browser and take over.

What it does

Version 0.4.0 turns a raw talking-head recording into a clean, captioned cut that opens in a pro editor:

All of it works from chat (the Claude Code skill or the MCP server), the CLI, and the browser UI; the cut check isn't in the UI yet. Every edit is one step on a non-destructive timeline that undo and redo walk through. Underneath sit 19 single-file FFmpeg tools for everything else: trim, split, concat, transitions, text and title cards, zoom/pan, overlay, speed, color, chroma key, stabilize, and render.

Install in 30 seconds

As a Claude Code skill (chat-driven, no global install):

npx skills add MakeMyClip/editor

Or install it as a Claude Code plugin from this repo's marketplace, inside Claude Code:

/plugin marketplace add MakeMyClip/editor/plugin install makemyclip-editor@makemyclip

As a CLI (for scripts and CI):

npm i -g @makemyclip/editorclip --help

As a browser UI (dark visual timeline editor):

clip ui   # opens http://127.0.0.1:5573

As a Claude Desktop extension (one click, no Node or config file):

1. Install FFmpeg: brew install ffmpeg on macOS, winget install Gyan.FFmpeg on Windows.
2. Download makemyclip-editor.mcpb and double-click it, or drag it into Claude Desktop.

Put your videos in the extension's Media folder (by default Documents/MakeMyClip); the editor reads and writes only there. The extension doesn't include FFmpeg (see License): it finds the one Homebrew, MacPorts, winget, Scoop or Chocolatey installed, or you pick it in the extension's settings, along with the optional whisper model.

As an MCP server (drive it from Claude Desktop / Cursor / any MCP client — no API key, on your existing Claude):

// claude_desktop_config.json → "mcpServers"{  "makemyclip-editor": {    "command": "npx",    "args": ["-y", "@makemyclip/editor", "mcp"],    "env": {      "MAKEMYCLIP_WORKSPACE": "/path/to/your/media",      "MAKEMYCLIP_WHISPER_MODEL": "/path/to/ggml-base.en.bin"    }  }}

It is listed in the official MCP Registry as io.github.MakeMyClip/editor, so MCP clients that browse the registry can install it from there. The Claude Code skill auto-discovers triggers and shells out via npx -y on demand. The MCP server exposes the timeline tools (show / edit / check / transcribe / undo / redo / export) and a doctor setup check over stdio; media stays confined to MAKEMYCLIP_WORKSPACE, and MAKEMYCLIP_WHISPER_MODEL is only needed for transcription and captions. Everything runs locally and offline — no API key.

Optional: local transcription (for editing by transcript, removing retakes, and captions):

brew install whisper-cpp   # macOS; other platforms: https://github.com/ggml-org/whisper.cppexport MAKEMYCLIP_WHISPER_MODEL=/path/to/ggml-base.en.bin

Download a model such as ggml-base.en.bin from huggingface.co/ggerganov/whisper.cpp, and set MAKEMYCLIP_WHISPER_PATH if whisper-cli isn't on your PATH. The editor never downloads a model itself.

Check your setup:

npx -y @makemyclip/editor doctor   # add --json for a machine-readable report

It checks Node, which FFmpeg runs and whether it can draw text and captions, the workspace, a caption font, and the optional whisper.cpp and model, and prints the fix for anything missing. In Claude Desktop or another MCP client, ask "is my setup OK?" and Claude runs the same check.

Quick start: clean up a talking-head recording

In Claude Code (with the skill) or Claude Desktop (with the MCP server), ask:

Clean up talk.mp4: remove the repeated takes and the pauses, add captions, check the cuts, then export an mp4 and a Final Cut Pro project.

The same steps from the CLI:

clip timeline newclip timeline add-media talk.mp4             # prints the clip id, e.g. clip_ec2f047dclip timeline transcribe clip_ec2f047d       # each word with its time, plus repeated takesclip timeline remove-retakes clip_ec2f047d   # cut the earlier take of each repeated phraseclip timeline silence clip_ec2f047d          # cut the pausesclip timeline captions                       # caption every transcribed clipclip timeline check --sheet cuts.jpg         # flag cuts that may clip a wordclip timeline export talk-clean.mp4          # render the cutclip timeline export talk.fcpxml             # or open it in Final Cut Pro / DaVinci Resolveclip timeline export talk.xml                # or in Premiere Pro

A cut splits the clip into pieces: the first keeps its id, and clip timeline show lists the rest, so run silence on each piece you want tightened (in chat, the agent does this for you). clip timeline undo reverses any step.

Another example: a product demo from screen recordings

Five screen recordings → one polished product demo. Type this into Claude Code (or Claude Desktop, via the MCP server):

Import these five recordings. Trim each to the most interesting 8–12 seconds. Add black title cards saying "Demo 1: Inbox", "Demo 2: Search", "Demo 3: Compose", "Demo 4: Calendar", "Demo 5: Reports" between them. Concat in order. Render to 1080p mp4.

The agent runs roughly ingest × 5 → trim × 5 → add_title_card × 5 → concat → render. The final mp4 lands in your workspace folder, every step is appended to session.json, and you can ⌘Z any of it.

Or skip the chat and do it from a script:

clip ingest demo1.mp4clip trim demo1.mp4 5 20clip add_title_card demo1-trim.mp4 "Demo 1: Inbox"clip concat demo1-with-card.mp4 demo2.mp4 demo3.mp4clip render concat-output.mp4 mp4 23 fast 1920

Same registry, same session log, same output.

All 19 tools

19 tools across 5 categories, four surfaces (Claude Code skill, CLI, browser UI, MCP server), one shared op log.

Plus four meta-ops not in the registry: snapshot, undo, inspect, delete.

The browser UI is a dark timeline editor: drag-drop import, a monitor (the composited frame at the playhead), an editable timeline (select a clip to trim / split / move / transition / remove, cut its silences, or cut words and retakes from its transcript), captions from transcripts, one-click export (an mp4, or a project for Final Cut Pro, DaVinci Resolve or Premiere Pro), timeline undo/redo, snapshot, and keyboard shortcuts.

Why it exists

Existing tools force a tradeoff that doesn't need to exist:

• iMovie / CapCut / DaVinci Resolve — mouse-and-timeline desktops. Can't be driven by an agent, scripted in CI, or version-controlled.
• Descript — closed-source, cloud-based, rewrites audio with generative AI you can't inspect.
• Runway / Pika / Luma — generate video from text. Useful for VFX, useless for assembling a 90-second demo from recordings you already have.
• Raw FFmpeg — deterministic and free, but the surface is hostile to LLMs: cryptic filter graphs, no session model, no undo, no tool catalog.

MakeMyClip Editor closes the gap: deterministic editing an agent can drive end to end (silence, transcript cuts, captions, export to pro editors) on a timeline it can inspect and a human can open and take over.

Claude Code  →  skill triggers  →  npx -y @makemyclip/editor <tool | timeline …>                                           │Browser UI   →  /api/tools/:name · /api/timeline/verbs  →  registry + verb layer                                           │Claude Desktop →  clip mcp (MCP server)  →  timeline verbs                                           │                                           ▼                                  Tool handlers (TypeScript)                                           │                                           ▼                                 FFmpeg subprocess (args as array, no shell)                                           │                   ┌───────────────────────┴───────────────────────┐                   ▼                                                 ▼        Composition document                              session.json        (non-destructive timeline,                        (append-only op log         op-log undo/redo)                                 of every tool call)

clip timeline new                       # start an empty compositionclip timeline add-media intro.mp4       # ingest + append a clipclip timeline add-media demo.mp4clip timeline transition <afterClipId> fade 0.5clip timeline show                      # inspect tracks, clips, timingsclip timeline export final.mp4          # compile the document to a render

Questions people ask

Answers describe v0.4.0 (November 2026).

How do I edit a video with Claude Code?

Install the MakeMyClip Editor skill with npx skills add MakeMyClip/editor, then ask Claude Code in plain words, for example "cut the pauses out of talk.mp4 and add captions." The skill runs the clip CLI through npx, edits a timeline document in a local workspace folder, and renders with FFmpeg on your machine. Every edit can be undone.

Is there an iMovie or CapCut for Claude?

MakeMyClip Editor is built for that job: an open-source video editor that Claude drives through a Claude Code skill or an MCP server, with a browser timeline (clip ui) where you can watch and take over. It covers everyday edits (trim, join, transitions, titles, captions, silence removal) but isn't a full desktop editor; for finishing, it exports to Final Cut Pro, DaVinci Resolve or Premiere Pro.

Is there an MCP server for video editing?

Yes. npx -y @makemyclip/editor mcp starts MakeMyClip Editor's local MCP server over stdio for Claude Desktop, Cursor, or any MCP client. Its tools show the timeline, edit it (add media, trim, split, remove silence, cut words, remove retakes, caption speech, transitions), check the cuts, transcribe, undo, redo, and export to mp4, FCPXML or Premiere XML. Media stays in one workspace folder, and no API key is needed.

How do I remove silence from a video automatically?

With MakeMyClip Editor, add the recording to a timeline and run clip timeline silence <clipId>, or ask Claude to "cut the pauses." It finds the quiet stretches with FFmpeg, keeps the speech as back-to-back clips, and lands as one undoable edit. --sensitivity (0–1) sets how much it cuts, and --dry-run lists what it would remove before changing anything.

Can I edit a video by its transcript offline?

Yes. MakeMyClip Editor transcribes with whisper.cpp on your machine; install it and point MAKEMYCLIP_WHISPER_MODEL at a model file. clip timeline transcribe returns each word with its time, cut-words removes a range of words, and remove-retakes cuts the earlier take of each phrase said twice. Nothing is uploaded. Whisper tends to leave out filler words like "um," so the transcript doesn't find them.

Can Claude add captions or subtitles to a video?

Yes. After transcription, MakeMyClip Editor's clip timeline captions (or the UI's Captions button) puts captions timed to the words on a track above the video, and export burns them in. Captions come as short phrases or one word at a time, with your choice of size, color, position, and background. Non-Latin scripts use an installed font that has the glyphs. In the Premiere export, captions become .srt files. On Linux, the bundled FFmpeg can't draw text, so set MAKEMYCLIP_FFMPEG_PATH to an FFmpeg built with libfreetype and libharfbuzz.

Can I finish an AI edit in DaVinci Resolve, Premiere Pro or Final Cut Pro?

Yes. MakeMyClip Editor's clip timeline export cut.fcpxml writes FCPXML 1.10 for Final Cut Pro and DaVinci Resolve, and clip timeline export cut.xml writes Final Cut Pro 7 XML for Premiere Pro. Both keep the cuts, gaps, fades, volume, and cross dissolves, and point at your original files by path. Anything the format can't hold (speed, color adjustments, chroma key) is refused with the fix to make.

How does MakeMyClip Editor compare to Descript?

Descript is a hosted, closed-source editor with its own AI agent, transcript editing, and paid plans. MakeMyClip Editor is MIT-licensed and local: your agent (Claude Code, Claude Desktop, or another MCP client) edits a timeline file on your machine with FFmpeg and whisper.cpp, and the cut exports to Final Cut Pro, Resolve, or Premiere. Descript offers a richer editing app, collaboration, and AI voice features.

How does MakeMyClip Editor compare to auto-editor?

auto-editor is a mature open-source command-line tool that cuts silence or motion, edits by word with local transcription, and exports to Premiere, Resolve, and Final Cut Pro. MakeMyClip Editor covers the same talking-head cleanup but keeps the edit as a timeline document that an agent (via the skill or MCP) and a person (in the browser UI) share, with undo for every step and a check that flags cuts that may clip a word.

When to use it

✅ Great fit for: cleaning up talking-head videos, tutorials, and podcasts (silence, retakes, captions) before finishing in Final Cut Pro, Resolve, or Premiere · assembling product demos, screen recordings, and social clips with an AI agent doing the labor · scripting repeatable video pipelines in CI · sharing version-controllable timeline JSON · editing offline.

❌ Not the right tool for: frame-accurate color grading (use DaVinci Resolve) · multi-track audio mixing with effects (use Reaper, Logic) · generative-AI video (use Runway, Pika) · long-form projects with hundreds of clips.

Roadmap

• Now (v0.4.0) — silence removal, local transcription, edit by transcript, retake removal, captions, export to Final Cut Pro / DaVinci Resolve / Premiere Pro, on top of the dark timeline editor (view / edit / preview / export), 19 tools, MCP server, and snapshot/undo
• Next — model picker, SSE for live session updates, AI Elements / shadcn migration
• 1.0 — frozen tool schemas, MCP transport, published Anthropic skill, docs site
• Beyond — desktop app (Electron), cloud rendering via MakeMyClip.com

The full milestone log lives in PR descriptions on GitHub.

Acknowledgments

Built on the work of FFmpeg, whisper.cpp, the Model Context Protocol, Anthropic Claude, Zod, Hono, Vite, and React.

Links

License

MIT for the editor source. FFmpeg is a separate program, run as a subprocess under its own license:

• npm package, CLI, Claude Code skill: ffmpeg-static downloads an FFmpeg build from its GitHub releases when the package installs. The Intel macOS, Windows and Linux builds are GPLv3. The Apple Silicon build includes nonfree parts and isn't redistributable.
• Claude Desktop extension (.mcpb): includes no FFmpeg. It runs the one you install.

Set MAKEMYCLIP_FFMPEG_PATH to use an FFmpeg of your choice. Use it, fork it, ship it.