Limitations of text-to-CAD: Architectural Constraints and Skill Boundaries in earthtojake/text-to-cad

The text-to-CAD framework restricts validation to measurable geometric facts, implements only subsets of the SRDF and SDF specifications, and performs static G-code analysis without physics simulation, creating explicit boundaries that developers must work around when generating CAD models and robot descriptions.

The earthtojake/text-to-cad repository provides a modular skill-based architecture for converting natural language prompts into CAD geometry, robot descriptions, and manufacturing code. While the system supports diverse output formats including URDF, SRDF, SDF, and G-code, understanding the limitations of text-to-CAD is critical for production use, as each skill module contains documented constraints regarding validation depth, format coverage, and runtime verification capabilities.

CAD Skill Limitations: Geometry Validation and Inspection Boundaries

The CAD skill performs validation limited to facts that can be extracted directly from the model geometry, such as dimensions, units, bounding-box calculations, and entity counts. According to skills/cad/references/inspection-and-validation.md, the system does not perform full-scale manufacturability checks, clearance analysis, or physics simulation.

The implementation exposes two specific technical constraints. First, the --plane-limit flag caps the number of planes examined during inspection, potentially missing features in complex models. Second, topology enumeration is restricted to debugging scenarios or situations where features cannot be verified through simple measurements, rather than serving as a primary validation mechanism.

# Demonstrates fact-only validation limitation

npx skills run cad "Create a rectangular block with 0.5 mm wall thickness"

# Output shows dimensions and volume but cannot validate manufacturability

URDF Skill Limitations: Unit Constraints and Runtime Validation Gaps

The URDF skill enforces strict unit requirements that limit input flexibility. As documented in skills/urdf/references/validation.md, joint limits must be expressed exclusively in radians for revolute joints and meters for prismatic joints. Continuous joints must not receive artificial finite limits, and the system lacks runtime structural validation beyond generation-time checks for link connectivity and duplicate names.

# Demonstrates unit conversion requirement

npx skills run urdf "Add a revolute joint with limits 0-180 degrees"

# Generator converts degrees to radians; direct degree input is rejected

SRDF Skill Limitations: Incomplete MoveIt 2 Specification Support

The SRDF skill implements only a subset of the full MoveIt 2 SRDF specification, creating significant gaps in robot configuration support. According to skills/srdf/references/implementation-notes.md, the current implementation lacks support for:

• Virtual joint parsing and passive-joint handling
• Chain base/tip failure detection and subgroup-cycle detection
• Typed helper generators and self-collision matrix generation
• Full MoveIt configuration package generation
• Robust subprocess execution for external validation tools

# Demonstrates missing virtual joint support

npx skills run srdf "Add a virtual joint for a gripper"

# Runtime ignores virtual joints and emits a warning per implementation notes

SDF Skill Limitations: Partial Physics Validation

The SDF runtime validates only a limited set of fields including axis values, limits, and basic dynamics, without enforcing all physical constraints. The skills/sdf/references/implementation-notes.md file explicitly documents "Remaining limitations" where the validator accepts values that may not represent physically plausible configurations, particularly regarding complex damping and friction models.

# Demonstrates limited dynamics validation

npx skills run sdf "Create a ground plane with friction 0.5"

# Accepts friction value without validating against full physics constraints

G-code Skill Limitations: Static Slicer Analysis

The G-code skill relies on static slicer checks that cannot simulate physical manufacturing realities. As stated in skills/gcode/references/gcode-validation.md, the system checks mesh manifoldness and basic motion bounds but does not simulate extrusion physics, firmware state, acceleration limits, or slicer-specific semantics. While motion bounds can be supplied per-axis, the slicer enforces these only when generating start and end moves, not throughout the entire toolpath.

# Demonstrates static validation limitation

npx skills run gcode "Slice mesh cube.stl for Prusa MK3"

# Validates mesh integrity but cannot simulate nozzle pressure or acceleration

SendCutSend and Implicit CAD Constraints

The SendCutSend skill generates inspection reports that are fact-only, meaning they list parseability, units, and bounding-box data but never emit a final "pass/fail" verdict. According to skills/sendcutsend/SKILL.md, geometry-specific limits such as bend-line flange lengths are enforced only when the service provides explicit specifications; otherwise, they are reported as unresolved limitations.

The Implicit CAD skill remains experimental, relying on GLSL signed-distance fields and ray-marching rendering that may fail to cover all constructive solid geometry use-cases, particularly complex Boolean combinations that produce rendering artifacts.

# Demonstrates fact-only reporting

npx skills run sendcutsend "Inspect part.stp"

# Outputs dimensional facts without readiness determination

# Demonstrates experimental implicit CAD limitations  

npx skills run implicit-cad "Render torus using signed-distance fields"

# Works for primitives but fails on complex Boolean operations

Repository-Level Architectural Limitations

Beyond individual skills, the repository architecture imposes workflow constraints documented in README.md. Heavy binary assets including GIFs and LFS-tracked CAD files are stored separately, meaning lightweight clones do not fetch them unless explicitly requested. Additionally, the development workflow uses a symlinked layout where editing the wrong copy of a generated file produces no effect, risking confusion during development.

Summary

• CAD validation is restricted to measurable facts and excludes manufacturability analysis, with plane limits constraining inspection scope.
• URDF processing requires radians and meters for joint limits and lacks continuous joint finite limit support, validating only at generation time.
• SRDF support is incomplete, missing virtual joints, passive joints, collision matrix generation, and full MoveIt package creation.
• SDF validation covers only basic dynamics, leaving gaps in physics constraint enforcement.
• G-code verification performs static checks without physics simulation, ignoring acceleration limits and extrusion dynamics.
• SendCutSend provides dimensional reporting without pass/fail verdicts, while Implicit CAD remains experimental with rendering limitations.
• Repository workflow requires careful handling of LFS assets and symlinked file structures to avoid editing errors.

Frequently Asked Questions

Does text-to-CAD perform manufacturability checks on generated geometry?

No. According to skills/cad/references/inspection-and-validation.md, the system validates only measurable facts such as dimensions, units, and bounding boxes. It does not perform clearance analysis, wall-thickness validation, or other manufacturability assessments required for production readiness.

Why can't I use degrees directly for URDF joint limits in text-to-CAD?

The URDF skill enforces strict unit standards as documented in skills/urdf/references/validation.md. Revolute joints must use radians and prismatic joints must use meters. While the generator will convert degree inputs to radians during processing, direct degree specifications are rejected to maintain compatibility with the URDF specification.

What SRDF features are missing from the current implementation?

The implementation lacks virtual joint parsing, passive joint handling, chain base and tip failure detection, subgroup cycle detection, typed helper generators, self-collision matrix generation, and robust subprocess execution for external tools. These gaps are explicitly listed in skills/srdf/references/implementation-notes.md.

How does text-to-CAD validate G-code before sending it to a printer?

The G-code skill performs static validation only, checking mesh manifoldness and basic motion bounds as documented in skills/gcode/references/gcode-validation.md. It does not simulate extrusion physics, firmware state, acceleration limits, or slicer-specific semantics, meaning generated code requires external validation before physical production.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}