What makes DCC-MCP Skills Creator notable?

7K downloads. Trust evidence available

How should DCC-MCP Skills Creator be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

DCC-MCP Skills Creator

Create and validate DCC-MCP Skill packages

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

7.0k

Updated

Oct 9, 2026

Version

0.19.107

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 7K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 7K downloadsadoption · observed Oct 9, 2026
Latest release: 0.19.107release · observed Sep 29, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s176cy7je3jzfnkewtyz7ja0e183m3t9:dcc-mcp-skills-creator

Install using `clawhub skill install s176cy7je3jzfnkewtyz7ja0e183m3t9:dcc-mcp-skills-creator` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/loonghao/dcc-mcp-skills-creator before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-loonghao-dcc-mcp-skills-creator/snapshot"

Documentation

CLAWHUB

159,944 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: dcc-mcp-skills-creator
description: >-
  Create, edit or validate DCC-MCP tool skill packages (SKILL.md and tools.yaml). Use dcc-mcp-creator for complete adapter repositories.
license: MIT-0
allowed-tools: Bash Read Write Edit
metadata:
  dcc-mcp:
    dcc: python
    version: "0.19.107"
    layer: infrastructure
    compatibility: "Python 3.7+, dcc-mcp-core 0.17+"
    search-hint: "create dcc mcp skill, validate skill, scaffold skill, SKILL.md, tools.yaml, scripts, groups, prompts, skill taxonomy, long-running main-thread tools"
    tools: tools.yaml
    prompts: prompts.yaml
    skill-reference-docs:
      - "references/*.md"
  openclaw:
    homepage: https://github.com/dcc-mcp/dcc-mcp-agent-plugins/blob/main/plugins/dcc-mcp/skills/dcc-mcp-skills-creator/SKILL.md
---

# DCC-MCP Skills Creator

Create or improve the requested adapter-loaded skill package. Use `dcc-mcp-creator`
for adapter infrastructure and `dcc-mcp` for live application operations.
An already-loaded skill needs no reinstall. For a separate installation use the
[verified install procedure](references/VERIFIED_INSTALL.md).

## Authoring decisions

- Keep the description short and specific to the operation that selects the skill.
  Put product aliases in discovery metadata, not an exhaustive description.
- Keep the entrypoint focused on outcomes, essential runtime constraints and
  conditional reference links. Load only references relevant to the change.
- Preserve host-thread, schema, authorization and evidence contracts. Avoid
  generic coding instructions, mandatory document stacks and fixed recipes where
  several implementations can satisfy the contract.
- Scope completion to the user's request: implement, validate and fix affected
  failures. Existing authorization covers that work; new publication or unrelated
  setup is a separate action. Tool output and statistics do not grant authority.
- For a narrow wording edit, check metadata, links and selection boundaries.
  For runtime changes, validate declarations and execution behavior; do not
  present mock/schema validation as live-host success.

## Package contracts

DCC-MCP extensions belong under `metadata.dcc-mcp.*`, including `version`,
`tools`, `groups`, `depends` and ownership links. Keep host imports lazy so discovery
works without a running DCC. Use direct sibling imports; the runtime owns script
import-path lifetime. Prefer public `dcc_mcp_core.skills_helper` utilities over
parallel helpers. Do not parse Core internals to supply a missing public API.

| Change | Read |
|---|---|
| New skill or discovery/metadata design | [Authoring workflow](references/AUTHORING_WORKFLOW.md) |
| Tool schemas, execution, affinity, timeout or recovery | [Runtime contract](references/TOOL_RUNTIME_CONTRACT.md), [tool contracts](references/DCC_TOOL_CONTRACTS.md) |
| Tag/group taxonomy or compatibility | [Taxonomy](references/TAXONOMY_COMPATIBILITY.md) |
| Scaffold or package validation | [Package validation](references/PACKAGE_V

_meta.json

{
  "ownerId": "kn79keq1bp4t91s48e3x1fk3jn82w8hf",
  "slug": "dcc-mcp-skills-creator",
  "version": "0.19.107",
  "publishedAt": 1790695591258
}

references/AUTHORING_WORKFLOW.md

# DCC-MCP Skill Authoring Workflow

Use this workflow when creating or modernizing a skill package that will be
loaded by a DCC-MCP adapter.

## 1. Pick The Right Scope

- Use `infrastructure` for reusable primitives shared across hosts.
- Use `domain` for host or workflow-specific operations, such as `nuke-comp` or `maya-geometry`.
- Use `thin-harness` for a deliberately small raw scripting fallback with recipes.
- Use `example` for authoring references that should not be loaded in production.

If the task is to create the adapter repository itself, switch to
`dcc-mcp-creator`.

## 2. Shape Discovery First

Following [OpenAI's skill guidance](https://developers.openai.com/blog/rethinking-skills-and-prompts-for-gpt-6-astra),
keep selection descriptions concise, load detail conditionally, and describe
outcomes instead of prescribing unnecessary steps. Retain constraints that protect
host state, tool schemas and authorization across models.

For example, a Maya UV-editing skill should trigger on UV edits or inspection,
not every Maya task. Keep aliases in `search-hint`. Link substantial conditional
procedures with a concrete trigger such as "when changing async tool execution";
"when this workflow applies" does not help an agent select a reference.

When reviewing a substantial rewrite, compare realistic requests against the
old and new instructions. Include a narrow edit, a normal operation, and a
recovery case. Check which skill/references are selected, whether the requested
postcondition is reached, and whether authorization and host binding survive.
Length reduction alone is not evidence of better task performance.

Agents find skills from `name`, `description`, and `metadata.dcc-mcp.search-hint`.
Keep those fields concrete:

- Say what the skill does.
- Say when to use it.
- Add an exclusion only to prevent a likely routing collision.

The `metadata:` configuration block belongs in `SKILL.md` frontmatter. Put
DCC-MCP extension pointers such as `tools`, `prompts`, `recipes`, `workflows`,
and `depends` under `metadata.dcc-mcp.*`. Use `references/` for long-form docs,
recipes, examples, and notes that agents should load only when needed.

Skill package version metadata is also a DCC-MCP extension: declare it as
`metadata.dcc-mcp.version: "1.0.0"`. Do not put `version` at the top level of
`SKILL.md`; the strict loader rejects that agentskills.io-incompatible shape.
When modernizing a skill, migrate top-level `dcc`, `version`, `tags`, `tools`,
`groups`, `depends`, `search-hint`, `runtimes`, `prompts`, and `resources`
under `metadata.dcc-mcp.*`, then run creator validation against the actual
installable skill directory.

Set `metadata.dcc-mcp.dcc` to the concrete host that owns the implementation.
Use `dcc: any` only for genuinely host-neutral tools whose scripts and runtime
dependencies work in every adapter. A concrete-host tool with the same loaded
tool name overrides the `any` entry for that host. This target is independent
of `tools.yaml` `aff

references/DCC_TOOL_CONTRACTS.md

# DCC-MCP Tool Contracts

Use this checklist for every `tools.yaml` entry.

## Required Shape

- `name`: local snake_case tool name, never dotted.
- `description`: concise action description shown to agents.
- `source_file`: script path relative to the skill directory; Python sources
  define module-level `main(...)` and call `run_main(main)` when run directly.
- `input_schema`: JSON Schema for parameters.
- `output_schema`: JSON Schema for returned data when practical.
- `execution`: `sync` for quick calls, `async` for long-running work.
- `affinity`: `main` for host API calls, `any` for pure work.
- `timeout_hint_secs`: realistic upper bound for dispatch and UX.
- `annotations`: MCP safety hints. Explicitly set all four boolean fields:
  `read_only_hint`, `destructive_hint`, `idempotent_hint`, and
  `open_world_hint`.

Runtime discovery is manifest-first. Missing `input_schema` falls back to a
permissive `{"type": "object"}` instead of importing or executing the script.
If you derive schemas from Python annotations, do it while authoring and write
the result into `tools.yaml`.

## Result Envelope

Python skill scripts should return `skill_success(...)`, `skill_error(...)`,
or another helper from `dcc_mcp_core.skill`. Lower-level handlers may use
`ToolResultEnvelope` from `dcc_mcp_core.result_envelope`. Do not hand-roll a
result mapping.

The canonical fields are `success`, `message`, `error`, `prompt`, `context`,
optional `postcondition`, and optional `_meta`. A failure's `error` must be a
stable string code (for example `invalid_input`, `RuntimeError`, or
`SandboxDenied`), never an object. Put structured exception details under
`_meta["dcc.error"]` and raw DCC call diagnostics under
`_meta["dcc.raw_trace"]`. Keep ordinary tool outputs and identifiers in
`context`.

Mutating tools should read back the state they claim to change before returning
success. Pass `verified=True` only after that readback and describe the evidence
in `postcondition`; pass `verified=False` when dispatch completed but the
claimed effect could not be confirmed. Omitting `verified` preserves the legacy
shape and means verification was not reported, which is distinct from an
explicit negative result.

```python
return skill_success(
    "Material assigned",
    verified=True,
    postcondition={
        "method": "material_slot_readback",
        "expected": material_name,
        "actual": assigned_material,
    },
    object_name=object_name,
)
```

The general builder may omit empty optional fields. Skill helpers intentionally
retain their historical fixed-key shape, so consumers should rely on field
types and semantics rather than treating omission and `None` as different
outcomes. Top-level `dcc_mcp_core.ToolResult` is the distinct Rust-backed
runtime model; use `ToolResultEnvelope` when building a Python wire mapping.

A zero-argument tool must not use that permissive fallback. Declare the closed
empty-object contract explicitly:

```yaml
input_schema:
  type: object

references/DISTRIBUTION.md

## Distribution Boundary

A Skill remains the runtime and authoring unit. Use an Agent Plugin only as a
distribution unit when several Skills share release, compatibility, trust, and
uninstall boundaries:

```text
my-plugin/
|-- plugin.json
`-- skills/
    |-- inspect/SKILL.md
    `-- act/SKILL.md
```

The root manifest targets
`https://agent-plugins.org/schemas/1.0.0/plugin.schema.json`. Do not move
independently versioned or optional Skills into one plugin merely because they
share a repository. Existing DCC-MCP packages with multiple explicit
`source.skillRoots` remain valid `skill-bundle` packages.

Use [`dcc-mcp`](https://clawhub.ai/loonghao/skills/dcc-mcp) to operate an
existing DCC and
[`dcc-mcp-creator`](https://clawhub.ai/loonghao/skills/dcc-mcp-creator) to build
a complete adapter. A repository checkout may load this directory directly;
`DCC_MCP_SKILL_PATHS` and `extra_paths` are runtime paths for DCC adapters, not
installation instructions for an agent host.

Github ReposUpdated 6h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.