Ditto AI vs writing a Claude Code skill yourself
A Claude Code skill is a folder with a SKILL.md file: instructions you write, which Claude loads when they're relevant. Writing one is free and gives you full control, but choosing MCP servers, wiring their credentials and setting permissions is still your job, and a skill's allowed-tools only pre-approves tools for one turn. Ditto AI writes the agent from a recording of you doing the task, finds and checks a tool for each step, and installs it into Claude Code with its servers and allowlist.
The short answer
A skill is a text file. Claude Code's docs put it plainly: "Create a SKILL.md file with instructions, and Claude adds it to its toolkit." It has YAML frontmatter that "tells Claude when to use the skill" and Markdown with "the instructions Claude follows" (Claude Code docs). If the procedure is short and you already know the tools, writing it yourself is the fastest route there is.
The file is rarely the hard part. For a task that crosses two or three apps, the work is around the file: finding a server for each app, getting a credential into each one, deciding what the agent may touch, and checking all of it works. That's the part Ditto AI does from a recording.
What you still do yourself
- Write the steps from memory. The docs suggest a skill "when you keep pasting the same instructions, checklist, or multi-step procedure into chat" (docs). Nothing watches you do the task.
- Choose the MCP servers. The docs warn: "Verify you trust each server before connecting it. Servers that fetch external content can expose you to prompt injection risk" (docs).
- Install and scope each server, with
claude mcp addfor a remote one or a stdio command for a local one, at local, project or user scope (docs). - Wire the credentials: an
--envvalue, a header, an OAuth sign-in, or${VAR}expansion in.mcp.json(docs). - Set the permissions. A skill's
allowed-tools"grants permission for the listed tools during the turn that invokes the skill", "the grant clears when you send your next message", and it "does not restrict which tools are available". Lasting allow, ask and deny rules go in settings (skills, permissions). - Package it so the servers travel with it. Adding
.claude-plugin/plugin.jsonturns a skill folder into a plugin "so it can bundle agents, hooks, and MCP servers" (docs). - Test it with realistic prompts, with and without the skill (docs).
Side by side
| Recording it with Ditto AI | Writing it yourself | |
|---|---|---|
| Where the steps come from | Your recording. Each step cites the frames and clicks it came from; a step with nothing to cite is dropped | Your memory (docs) |
| Choosing tool servers | Candidates from the official MCP registry and npm; the model ranks what was found and can't name one from memory | You pick, and the docs ask you to verify you trust each one (docs) |
| Proving a server works | One real, read-only call before it counts as working; nothing that writes is exercised | Up to you |
| Credentials | Ditto reads the server's README for exactly what it needs and asks you for that | You wire each one (docs) |
| Permissions | From a fixed table, per tool; anything unclassifiable is a write. Ditto's own Claude Code runs pass the list as --allowedTools | allowed-tools pre-approves for one turn; lasting rules go in settings (skills, permissions) |
| Where it runs | Ditto, Claude Code or Kiro CLI | Claude Code, and other tools that read the same skill format |
| Cost | Free; you pay your AI provider for reading the recording (pricing) | Free: it's a text file |
Where writing it yourself is better
- Nothing new to install or trust. No app watching your screen, no new vendor.
- Full control. Subagents, hooks, shell output in the prompt, path-scoped activation, model and effort overrides (docs).
- It's portable. The same skill format works in other agent tools, including Codex. Ditto has no Codex export yet.
- It suits coding procedures. The docs' own examples summarise a diff, deploy an app and commit changes, which are easier to write than to record.
Where Ditto is different
- You show it instead of describing it. For a task with many clicks across several apps, doing it once is quicker than writing it down accurately.
- The tool layer comes with it. A server per step, found and ranked from the registry, checked with a read-only call, with the credential it actually needs.
- The permissions are decided by a table, not by you or the model. The agent gets only the tools the recording used. See a real exported policy on the Wikipedia template.
Choose to write it yourself if
- The procedure is short and clear enough to write down: a deploy, a commit, a review.
- You already know which MCP servers you trust and how to scope their credentials.
- You need it in Codex, on Linux or Windows, or in CI.
Choose Ditto AI if
- The task is easier to show than to write: several apps, many clicks, inputs that change.
- You'd rather not pick and wire MCP servers yourself.
- You want the permissions settled before the first run, from a fixed table.
Can you use both?
Yes. A skill Ditto installs is a folder in ~/.claude/skills/, and you can edit it like any skill you wrote. A sensible split: record the multi-app chores, and keep writing the short coding procedures by hand.
Ditto AI with Claude Code shows what gets installed and how it runs.