ComfyUI Custom Node Skills
Nine skills for Claude Code and Codex: the agent writes custom ComfyUI nodes on the V3 API from source-verified guidance
- 319 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- Markdown instructions only: the skills run nothing themselves and call no external services
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/comfyui-custom-node-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- Markdown instructions only: the skills run nothing themselves and call no external services
This is third-party code. Review the repository files before installing.
What it does
A set of nine skills teaches the agent to write custom ComfyUI nodes. The examples use the V3 API: a node inherits `io.ComfyNode`, defines its schema through `io.Schema`, returns `io.NodeOutput` and registers through `ComfyExtension`. The old V1 is described for migration and compatibility. The skills split the topic into parts. `comfyui-node-basics` covers node structure and registration, `comfyui-node-inputs` widgets and input types (INT, FLOAT, STRING, BOOLEAN, COMBO, hidden, optional and lazy), `comfyui-node-outputs` results, previews and saving files, and `comfyui-node-datatypes` tensors and types such as IMAGE, LATENT, MASK, CONDITIONING, MODEL, CLIP, VAE, AUDIO and VIDEO. `comfyui-node-advanced` covers dynamic inputs, `MatchType`, `Autogrow`, `DynamicCombo`, `GraphBuilder` and async. The remaining three: `comfyui-node-lifecycle` covers caching, input validation and execution order, `comfyui-node-frontend` JavaScript extensions, sidebar tabs and settings, and `comfyui-node-migration` moving nodes from V1 to V3. The ninth, `comfyui-node-packaging`, describes project layout, `pyproject.toml`, `WEB_DIRECTORY` and registry publishing. The guidance is cross-checked against the ComfyUI backend and frontend sources and the documentation.
Who it is for. Developers who write their own ComfyUI nodes and ask Claude Code, Codex or GitHub Copilot to write a node, set up inputs or migrate old code.
Good fit when
- A ComfyUI node with an image input and a FLOAT slider is needed, and the agent has to write it on V3 right away
- A V1 node has to move to V3: map properties, methods and registration
- A node has to show an image preview or save files through `SavedImages`
- An extension needs a sidebar tab, custom widgets or JavaScript dialogs
- A node pack is being prepared for registry publishing: directory layout, `__init__.py`, `pyproject.toml`
Not a fit when
- You need the agent to drive ComfyUI itself, run workflows and generate images: these skills teach writing nodes
- The task is solved with ready nodes and workflows without new code
- The nodes are not written for ComfyUI
- The project is tied to an old API version and no migration to V3 is planned
Example request
Create a ComfyUI node on the V3 API: IMAGE and FLOAT inputs, an IMAGE output, then add a result previewLimitations
- The guidance is tied to the V3 API (`comfy_api/latest/`) as of the verification date: the README lists the backend and frontend commits it was checked against. Newer ComfyUI changes may overtake it.
- The skills run and generate nothing: they only give the agent knowledge of how to write nodes.
- Manual installation in Claude Code means cloning the repository and copying the `comfyui-node-*` folders, and the marketplace route depends on the client.
How to disable. Delete the copied `comfyui-node-*` folders from `~/.claude/skills/`, `~/.agents/skills/` or the project's `.claude/skills/`. The plugin is removed through the client's plugin menu.
FAQ
How do I install the ComfyUI node skills in Claude Code?
Through the client marketplace: add the repository address in Claude Code and the `comfyui-custom-nodes` plugin exposes all nine skills. By hand, clone the repository and copy the `comfyui-node-*` folders from `plugins/comfyui-custom-nodes/skills/` into `~/.claude/skills/`.
How do I install them in Codex?
Run `codex plugin marketplace add jtydhr88/comfyui-custom-node-skills`, then pick the plugin in the list and install it. The same `SKILL.md` files work in Codex without rewriting, and personal skills go into `~/.agents/skills/`.
How does the V3 API differ from V1?
In V3 a node inherits `io.ComfyNode`, the schema comes from `io.Schema`, the result is an `io.NodeOutput` and registration goes through `ComfyExtension`. The `comfyui-node-migration` skill guides the move: it maps properties, methods and registration.
Do the skills run ComfyUI?
No, they give knowledge for writing node code, and they neither run ComfyUI nor generate images. Driving ComfyUI itself from an agent takes other tools.
Which agents are supported?
Claude Code and OpenAI Codex, plus GitHub Copilot through a plugin in Copilot CLI. The `SKILL.md` files follow the open agentskills.io standard, so the same skills install into both agents.
Discussion
No questions or reviews yet.
Related
SkillsNine personal engineering skills: an idea-to-PR chain, standards search, a sandboxed review loop and wizard pages for changes
skills-npm links agent skills shipped in your dependencies in node_modules and listed in the skills field of package.json
15 skills for Claude Code and Codex: Laravel, Docker, UI, debugging, tests and docs in four ready plugin bundles
A skills library for Claude Code, Cursor and Codex: team code review, TDD, stacked PRs and repository readiness scoring
Over 1,100 ready-made skills for Claude Code, Codex, Gemini CLI and Cursor, plus an MCP server that picks a skill for the task
A set of skills from real work: npm supply-chain audit, CLI building, Obsidian plugin release and an AGENTS.md hierarchy
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| ComfyUI Custom Node Skills (this card) | no | 319 | ||
| ComfyUI-Agent-Kit | no | 121 | a skill and MCP driver that control a local ComfyUI, while these skills teach writing custom nodes | |
| ComfyUI MCP Server | no | not required | 413 | an MCP server through which an agent generates images in ComfyUI, while this is knowledge for node development |
README in short
The README lists the nine skills with triggers, then covers installation in Claude Code, Codex and GitHub Copilot, example requests and features: V3 first, a V1 reference, source verification, frontend extensions. It ends with the sources and verification commits.
README badge
Original SKILL.md
---
name: comfyui-node-basics
description: ComfyUI custom node fundamentals - V3 node structure, Schema, inputs/outputs, registration. Use when creating new ComfyUI custom nodes, defining node classes, or setting up a custom node project.
---
# ComfyUI Custom Node Basics (V3 API)
ComfyUI uses Python classes to define nodes. The **V3 API** is the current recommended approach. Nodes inherit from `io.ComfyNode` and define a schema + execute method.
## Quick Start
```python
from comfy_api.latest import ComfyExtension, io
class MyNode(io.ComfyNode):
@classmethod
def define_schema(cls):
return io.Schema(
node_id="MyNode",
display_name="My Custom Node",
category="my_category",
inputs=[
io.Image.Input("image"),
io.Float.Input("strength", default=1.0, min=0.0, max=1.0, step=0.01),
],
outputs=[
io.Image.Output("IMAGE"),
],
)
@classmethod
def execute(cls, image, strength):
result = image * strength
return io.NodeOutput(result)
```
## V3 Node Class Structure
Every V3 node requires:
1. **Inherit from `io.ComfyNode`**
2. **`define_schema(cls)`** - classmethod returning `io.Schema`
3. **`execute(cls, ...)`** - classmethod performing the computation
```python