What does this skill do, and when should you use it?
engineering-drawing is one of the 13 skills bundled in earthtojake/text-to-cad. It takes a part you have already modelled — a STEP file written by a @step model or a live build123d shape — and produces a shop-ready engineering drawing as a single PDF. Under the hood it runs cadgen 0.7.20 through uv, projecting views from the part's geometry, measuring dimensions between points on that geometry, finding centre marks, and laying everything out on an ISO sheet with a frame and title block. Nothing on the sheet is drawn by hand and no number is typed unless you choose to override it: change the model, rerun the script, and the views and measured values move with it. There is no CLI and no DXF output — the script is the interface, and the PDF is the deliverable.
- Reads a STEP artifact (e.g. produced by a @step model script) or a live build123d shape via cadgen.read_step() as the drawing subject.
- Places third-angle views with sheet.three_views() — top, front, right (plus an isometric in the free corner with iso=True), or custom layouts with sheet.view() on A3/A4 ISO sheets.
- Dimensions what a maker needs in model coordinates: overall size (view.overall()), feature positions and sizes (view.dim with tol= or fit=), hole callouts (view.hole: thru, depth, counterbore, countersink, thread), and leadered notes (view.note).
- Prints layered line work at distinct weights — VISIBLE, HIDDEN (dashed), CENTER marks, DIM, NOTES, TITLE, SHEET frame — from 0.5 mm down to 0.18 mm.
- Renders an ISO sheet with a title block (part number, material, scale, units, projection, revision, SHEET n OF m), numbered notes, an optional revision table, and deterministic PDF bytes (no creation timestamp).
- Reports problems it noticed while drawing (e.g. 'measures blank paper', 'annotation overlaps') and raises on invalid arguments instead of writing a wrong document.
- A mechanical engineer working in Claude Code who has just modelled a part and needs a dimensioned sheet to hand to a machine shop, without manually detailing it in CAD software.
- Teams with frequent design iteration: after a model change, rerunning the drawing script updates views, hidden lines and measured values automatically, with no risk of stale hand-edited dimensions.
- An indie maker or small studio that needs standards-flavoured output: ISO sheet, title block and revision table are generated, and identical rebuilds produce byte-identical PDFs for versioning.
- Anyone who asks their agent for 'a drawing', 'a dimensioned sheet', 'shop drawings' or '2D views of this part' — the SKILL.md description triggers the read-model/write-script/render-PDF flow.
- A manufacturing handoff that must state tolerances explicitly: only tol=, fit= and general_tolerance= values you write appear on the sheet; none are invented.
- Users needing sections, detail views or auxiliary views — SKILL.md states these are not supported yet, and the handoff should say what a view does not show.
- Users who need DXF cut layouts or flat patterns — this skill deliberately writes no DXF (that is the sibling DXF skill's job, for toolpaths, not documents).
- Users unwilling to install uv/a Python runtime or wanting a GUI or CLI — there is no CLI (the script is the interface), and Windows 11 Smart App Control blocks the unsigned OCP kernel wheel, breaking every cadgen command.
How do you install this skill?
- Static review only; no scripts were executed — output quality and failure behaviour are unverified by execution.
- First run downloads cadgen==0.7.20 and dependencies (matplotlib etc.) from PyPI; mainland-China reachability unverified; no Chinese-language documentation.
- cadgen sends telemetry by default (no file contents); disable with `uvx cadgen telemetry off` or DO_NOT_TRACK=1 after install.
- Annotation is not checked against line work — read the PDF manually; tolerances must come from the user and are never invented by the skill.
- On Windows 11 with Smart App Control enabled, the unsigned OCP native module is blocked and cadgen fails; disable it or run under WSL.
- Shell / CLI
- Network access
- Local filesystem
uvcadgen 0.7.20 (installed via uvx, Python 3.13)matplotlib (rendering backend)
This skill ships inside the text-to-cad collection (13 skills); install the collection and use the engineering-drawing skill. Claude Code (plugin):
claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-tocadd@earthtojakeInstall from #latest (the release branch), then restart the app — the first start downloads the CAD runtime and needs a network connection. Cursor (local plugin):
git clone --depth 1 --branch latest https://github.com/earthtojake/text-to-cad ~/.cursor/plugins/local/text-to-cadThen restart Cursor. Grok Build:
grok plugin install earthtojake/text-to-cad@latest --trust
grok plugin enable text-to-cadGemini (extension):
gemini extensions install https://github.com/earthtojake/text-to-cad --ref latest --consent --auto-updateOther agents (skills only, no CAD server):
npx skills add earthtojake/text-to-cad#latestPrerequisite for every route: uv must be installed (uv --version). The skill runs cadgen 0.7.20 through uvx with a pinned command. Install either the plugin or the skills in an app, not both. Note: the Claude Code commands above are as documented in the README — double-check the exact marketplace string against the README before running.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Make an engineering drawing of this part as a PDF on A3 landscape, third angle, with all holes called out
- I changed the flange's hole pitch — regenerate the shop drawing with centre marks and thru callouts on every hole
- Give me 2D views of this bracket with overall size and wall thickness dimensioned at ±0.1
- Produce a formal drawing of this STEP file with a title block, revision table, and a 'BREAK EDGES' note
The skill is triggered by requests like 'a drawing', 'a dimensioned sheet', 'shop or manufacturing drawings', 'a print', or '2D views of this part'. Workflow: 1) Build the part first — run python <model>.py so the @step model writes a STEP artifact, then read it with cadgen.read_step(); a live build123d shape works equally well. 2) Write <name>_drawing.py beside the model using the template at references/sheet-api.md#template, importing dimension-referenced facts (hole pitch, overall size, wall) from the model module rather than retyping them. 3) Lay out views with sheet.three_views(part, iso=True) — it returns four views (third-angle top/front/right plus an isometric); positions use sheet millimetres from the bottom-left (A3 is 420×297, A4 is 297×210). 4) Dimension in model coordinates: view.overall(), view.dim (with tol= or fit= where required), view.hole, view.note — leave text unset so values are measured. 5) Run:
python <name>_drawing.pyIt prints the PDF path plus anything it noticed — read 'measures blank paper' (check the part's bounding box; usually a corner-built part assumed centred) and 'annotation overlaps' (raise three_views(gap=) or pass offset=) first. 6) Open the PDF and fix collisions: dimension text over views, missing hidden lines or centre marks, leaders crossing the part — move at= or offset= and rerun. When running unattended, set MPLCONFIGDIR to a writable directory so matplotlib's font cache does not warn. The full cadgen command is the pinned uvx form: uvx --no-config --managed-python --python 3.13 --from cadgen==0.7.20 cadgen.
What are this skill's strengths and limitations?
- Views, hidden lines, centre marks and dimensions are all projected and measured from the part's geometry — change the model, rerun, and the drawing follows; nothing goes stale.
- Deterministic output: no creation timestamp is stamped, so an unchanged drawing rebuilds to a byte-identical PDF, which suits versioning and review.
- Fails loudly: invalid arguments, views off the frame, or a missing renderer raise instead of writing a wrong or missing document.
- Strict argument validation with specific refusals — unknown view names/sheet sizes/projections, malformed tolerances, notes wider than the sheet, bare strings for notes=/revisions= all error with reasons.
- No sections, details or auxiliary views yet — complex parts may not be fully expressible.
- No CLI and no DXF output; the script is the only interface, which limits toolchain integration.
- The sheet keeps callouts clear of views it knows about and reports overlapping annotations, but it does not check annotation against line work — you must read the PDF yourself.
- Tolerances are never invented: without your tol=/fit=/general_tolerance=, dimensions are nominal — unsuitable if the user cannot supply tolerance values.
- The whole text-to-cad collection sends anonymous usage stats and crash reports by default; turn them off with `uvx cadgen telemetry off`.
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 |
|---|---|---|---|---|
| Engineering Drawing (Text-to-CAD) this page | 59 · Recommended | ★ 19k | 1d ago | MIT |
| DXF Generation & Validation Skill | 57 · Use with care | ★ 19k | 1d ago | MIT |
| SendCutSend Upload Preflight | 57 · Use with care | ★ 19k | 1d ago | MIT |
| Desktop Commander MCP | 65 · Recommended | ★ 10k | 4d ago | MIT |
| G-code Slicing Skill (text-to-cad) | 60 · Recommended | ★ 19k | 1d ago | MIT |
Within the same repository, the DXF skill produces 2D DXF cut layouts and flat patterns (toolpaths), while this skill produces document-grade engineering-drawing PDFs — SKILL.md states explicitly that the two are different jobs. Pick by deliverable.
How did FollowSkills review this skill?
Purely local document-generation workflow: reads STEP geometry, renders a PDF via script; no DXF, no network side effects, no credential handling; version pinned via uvx to cadgen==0.7.20, giving visible supply chain. README transparently discloses default telemetry and opt-out (shared install with this skill); SECURITY.md documents loopback-only viewer binding. Deducted for: no explicit user-confirmation mechanism, isolation or rollback notes; telemetry on by default (though opt-out exists); unverified publisher with attribution being just a repo link.
High internal consistency: template, API reference, failure modes ('measures blank paper', 'annotation overlaps', off-frame views raise naming a fitting scale, missing renderer fails without leaving a file), and a detailed list of refused invalid inputs. But static review cannot execute key paths; a CI badge (test.yml) exists, yet no committed tests covering this skill's drawing paths were shown, so capped at 10 per anchor.
Clear triggers ('drawing', 'dimensioned sheet', '2D views of this part') and explicit non-fit boundaries: no sections, details or auxiliary views, no DXF, tolerances must come from the user and never be invented. Deducted for: dependence on first-run uv/PyPI downloads and matplotlib etc., with unverified mainland-China reachability; no Chinese-language support.
Good layered docs (workflow → API reference → limits), clear MIT license, provenance pointing to the repo, pinned cadgen 0.7.20, and an update path (uvx cache, plugin update) in the README. Deducted for: no per-skill changelog/version history; dependency evolution lives in an external PyPI package; known-limitation handling partly relies on the user 'reading the PDF'.
Claims a directly shop-usable single PDF output that is deterministic (no timestamp, identical rebuild bytes) with clear marginal value over manual drafting. Static review cannot verify output quality and no representative sample outputs are present in the source files, so held at the static cap of 7, kept conservative for missing sample evidence.
Key claims trace to in-repo source files and pinned version parameters; README offers third-party signals (PyPI/CI badges). However, no committed tests or independent reproduction evidence for this skill's key paths (view projection, annotation rendering); fact/inference separation is mostly clean but coverage is thin — scored 4 under the cap of 5.
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 →