What does this skill do, and when should you use it?
One of 13 skills bundled in the earthtojake/text-to-cad repository, this skill focuses on writing, editing, and validating MoveIt SRDF files. Its thirteen-step workflow derives planning groups, end effectors, group states, and disabled collisions from the paired URDF's topology rather than visual guessing. A built-in cadgen validator cross-checks the SRDF against the same-folder URDF with the matching robot name, including chain resolvability, joint-limit units, and the truthfulness of disabled-collision reasons. It also supports visual review through the CAD Viewer and PNG snapshots of the paired URDF's geometry.
- Reads the same-folder URDF whose robot name matches, extracts its link/joint table, and copies every name from that table only
- Authors and edits .srdf XML: planning groups (chain groups preferred), virtual/passive joints, end effectors, group states, disabled collision pairs
- Runs cadgen srdf validate to cross-check name existence, chain paths, state limits, end-effector topology, and collision-pair reasons against the URDF
- Runs cadgen snapshot to render the paired URDF's geometry as PNG, with --joint-values and --display render posing options
- Shows models via the local CAD Viewer (cadgen viewer) or the host's cad_show tool when available
- Maintains a planning ledger as a comment block inside the .srdf and reports assumptions and skipped checks
- ROS 2 / MoveIt users who have a valid URDF and need planning groups and semantics on top
- Manipulator integrators defining chain groups and default group states (radians/meters) for serial arms
- Engineers who need an evidence-based disabled-collision matrix from URDF adjacency or Setup Assistant sampling, not invented lists
- Teams auditing existing .srdf files for name, limit, and chain consistency with their URDF
- Dual-arm or gripper-equipped robots needing end-effector groups that don't overlap their parent groups
- Anyone hoping to put geometry, inertials, or ros2_control interfaces in SRDF — the skill explicitly forbids that (structure belongs to URDF, simulation to SDF)
- Projects without a usable URDF — the skill requires a valid URDF first, colocated with a matching robot name
- Teams without any MoveIt environment — file-level validation and rendering still can't prove planning correctness
How do you install this skill?
- First run downloads pinned cadgen from PyPI plus a headless-browser snapshot; this may be unreachable or slow from mainland-China networks, with no offline or mirror fallback.
- cadgen telemetry is on by default (random ID, no file contents); disable with `cadgen telemetry off` or environment variables before first run if data-sensitive.
- The CAD Viewer is an unauthenticated loopback server; any local process can read files under the opened directory — never bind a non-loopback host.
- On Windows 11 with Smart App Control enabled, cadgen fails importing the unsigned OCP module; disable it or use WSL.
- The SRDF validator cannot prove planning semantics (task intent, TCP choice, collision safety); record assumptions in the ledger and smoke-test in MoveIt when possible.
- Publisher is unverified by the FollowSkills registry; this is a static source review with no code executed.
- Shell / CLI
- Network access
- Local filesystem
uvcadgen 0.7.20 (pinned via uvx)Python 3.13 (managed by uv)a paired URDF with matching robot nameGit LFS meshes must be checked out for snapshots
This skill ships as part of the 13-skill text-to-cad collection, installed via the Skills CLI or per-agent plugins:
Claude Code
claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-to-cad@earthtojakeCursor / Grok Build
git clone --depth 1 --branch latest https://github.com/earthtojake/text-to-cad ~/.cursor/plugins/local/text-to-cadGemini
gemini extensions install https://github.com/earthtojake/text-to-cad --ref latest --consent --auto-updateOther agents (Skills CLI)
npx skills add earthtojake/text-to-cad#latestPrerequisites: uv must be installed; on Windows 11, Smart App Control blocks OpenCascade's unsigned OCP module, so disable it or run under WSL.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Create an SRDF for my_arm.urdf: a chain planning group from base to tool, a home group state, and an end effector, then validate it with cadgen srdf validate
- Check that robot.srdf and robot.urdf are correctly paired and list the stated reason behind every disabled collision pair
- Define separate planning groups for a dual-arm robot's left and right arms plus gripper end effectors, and render a snapshot for me
- My SRDF group states use degrees — convert them to URDF-native units (radians/meters) and revalidate
The skill triggers on SRDF-related requests (its description covers creating, editing, inspecting, and validating .srdf files). Standard flow: obtain a valid URDF via the URDF skill; extract the URDF link/joint table; record the planning task with the planning-ledger reference; save the .srdf beside the .urdf (colocation plus matching robot name is the only pairing mechanism); then define groups, end effectors, states, and collision pairs step by step. Validate every file:
cadgen srdf validate path/to/robot.srdf
cadgen srdf validate path/to/robot.srdf --strict
cadgen srdf validate path/to/robot.srdf --Visual review:
cadgen viewer --host 127.0.0.1 -- --detach
cadgen snapshot path/to/robot.srdf review.pngSnapshots accept --joint-values ({joint: degrees} JSON) and --display render for a photographic scene; run git lfs checkout on the mesh directory first or unhydrated LFS pointers fail loading. Commands run through uvx pinned to cadgen==0.7.20 / Python 3.13.
What are this skill's strengths and limitations?
- Forces deriving names from the URDF topology instead of typing them from memory — directly targets the weak spatial reasoning of language models
- The cadgen validator performs real cross-file checks: chain resolvability, limit units, end-effector topology, and truthfulness of collision-pair reasons
- Simple, explicit pairing mechanism (same folder + same robot name) with no hidden metadata
- Supports local visual review and snapshots while honestly stating that rendering cannot prove planning correctness
- Hard dependency on a pinned cadgen 0.7.20 via uv, with a first-run download of the runtime and browser snapshot
- Requires a valid paired URDF in the same folder — cannot be used standalone
- Validation is file-level only; without a MoveIt environment, planning correctness stays unproven
- cad_show / cad_view / cad_screenshot tools depend on host support; plain setups fall back to the browser Viewer
- The repo README describes the whole collection, so this skill's own capabilities must be confirmed in skills/srdf/SKILL.md
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| SRDF Skill: MoveIt Planning Semantics this page | 62 · Recommended | ★ 19k | 1d ago | MIT |
| URDF Robot Description Skill | 57 · Use with care | ★ 19k | 1d ago | MIT |
| text-to-cad SDF Skill | 55 · Use with care | ★ 19k | 1d ago | MIT |
| I4H Workflow Environment Creator ✓ NVIDIA · Official | 50 · Use with care | ★ 3.5k | 3d ago | Apache-2.0 |
| Isaac for Healthcare Dataset Replay ✓ NVIDIA · Official | 48 · Use with care | ★ 3.5k | 3d ago | Apache-2.0 |
The repository defines a clear division of labor: the URDF skill owns physical structure (links, joints, geometry, inertials), the SDF skill owns simulator descriptions (physics, sensors, worlds), and this skill owns only MoveIt planning semantics. Use all three along the format boundary rather than interchangeably.
How did FollowSkills review this skill?
The skill performs only local file reads/writes and validation, with no destructive defaults; it relies on the external cadgen tool (pinned at 0.7.20 via uvx/PyPI), which introduces third-party code execution. Repo telemetry is on by default (disclosed, with opt-out), and the viewer is an unauthenticated loopback server whose trust boundary is explicitly disclosed in SECURITY.md. Deductions: the pinned cadgen binary cannot be statically audited, telemetry default-on, and the unauthenticated viewer are mitigated by disclosure rather than mechanism.
Documentation is highly self-consistent: the two-phase validator, error codes, nonzero exit, and failure messages (missing/ambiguous/not-a-tree paired URDF) are described in detail, and the skill states what validation cannot prove. Deduction: nothing was executed and no committed tests covering the srdf key path were read; capped at 10 per calibration.
Scenarios are clear (MoveIt2 SRDF authoring/validation/review), trigger description is specific, boundaries are explicit (no structure, geometry, or physical limits), and it correctly states visual review cannot prove planning correctness. Deductions: English only; core operation depends on uvx downloads from PyPI plus a snapshot browser download, with questionable mainland-China reachability and no offline/mirror fallback.
Well-layered docs (SKILL.md plus six references with progressive disclosure), naming contract, golden skeleton, known limitations, pairing mechanism, MIT license, provenance link, and cadgen doctor for doc drift. Deductions: no per-skill version or changelog, maintenance rests on an individual repo, publisher unverified.
The core path is complete: URDF table extraction → ledger → direct XML → cadgen srdf validate → snapshot review, addressing the common failure of near-miss names without shifting debugging cost to the user. Deduction: static review cannot verify outputs are directly usable in MoveIt; capped at 7.
Validator behavior is stated as checkable error codes and checklists; the repo shows a test workflow badge and model test fixtures. Deduction: no committed tests or third-party execution evidence covering the srdf key path were read; capped at 5 statically.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →