Skip to content
Back to search

media-pipeline-marketplace

SkillWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/guinacio--claude-image-gen/badge.svg)](/listings/guinacio--claude-image-gen)

HTML

<a href="/listings/guinacio--claude-image-gen"><img src="/api/listings/guinacio--claude-image-gen/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Quick Install (Claude Code Plugin)

The plugin installs the **core image-generation skill + CLI + MCP server** in one step—no separate configuration needed. Specialized workflows are intentionally opt-in.

# Add the marketplace
/plugin marketplace add guinacio/claude-image-gen

# Install the plugin
/plugin install media-pipeline@media-pipeline-marketplace

Or install directly from GitHub:

/plugin install guinacio/claude-image-gen

Once installed: - **Core skill** uses the bundled CLI script (no MCP overhead) - **MCP server** is also available for direct tool calls - **Specialized workflows** are not auto-installed; add only the ones you need

> **Tip:** Since the skill runs the CLI directly, you can disable the MCP server in Claude Code's MCP list to reduce startup overhead. The skill will continue to work without it.

---

Quick Install (Claude Desktop Extension)

For Claude Desktop users, install the pre-built extension:

1. Download `media-pipeline.mcpb` from [Releases](https://github.com/guinacio/claude-image-gen/releases) 2. Open Claude Desktop 3. Go to **Settings** → **Extensions** → **Advanced settings** 4. Click **Install Extension** and select the `.mcpb` file 5. Enter your Gemini and/or OpenAI API key when prompted (at least one is required)

---

Manual Installation

For developers who want to customize or build from source:

1. Build the MCP Server

cd mcp-server
npm install
npm run bundle

2. Use the Standalone CLI

cd mcp-server
GEMINI_API_KEY=your-api-key-here node build/cli.bundle.js \
  --prompt "Landing page hero image for a fintech startup" \
  --aspect-ratio "16:9"

The CLI routes to Gemini or OpenAI based on the model name and returns structured JSON on stdout. It does not require the MCP server layer. Any custom output path must still remain inside the configured output directory.

To run the CLI from any folder, install it as a command from the repository root:

npm install -g ./mcp-server
media-pipeline-cli --help

Installing a local folder globally links to it, so later builds of the clone are picked up without reinstalling. The CLI reads its settings from environment variables (see [Configuration](#configuration)), so set at least one API key in your shell or system environment.

3. Add to Claude Code

**Option A: Using MCP server**

claude mcp add --transport stdio media-pipeline \
  --env GEMINI_API_KEY=your-api-key-here \
  -- node /path/to/claude-image-gen/mcp-server/build/bundle.js

The `--` separates Claude CLI flags from the server command.

**Option B: Manual config**

Add to your Claude Code config (`~/.claude.json`):

{
  "mcpServers": {
    "media-pipeline": {
      "command": "node",
      "args": ["/path/to/claude-image-gen/mcp-server/build/bundle.js"],
      "env": {
        "GEMINI_API_KEY": "${GEMINI_API_KEY}",
        "GEMINI_DEFAULT_MODEL": "${GEMINI_DEFAULT_MODEL:-gemini-3-pro-image}",
        "OPENAI_API_KEY": "${OPENAI_API_KEY}",
        "OPENAI_DEFAULT_MODEL": "${OPENAI_DEFAULT_MODEL:-gpt-image-2}",
        "IMAGE_PROVIDER": "${IMAGE_PROVIDER:-gemini}",
        "IMAGE_OUTPUT_DIR": "${IMAGE_OUTPUT_DIR:-~/generated-images}",
        "REQUEST_TIMEOUT_MS": "${REQUEST_TIMEOUT_MS:-60000}",
        "MEDIA_PIPELINE_LOG_LEVEL": "${MEDIA_PIPELINE_LOG_LEVEL:-info}"
      }
    }
  }
}

The `${VAR:-default}` syntax uses environment variables with fallback defaults.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "media-pipeline-marketplace",
  3. "owner": {
  4. "name": "Claude Image Gen"
  5. },
  6. "plugins": [
  7. {
  8. "name": "media-pipeline",
  9. "source": "./",
  10. "description": "Media asset processing plugin with skills for visual content creation.",
  11. "version": "1.3.0",
  12. "author": {
  13. "name": "Claude Image Gen"
  14. }
  15. }
  16. ]
  17. }
README.md · README · 377 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # AI Image Generation - Claude Skill + MCP
  2. AI-powered image generation using Google Gemini or OpenAI (gpt-image-2), integrated with Claude Code.
  3. ## Features
  4. - Generate images from text prompts using Google Gemini or OpenAI (gpt-image-2)
  5. - **Dual-provider support**: model name routes the request automatically (gpt-image* → OpenAI, everything else → Gemini; dall-e* shut down on 2026-05-12)
  6. - Proactive Claude skill suggests images for websites, presentations, and more
  7. - Opt-in specialized workflows for narrower production pipelines, without adding them to every installation
  8. - **Two execution modes**: CLI script (skill-only) or MCP server (protocol-based)
  9. - Configurable aspect ratios (1:1, 16:9, 9:16, etc.)
  10. - Multiple model support (quality vs speed) across both providers
  11. - Optional reference images to guide generation (up to 5, PNG/JPEG/WebP) on both providers
  12. - Inpainting with a PNG mask, plus `background` and `outputFormat` control (including animated GIF and SVG), on OpenAI models
  13. - Images saved to disk within the configured output directory, with file paths returned
  14. - MCP server speaks the MCP 2026-07-28 spec, with backward compatibility for older MCP clients
  15. ## Prerequisites
  16. - Google Gemini API key ([Get one here](https://aistudio.google.com/apikey)) and/or an OpenAI API key ([Get one here](https://platform.openai.com/api-keys)) — at least one is required
  17. - Node.js 20+ (only for manual installation)
  18. ## Installation
  19. ### Quick Install (Claude Code Plugin)
  20. The plugin installs the **core image-generation skill + CLI + MCP server** in one step—no separate configuration needed. Specialized workflows are intentionally opt-in.
  21. ```bash
  22. # Add the marketplace
  23. /plugin marketplace add guinacio/claude-image-gen
  24. # Install the plugin
  25. /plugin install media-pipeline@media-pipeline-marketplace
  26. ```
  27. Or install directly from GitHub:
  28. ```bash
  29. /plugin install guinacio/claude-image-gen
  30. ```
  31. Once installed:
  32. - **Core skill** uses the bundled CLI script (no MCP overhead)
  33. - **MCP server** is also available for direct tool calls
  34. - **Specialized workflows** are not auto-installed; add only the ones you need
  35. > **Tip:** Since the skill runs the CLI directly, you can disable the MCP server in Claude Code's MCP list to reduce startup overhead. The skill will continue to work without it.
  36. ---
  37. ### Quick Install (Claude Desktop Extension)
  38. For Claude Desktop users, install the pre-built extension:
  39. 1. Download `media-pipeline.mcpb` from [Releases](https://github.com/guinacio/claude-image-gen/releases)
  40. 2. Open Claude Desktop
  41. 3. Go to **Settings** → **Extensions** → **Advanced settings**
  42. 4. Click **Install Extension** and select the `.mcpb` file
  43. 5. Enter your Gemini and/or OpenAI API key when prompted (at least one is required)
  44. ---
  45. ### Manual Installation
  46. For developers who want to customize or build from source:
  47. #### 1. Build the MCP Server
  48. ```bash
  49. cd mcp-server
  50. npm install
  51. npm run bundle
  52. ```
  53. #### 2. Use the Standalone CLI
  54. ```bash
  55. cd mcp-server
  56. GEMINI_API_KEY=your-api-key-here node build/cli.bundle.js \
  57. --prompt "Landing page hero image for a fintech startup" \
  58. --aspect-ratio "16:9"
  59. ```
  60. The CLI routes to Gemini or OpenAI based on the model name and returns structured JSON on stdout. It does not require the MCP server layer.
  61. Any custom output path must still remain inside the configured output directory.
  62. To run the CLI from any folder, install it as a command from the repository root:
  63. ```bash
  64. npm install -g ./mcp-server
  65. media-pipeline-cli --help
  66. ```
  67. Installing a local folder globally links to it, so later builds of the clone are picked up without reinstalling. The CLI reads its settings from environment variables (see [Configuration](#configuration)), so set at least one API key in your shell or system environment.
  68. #### 3. Add to Claude Code
  69. **Option A: Using MCP server**
  70. ```bash
  71. claude mcp add --transport stdio media-pipeline \
  72. --env GEMINI_API_KEY=your-api-key-here \
  73. -- node /path/to/claude-image-gen/mcp-server/build/bundle.js
  74. ```
  75. The `--` separates Claude CLI flags from the server command.
  76. **Option B: Manual config**
  77. Add to your Claude Code config (`~/.claude.json`):
  78. ```json
  79. {
  80. "mcpServers": {
  81. "media-pipeline": {
  82. "command": "node",
  83. "args": ["/path/to/claude-image-gen/mcp-server/build/bundle.js"],
  84. "env": {
  85. "GEMINI_API_KEY": "${GEMINI_API_KEY}",
  86. "GEMINI_DEFAULT_MODEL": "${GEMINI_DEFAULT_MODEL:-gemini-3-pro-image}",
  87. "OPENAI_API_KEY": "${OPENAI_API_KEY}",
  88. "OPENAI_DEFAULT_MODEL": "${OPENAI_DEFAULT_MODEL:-gpt-image-2}",
  89. "IMAGE_PROVIDER": "${IMAGE_PROVIDER:-gemini}",
  90. "IMAGE_OUTPUT_DIR": "${IMAGE_OUTPUT_DIR:-~/generated-images}",
  91. "REQUEST_TIMEOUT_MS": "${REQUEST_TIMEOUT_MS:-60000}",
  92. "MEDIA_PIPELINE_LOG_LEVEL": "${MEDIA_PIPELINE_LOG_LEVEL:-info}"
  93. }
  94. }
  95. }
  96. }
  97. ```
  98. The `${VAR:-default}` syntax uses environment variables with fallback defaults.
  99. **Running Claude Code inside the clone:** the repository's own `.mcp.json` is the plugin's server definition, and its path uses `${CLAUDE_PLUGIN_ROOT}`, which is only set when the repository is installed as a plugin. In a session opened in the clone, Claude Code loads it as a project server that takes the place of the `media-pipeline` server configured above, and it fails with `Cannot find module '…${CLAUDE_PLUGIN_ROOT}…bundle.js'`. To keep using your own config there, trust the folder, then disable the project server in `.claude/settings.local.json` (ignored by git; Claude Code reads that file in a trusted folder) and restart Claude Code:
  100. ```json
  101. {
  102. "disabledMcpjsonServers": ["media-pipeline"]
  103. }
  104. ```
  105. #### 4. Install Skill Manually (Optional)
  106. If not using the plugin:
  107. ```bash
  108. cp -r skills/image-generation ~/.claude/skills/
  109. ```
  110. Outside the plugin, the skill runs the `media-pipeline-cli` command, so install the CLI as a command first (step 2).
  111. #### 5. Install a Specialized Workflow (Optional)
  112. Specialized workflows live outside `skills/`, so the plugin does not discover
  113. or install them automatically. The current character-reference workflow is for
  114. dressing Blender character renders and preparing garments for image-to-3D tools.
  115. From a cloned repository:
  116. ```bash
  117. python -m pip install -r optional-workflows/character-reference-sheets/requirements.txt
  118. cp -r optional-workflows/character-reference-sheets ~/.claude/skills/
  119. ```
  120. Built a specialized workflow of your own? See [Contributing a Specialized Workflow](#contributing-a-specialized-workflow).
  121. #### 6. Build Extension from Source (Optional)
  122. To create your own `.mcpb` extension for Claude Desktop:
  123. ```bash
  124. cd mcp-server
  125. npm install -g @anthropic-ai/mcpb
  126. npm run pack:mcpb
  127. ```
  128. This creates `mcp-server/media-pipeline.mcpb` using bundled runtime entry points for both the MCP server and the standalone CLI.
  129. The packed extension is committed to the repo and served from the Releases page, so it must not fall behind source. `pack:mcpb` records a hash of every packed file in `mcp-server/mcpb-contents.json`, and `npm test` recomputes them — change the source without repacking and the suite fails. The archive itself is not byte-reproducible (zip stores timestamps), which is why the inputs are hashed rather than the `.mcpb`.
  130. #### Versioning
  131. `mcp-server/package.json` is the single source of truth for the version. `mcp-server/manifest.json`, `mcp-server/package-lock.json`, `.claude-plugin/plugin.json` and `.claude-plugin/marketplace.json` are all derived from it — never edit their version fields by hand.
  132. To bump:
  133. ```bash
  134. cd mcp-server && npm version minor --no-git-tag-version
  135. ```
  136. `npm version` updates `package.json` and the lockfile, then the `version` lifecycle script propagates it to the remaining manifests and stages them. `npm run sync:version` does the same propagation on its own, and `npm run check:version` reports drift without writing. Both `npm test` and `npm run pack:mcpb` fail on drift, so a release cannot ship with mismatched manifests.
  137. ## Usage
  138. ### Direct Tool Usage
  139. ```
  140. Use create_asset to create a hero image for a tech startup website
  141. ```
  142. ### With the Skill
  143. The skill will proactively suggest image generation when:
  144. - Building websites with hero sections
  145. - Creating presentations
  146. - Working with placeholder images
  147. - Developing marketing materials
  148. ## Configuration
  149. ### Environment Variables
  150. | Variable | Required | Default | Description |
  151. |----------|----------|---------|-------------|
  152. | `GEMINI_API_KEY` | At least one of `GEMINI_API_KEY` / `OPENAI_API_KEY` | - | Your Gemini API key |
  153. | `GEMINI_DEFAULT_MODEL` | No | `gemini-3-pro-image` | Default Gemini model to use |
  154. | `OPENAI_API_KEY` | At least one of `GEMINI_API_KEY` / `OPENAI_API_KEY` | - | Your OpenAI API key |
  155. | `OPENAI_DEFAULT_MODEL` | No | `gpt-image-2` | Default OpenAI model to use |
  156. | `IMAGE_PROVIDER` | No | `gemini` | Provider (`gemini` or `openai`) used when a request omits `model` |
  157. | `IMAGE_OUTPUT_DIR` | No | `~/generated-images` | Where to save images. Left unset, the MCP server writes to `generated-images` in your home directory — not the current directory, since a server launched by Claude Desktop/Code has an unpredictable working directory. Relative paths are resolved against that working directory. `~`, `$HOME`, and `%USERPROFILE%` are expanded. The bundled plugin config (`.mcp.json`) sets `./generated-images` explicitly, and the CLI defaults to the current directory instead (see `--output-dir`) |
  158. | `REQUEST_TIMEOUT_MS` | No | `60000` | Request timeout for both Gemini and OpenAI. `GEMINI_REQUEST_TIMEOUT_MS` is still read when this one is unset. Claude Desktop stops a tool call at 240 seconds; the extension setting is capped there. SVG generation took about 2.5 minutes, so raise this (or the CLI `--timeout-ms`) to `180000` for SVG. Claude Code's own cap is `MCP_TOOL_TIMEOUT` |
  159. | `MEDIA_PIPELINE_LOG_LEVEL` | No | `info` | Stderr logging level |
  160. ### Providers
  161. The server is dual-provider: it routes each request to Google Gemini or OpenAI (`gpt-image-2`) automatically based on the `model` name — models starting with `gpt-image` go to OpenAI, everything else goes to Gemini. `dall-e-2` and `dall-e-3` were shut down on 2026-05-12 and are rejected before a request is sent. When a request omits `model` entirely, `IMAGE_PROVIDER` selects which provider's default model is used.
  162. - **Aspect ratios on OpenAI**: OpenAI image models only support `1024x1024`, `1536x1024`, and `1024x1536`. Requested aspect ratios are mapped to the nearest supported size, and if the mapping isn't exact the response includes a warning describing the substitution.
  163. - **Reference images**: supported on both providers — pass up to 5 reference image paths to guide generation.
  164. - **`size`**: OpenAI models only. An exact `WIDTHxHEIGHT` (or `auto`) that replaces the aspect ratio mapping above. Refused locally unless both sides are multiples of 16, neither edge exceeds 3840, and the ratio is between 1:3 and 3:1. The GIF frame-sheet budget is left to the API.
  165. - **`mask`, `background`, `outputFormat`, `complexity`, `frameCount`, `frameDurationMs`, `svgModel`, `svgReasoningEffort`**: OpenAI models only — Gemini models reject them.
  166. - `mask` takes an absolute path to a PNG whose transparent areas are the region the model repaints; everything else is preserved from the base image. It requires `referenceImages`, and [OpenAI documents](https://developers.openai.com/api/docs/guides/image-generation) the mask as needing an alpha channel and the same dimensions as the base image. Checked locally: the file really is a PNG, it is under the API's 4MB mask limit (masks are capped well below reference images, whose limit here is 20MB), and it is not fully opaque — an opaque mask marks nothing, so it is rejected before the request is sent. Left to the API: the dimension match, and whether a PNG carrying transparency in a `tRNS` chunk instead of an alpha channel is accepted — that case is sent with a warning rather than blocked.
  167. - `background` (`auto`, `transparent`, `opaque`) chooses how the background is handled. `transparent` needs an alpha-capable `outputFormat`, so `png` is selected automatically when `outputFormat` is omitted. `gpt-image-2` rejects `transparent`, and that combination is refused before the request is sent.
  168. - `outputFormat` (`png`, `jpeg`, `webp`, `gif`, `svg`) sets the encoding of the returned image. OpenAI documents transparency for `png` and `webp` only, so the other three are refused alongside `background: "transparent"`.
  169. - `gif` returns an animated GIF. `frameCount` (2–16, OpenAI default 9) and `frameDurationMs` (20–2000 ms, OpenAI default 200) shape it and are refused with any other format; the motion and how it loops go in the prompt. GIF output does not take a `mask`. The frames are laid out on one sheet limited to 3840 px per edge and to the pixel count of 3840x2160, so 16 frames at the default 1024x1024 are refused; `size: "720x720"` worked in testing, and 960x960 did not.
  170. - `svg` returns a vector image. It is generation-only, so it is refused alongside `referenceImages`. The image model creates a reference image and an author model turns it into the SVG; `svgModel` picks that author and `svgReasoningEffort` (`none` through `max`) its effort; both are refused with any other format. On accounts with SVG model selection the API requires `svgModel` — verified with `gpt-image-2.6-sunburst`, which refused SVG without it and produced one with `gpt-5.5` as the author in about 2.5 minutes, so raise `REQUEST_TIMEOUT_MS` to `180000`. Claude Desktop stops the tool call at 240 seconds, which still covers that run. Accounts without SVG model selection must leave both out.
  171. - OpenAI documents both for the `gpt-image-2.6-flare` and `gpt-image-2.6-sunburst` models, and GIF may need preview access on the account.
  172. - `complexity` (`low`, `medium`, `high`) sets how much the model plans the image, separately from rendering quality. The 2.6 models default to `high`.
  173. GIF and SVG output were verified on 2026-11-07 with `gpt-image-2.6-sunburst`. `complexity` and `svgReasoningEffort` were checked by unit tests only. When a model refuses an option that was not refused locally, the API's own reason is returned.
  174. ### Models
  175. Gemini models are fetched dynamically from the Gemini API at runtime; the CLI and MCP tool validate Gemini model choices against the current image-capable model list, and `GEMINI_DEFAULT_MODEL` is used when available. When discovery fails, the built-in fallbacks are `gemini-3-pro-image` and `gemini-3.1-flash-lite-image`. For OpenAI, `gpt-image-2` is the default model (`OPENAI_DEFAULT_MODEL`); any `gpt-image*` model name routes to OpenAI. `dall-e*` names are rejected.
  176. ### Aspect Ratios
  177. | Ratio | Best For |
  178. |-------|----------|
  179. | `1:1` | Social media, thumbnails |
  180. | `16:9` | Hero images, presentations |
  181. | `9:16` | Mobile stories, vertical banners |
  182. | `4:3` | Blog posts, general web |
  183. | `3:2` | Photography-style images |
  184. > On OpenAI models, aspect ratios other than `1:1`/`3:2`/`2:3`-equivalent are mapped to the nearest supported size (see [Providers](#providers)).
  185. ## Prompt Tips
  186. Use this formula for effective prompts:
  187. ```
  188. [Style] [Subject] [Composition] [Context/Atmosphere]
  189. ```
  190. Example:
  191. ```
  192. Minimalist 3D illustration of abstract geometric shapes floating in space,
  193. soft gradient background from deep purple to electric blue, subtle glow effects,
  194. modern professional aesthetic, wide composition for website header
  195. ```
  196. See [skills/image-generation/references/prompt-crafting.md](skills/image-generation/references/prompt-crafting.md) for advanced techniques.
  197. ## Architecture
  198. ### Two Execution Modes
  199. **CLI Mode (Default)** - Used by the skill:
  200. ```
  201. Claude → Skill → Bash → bundled CLI → Gemini API / OpenAI API
  202. ```
  203. - No MCP protocol overhead
  204. - Skill runs bundled CLI directly
  205. - All dependencies bundled in a single file
  206. **MCP Mode (Optional)** - For direct tool calls:
  207. ```
  208. Claude → MCP Tool → bundled MCP server → Gemini API / OpenAI API
  209. ```
  210. - Speaks the MCP 2026-07-28 spec, with backward-compatible fallback for older MCP clients
  211. - Useful for non-skill workflows
  212. - Extension package only needs bundled entry points
  213. ### Abstract MCP Naming
  214. The MCP server uses intentionally abstract naming (`media-pipeline` / `create_asset`) rather than image-specific names (`gemini-image-gen` / `generate_image`).
  215. **Why?** When tool names directly match intent (e.g., "I need to generate an image" → `generate_image`), AI assistants tend to call the MCP tool directly, bypassing the skill layer. By using generic names:
  216. - The **skill** (`image-generation`) becomes the semantically obvious choice for image tasks
  217. - The **MCP tool** doesn't immediately register as the solution
  218. - The skill's prompt optimization and aspect ratio selection are properly utilized
  219. This is a form of prompt engineering for tool selection—making the abstraction layer the natural choice while the underlying implementation has a name that doesn't invite direct use.
  220. ## Project Structure
  221. ```
  222. claude-image-gen/
  223. ├── .claude-plugin/ # Plugin configuration
  224. │ ├── plugin.json # Plugin manifest
  225. │ └── marketplace.json # Marketplace distribution
  226. ├── mcp-server/ # Server and CLI implementation
  227. │ ├── src/
  228. │ │ ├── index.ts # MCP server entry point
  229. │ │ ├── cli.ts # CLI entry point (skill uses this)
  230. │ │ ├── gemini-client.ts
  231. │ │ ├── openai-client.ts
  232. │ │ ├── provider.ts # Routes requests to Gemini or OpenAI by model name
  233. │ │ ├── image-storage.ts
  234. │ │ └── types.ts
  235. │ ├── build/
  236. │ │ ├── bundle.js # Bundled MCP server
  237. │ │ └── cli.bundle.js # Bundled CLI (all deps included)
  238. │ ├── .mcpbignore # Package only the runtime files needed by the bundle
  239. │ ├── manifest.json # MCPB extension manifest
  240. │ ├── icon.png # Extension icon
  241. │ ├── package.json
  242. │ └── tsconfig.json
  243. ├── skills/ # Core skills installed with the plugin
  244. │ └── image-generation/
  245. │ ├── SKILL.md # Skill instructions (uses CLI)
  246. │ └── references/
  247. ├── optional-workflows/ # Specialized skills installed explicitly
  248. │ └── character-reference-sheets/
  249. │ ├── SKILL.md
  250. │ ├── references/
  251. │ ├── requirements.txt
  252. │ └── scripts/
  253. ├── .mcp.json # MCP configuration
  254. └── README.md
  255. ```
  256. ## Contributing a Specialized Workflow
  257. `optional-workflows/` exists for exactly this: workflows that are too specialized to belong in every installation, but general enough that other people would benefit from them. If you have built one, a PR adding it to that folder is welcome.
  258. The bar is that middle ground. `character-reference-sheets` is the reference example — it is narrow (dressing Blender character renders for image-to-3D tools) yet reusable by anyone doing that work. Something tied to your own file layout, employer, or one-off project is probably too specific; something that helps everyone generating images probably belongs in the core `skills/image-generation` skill instead.
  259. What a workflow needs:
  260. ```
  261. optional-workflows/<your-workflow>/
  262. ├── SKILL.md # required: frontmatter with name + description, then the instructions
  263. ├── references/ # optional: deeper documentation the skill points to
  264. ├── scripts/ # optional: helper scripts
  265. └── requirements.txt # optional: only if scripts have dependencies
  266. ```
  267. A few things that make a workflow good rather than merely present:
  268. - **Write a `description` that says when *not* to use it.** Every skill in this repo competes for the same trigger space — `character-reference-sheets` ends its description by deferring website and banner imagery to the core skill. Without that, skills fire over each other.
  269. - **Say what you actually verified.** If a parameter's behaviour is an assumption rather than something you tested against the live API, write that down. The same discipline applies across `mcp-server/` and it is why the tool schemas distinguish verified claims from deferred ones.
  270. - **Respect that generations cost money.** Workflows that generate in a loop, or retry silently, spend the user's API credit without asking.
  271. - **Keep it self-contained.** Reference paths relative to the workflow folder, since users copy the directory to `~/.claude/skills/`.
  272. Adding a workflow does not need a version bump — nothing in `optional-workflows/` ships in the plugin or the `.mcpb`. Open a PR against `master` describing what the workflow is for and what you ran it against.
  273. Bug reports and fixes to the core skill, CLI, or MCP server are equally welcome — those do go through the [versioning](#versioning) flow, and `npm test` must pass.
  274. ## License
  275. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.