Source confidence: medium
See also: Deeper Dive — Scan, Fit, Print — agents that design parts around real objects →

Scan, Fit, Print — agents that design parts around real objects

Insight class: Emergent Capability · Difficulty: Medium · Quality: 4/5 Connected entries: 9 · Tools: After Effects, Blender, Claude, FFmpeg, Hugging Face, Moonshine, Orbiter, Python, Raspberry Pi, Raspberry Pi 5

In short: Open-source scanners (a smartphone Orbiter rig, a Raspberry Pi handheld LiDAR, LingBot-Map's video-to-3D) now produce a usable mesh of the thing you need to fit. LLMs already write Blender Python, and they can build a CLI for any app that has no MCP.

Key fact Detail
What it covers 3D, design, hardware, open source
Tools After Effects, Blender, Claude, FFmpeg, Hugging Face
Posts covered 9 posts (1 S-tier, 5 A-tier) · top: Gemma Translator — offline speech translation… · Claude Opus 5.5 to Blender — 3D animation… · Build-your-own CLI for agents — control apps…
Creators @aiproductlabs, @catlabs, @itsnicconley
Sources dated Mar 2026 – Oct 2026
Difficulty Medium
Prompt system Run-it-yourself prompts
Last verified 2026-10-22

Thesis

Open-source scanners (a smartphone Orbiter rig, a Raspberry Pi handheld LiDAR, LingBot-Map's video-to-3D) now produce a usable mesh of the thing you need to fit. LLMs already write Blender Python, and they can build a CLI for any app that has no MCP. Point the agent at the scan, have it write parametric CAD that references the scanned surfaces, and you get a custom-fit part on the first print. That is the step generative 3D can't do yet.

Why it matters

Makers, repair people and small product designers spend most of their CAD time measuring and re-printing. Tolerance-aware agent CAD collapses the loop from 'calipers, sketch, print, fail, repeat' into 'scan, describe, print'. Y-Pan and Gemma Translator show that whole working devices ship as STL plus a bill of materials.

The evidence — connected entries

Orbiter — open-source smartphone 3D scanner for print-ready parts

Creator: @rawmechatronics · Tier: A Tools: Orbiter

Capture: open smartphone scanning rig explicitly aimed at print-that-fits-first-time

Orbiter is an open-source rig and workflow from Raw Mechatronics for accurate 3D digitization with a smartphone camera. Scan an object, design around it and print a part that fits the first time.

View original post

Peppa Cam — DIY Raspberry Pi handheld LiDAR scanner

Creator: @peppes_ghost · Tier: B Tools: Raspberry Pi

Capture at room scale: DIY Pi LiDAR with open formats

A homemade handheld LiDAR scanner from a Raspberry Pi, a LiDAR sensor and a 3D-printed housing, mapping buildings, caves, gardens and trees without proprietary software. Build plan with wiring, code and CAD is comment-gated.

View original post

LingBot-Map — Autoregressive 3D world understanding in real — Open-source GitHub project by Ant Group’s Robbyant tea...

Creator: @aiproductlabs · Tier: B

Capture without hardware: LingBot-Map real-time 3D from plain video

LingBot-Map — Autoregressive 3D world understanding in real time — @aiproductlabs.

View original post

Claude Opus 5.5 to Blender — 3D animation built entirely as code

Creator: @nateherkai · Tier: A Tools: After Effects, Blender, Claude, FFmpeg, Python

Proof LLMs emit working Blender Python end-to-end, not just prompts

Claude Opus 5.5 wrote everything: a web mock of the After Effects UI, a Python script that builds the Blender scene, the character animation, plus the music and sound effects. Blender rendered 360 frames on GPU in about 15 minutes and FFmpeg stitched the video. Full prompt is comment-gated.

View original post

Build-your-own CLI for agents — control apps that lack an MCP

Creator: @catlabs · Tier: A

'Build yourself a CLI for X' — how the agent drives FreeCAD/slicers lacking MCP

When a program has no MCP server or the MCP misses controls you need, tell the agent 'Build yourself a CLI tool to interact with [program]', even down to every button of a DAW. MCP stays best for auth, discovery and distribution; a custom CLI wins for bespoke complex workflows and uses fewer tokens. Expect security flags.

View original post

Hugging Face — ️ FREECAD — github.com/FreeCAD/FreeCAD

Creator: @jg.engineers · Tier: A Tools: Hugging Face

FreeCAD as the open parametric backend

🔧 4 GitHub repos to explore instead of scrolling ↓↓ — @jg.engineers; uses Hugging Face.

View original post

Powerful websites you should know (part 962) generate a complete CAD mod...

Creator: @setupsai · Tier: B

Text-to-CAD sites: the dimension-blind baseline to beat

Powerful websites you should know (part 962) generate a complete CAD model with text #cad #3dmodel #3dmodelling — @setupsai.

View original post

Y-Pan — 3D-printed panoramic 35mm camera instead of a $5k XPan

Creator: @plumsojuyang · Tier: A

Output proof: printed mechanisms good enough for a working film camera (~$100 vs $5k)

A maker designed the Y-Pan, a 3D-printed panoramic film camera reproducing the Hasselblad XPan's wide 35mm format. Everything except the lens is printed, parts cost about $100, it builds in about a week, and the CAD files and bill of materials are on the creator's site.

View original post

Gemma Translator — offline speech translation on a Raspberry Pi 5

Creator: @itsnicconley · Tier: S Tools: Moonshine, Raspberry Pi 5

Output proof: a whole device shipped as code + BOM + printable STL

Google open-sourced Gemma Translator: Moonshine for speech recognition, Gemma for translation and a TTS model for voice, all on a Raspberry Pi 5 with no network at ~7 tokens/sec, enough for live Spanish–Mandarin conversation. Repo includes code, parts list (battery, touchscreen, speaker, micro keyboard with language knob), deployment script and printable STL case.

View original post

Action sketch — how to implement this

Scan three awkward real objects (a tool handle, a bike mount point, a phone in its case) with the Orbiter workflow or photogrammetry; export clean meshes. Have Claude Code write a CadQuery/FreeCAD script that imports the mesh, fits planes/cylinders to the contact surfaces, and builds a mount with a stated clearance (e.g. 0.3 mm); prompt it to build its own CLI for the slicer. Print, test fit, feed caliper measurements back as corrections; log iterations-to-fit for agent vs your hand CAD. Falsifier: if agent CAD needs more print iterations than your own hand CAD on 3 of 3 objects, the scan-to-parametric step isn't ready — the fitting step, not the scanner, is the bottleneck.

Prerequisites

Key tools and resources

Creators to follow

Prompt system — run this yourself

Everything below is pasteable into Claude Code, Claude, or any agent. Use the one-shot when you want the whole result in one run; use the step prompts when you want to steer. Every step carries its own audit, and the gap audit at the end makes the agent find and fill what it missed.

Mission. Produces a scan-to-parametric-CAD pipeline in which a coding agent takes a mesh of a real object (from the Orbiter smartphone rig, photogrammetry, or a Raspberry Pi LiDAR handheld), fits geometric primitives to the contact surfaces, writes a CadQuery script for a mount with a stated clearance, slices it through a CLI the agent builds itself, and logs iterations-to-fit against the maker's own hand CAD on three objects. Done means three printed parts with caliper-verified fit, a measured scan error budget, and a falsifier verdict on whether agent CAD needs fewer print iterations than hand CAD.

1 · Deeper, not bigger

Before running anything, make the task deeper rather than larger. Ask: what would a top professional do here that I am not asking for; what is the rawest material; which methods and tools; what, other than the model or me, proves it right. Then ask for exactly that.

Rewritten prompt — ask for exactly that:

Act as a mechanical design engineer building a scan-to-fit pipeline. Before any scanning, design and slice a clearance coupon (pegs and holes at 0.1, 0.2, 0.3, 0.4 and 0.5 mm clearance, 10 mm long) for my printer and filament, and tell me which clearance to adopt from my caliper readings. Then, for each of three objects (a tool handle, a bike mount point, a phone in its case), give a capture protocol for the Orbiter rig or a phone photo set with a ChArUco board for scale, processed in COLMAP or Meshroom. Write a Python script with Open3D and pyransac3d that cleans the mesh, fits planes and cylinders to the contact surfaces I mark, and reports residual RMS per surface. Validate the scan against three caliper measurements per object and stop if error exceeds 0.3 mm. Write a CadQuery script per object that builds a mount referencing the fitted primitives, with named parameters for clearance, wall thickness and fastener holes, exporting STEP and STL. Build yourself a CLI tool around PrusaSlicer that takes STL, orientation and profile and returns G-code plus estimated time and material. After each print I will give you caliper readings and a fit verdict; update parameters and log iterations-to-fit. In parallel I will hand-CAD the same three parts. Report iterations per object for both methods and say whether agent CAD lost on all three.

2 · One-shot prompt

ROLE AND STANCE
You are a mechanical design engineer and automation developer. Goal: prove or disprove that an agent can turn a scan of a real object into a parametric part that fits on the first or second print. Source claims to test: Orbiter promises 'a perfect fit on the first try' from a smartphone scan; Peppa Cam says a Pi LiDAR handheld is fine 'for most scanning jobs'; a Claude-to-Blender demo built a whole scene as Python; the 'build yourself a CLI tool' pattern lets an agent control any program without an MCP; text-to-CAD sites claim complete CAD models from a sentence.

CONTEXT
- Scanners: Orbiter (smartphone rig), photogrammetry via COLMAP or Meshroom, Peppa Cam Raspberry Pi LiDAR, LingBot-Map video-to-3D.
- Geometry: Open3D, trimesh, pyransac3d, CloudCompare.
- CAD: CadQuery or build123d (Python), FreeCAD fallback, Blender Python only for visualization.
- Slicing: PrusaSlicer or OrcaSlicer CLI.
- Hardware: the user's FDM printer, calipers, a ChArUco board printed at known scale.

HARD CONSTRAINTS
1. Every dimension in the CAD is a named parameter traceable to a fitted primitive or a caliper reading.
2. The scan is not trusted until three caliper checks per object agree within 0.3 mm.
3. Clearance is chosen from a printed coupon on this printer and filament, not assumed.
4. Write the go/no-go fit criterion per object before printing it.
5. The hand-CAD control is done by the user without seeing the agent's CAD.

DELIVERABLES IN ORDER
1. coupon.py (CadQuery), coupon.stl and the recommended clearance after the user's measurements.
2. capture_protocol.md for each object and scanner.
3. fit_primitives.py: clean mesh, segment marked contact regions, fit planes and cylinders, report residual RMS and the fitted parameters as JSON.
4. scan_check.md: caliper vs scan for three features per object; CloudCompare deviation vs a reference object.
5. One CadQuery script per object with STEP and STL output and a parameter table.
6. slicecli: an agent-built command-line wrapper around PrusaSlicer with orientation, profile and support flags, returning G-code path, time and grams.
7. fit_log.csv: object, method (agent or hand), iteration, parameters changed, caliper readings, fit verdict.
8. report.md with iterations-to-fit per object and method and the falsifier verdict.

BUILT-IN GAP ANALYSIS
Before finishing, list in GAPS: surfaces where primitive fitting failed (organic shapes like a tool handle grip); scale uncertainty; printer drift between iterations; any object where the hand CAD and agent CAD used different clearances; claims you could not test (for example LingBot-Map accuracy if not run). Fill gaps you can, such as re-fitting with a different primitive or adding a freeform offset surface from the mesh, and record the result.

SELF-QUESTIONS
- Which surfaces actually bear the load or locate the part, and did I fit only those?
- Is the scan scaled from a known reference, or is photogrammetry scale arbitrary?
- Is my clearance compensating for printer error that a slicer setting (horizontal expansion, elephant-foot compensation) should fix instead?
- Does print orientation change the fit dimension more than my clearance?
- For organic shapes, should the part be a mesh offset instead of primitives?

STOP CONDITIONS
Stop and report if scan error exceeds 0.3 mm after two capture attempts, or if after three iterations an object still fails fit; record which error source dominated.

RETURN FORMAT
A table of iterations-to-fit by object and method, falsifier verdict, file list, GAPS, and self-question answers.

3 · Step-by-step prompts

Step 1 — Ground truth: printer coupon and scanner accuracy

Goal: Measure what this printer and scanner can actually hold before designing anything.

Write coupon.py in CadQuery: a plate with pegs and matching holes at 0.1, 0.2, 0.3, 0.4 and 0.5 mm diametral clearance, 10 mm diameter and 10 mm deep, labeled by embossed numbers, plus a 25 mm calibration cube. Export STL and give PrusaSlicer settings to print it in the same orientation and material planned for the parts. Ask the user for caliper readings of every peg, hole and cube face, and for which pegs slide, press, or do not fit. From those readings compute the printer's dimensional bias and choose the slip-fit and press-fit clearances. Then have the user scan the calibration cube and one machined reference (or a gauge block) with each scanner they have, Orbiter rig or phone photogrammetry with a ChArUco board in frame, and compute scan scale error and CloudCompare deviation against nominal.

Expect: coupon.stl, a clearance recommendation with measured bias, and a scanner accuracy table in mm.

Audit before moving on: Fail if clearance is recommended without user caliper data or if scan scale is not anchored to a known reference. If scan error exceeds 0.3 mm, change capture settings before step 2.

Step 2 — Capture and clean three object scans

Goal: Produce clean, scaled meshes of a tool handle, a bike mount point and a phone in its case.

Write capture_protocol.md for each object: lighting, matte spray or chalk on shiny surfaces, ChArUco board placement, number and spacing of photos (for photogrammetry 60 to 120 images with 70% overlap), turntable or Orbiter settings, and for the bike mount a handheld protocol since it cannot move. After the user captures, process in COLMAP or Meshroom, then write clean_mesh.py with Open3D: statistical outlier removal, Poisson reconstruction or keep the original mesh, hole filling, scale from the board, and alignment so the main contact plane lies on XY. Export each as PLY and STL with a metadata JSON listing source images, scale factor and vertex count. Ask the user for three caliper measurements per object on features visible in the scan. If a Peppa Cam LiDAR scan exists, process it too.

Expect: Three clean meshes, metadata files, and a table comparing three caliper readings per object to scan measurements.

Audit before moving on: Fail any object whose caliper-to-scan difference exceeds 0.3 mm on any check; recapture with more images or matte spray. Note the error in the GAPS list.

Step 3 — Fit primitives to contact surfaces

Goal: Turn noisy mesh regions into exact planes, cylinders and offsets the CAD can reference.

Write fit_primitives.py. Inputs: a cleaned mesh and a JSON of contact regions the user marks (vertex indices selected in Blender or MeshLab, or bounding boxes). For each region, fit a plane with Open3D segment_plane, a cylinder with pyransac3d or least squares, or a sphere, choosing by lowest residual RMS. Output primitives.json: type, parameters (normal and offset, axis and radius), residual RMS, inlier fraction. For regions with RMS above 0.2 mm (likely organic, like a grip), output an offset surface instead: the mesh region offset outward by the chosen clearance, exported as a separate STL the CAD can subtract. Render a quick check image in Blender headless showing primitives overlaid on the mesh. Print a summary table of every region with type, RMS and inlier fraction so the user can veto a fit before CAD.

Expect: primitives.json per object, optional offset STLs for organic regions, and an overlay image.

Audit before moving on: Fail if any primitive has inlier fraction under 0.8. Check fitted cylinder radii against caliper diameters within 0.15 mm; if not, refit with tighter region selection.

Step 4 — Parametric CAD and an agent-built slicer CLI

Goal: Generate printable, parametric mounts and slice them from the command line.

For each object write a CadQuery script that loads primitives.json and builds the part around the fitted surfaces: contact faces offset by the chosen clearance, wall thickness 2.4 mm minimum, fillets on stress corners, fastener holes or strap slots, and boolean subtraction of any offset STL. All dimensions are named parameters at the top of the file with comments citing their source (primitive ID, caliper reading, coupon). Export STEP and STL. Then build yourself a CLI tool, slicecli, around PrusaSlicer: arguments for STL path, printer profile, filament, orientation (rotation in degrees), supports on or off, and output path; it returns G-code path, estimated time and grams, and fails loudly on slicer errors. Write the go/no-go fit criterion for each part before slicing.

Expect: Three CadQuery scripts, STEP and STL files, slicecli with help text, sliced G-code, and written fit criteria.

Audit before moving on: Re-import each STL in trimesh and check it is watertight and the clearance gap measured between part and mesh equals the parameter within 0.05 mm. Fail any part needing supports inside the contact surfaces.

Step 5 — Print, measure, iterate, and run the hand-CAD control

Goal: Log iterations-to-fit for agent CAD versus hand CAD on the same objects.

After each print, ask the user for caliper readings on every named contact dimension and a fit verdict against the written criterion. Compute the error per parameter and update only the parameters with measured error, logging iteration, changed parameter, old and new value, and reason in fit_log.csv. Maximum three iterations per object. In parallel the user designs the same three parts by hand in their usual CAD tool, without seeing the agent's files, and logs their own iterations in the same CSV with method set to hand. If an object fails three times, classify the dominant error source: scan, fitting, CAD logic, or printer. For comparison, also generate one of the parts from a text-to-CAD website prompt and log whether it fits at all.

Expect: fit_log.csv with every iteration for both methods and a short error-source note per failed object.

Audit before moving on: Fail if any parameter change is not justified by a measurement. Check the hand control used the same printer, filament and clearance coupon.

Step 6 — Validate against oracles and write the gap report

Goal: Deliver the falsifier verdict and list what is unproven.

Write report.md: per object, iterations-to-fit for agent and hand methods, final caliper error per contact dimension, scan accuracy, primitive residuals, and print time and material. State the falsifier: if agent CAD needed more iterations than hand CAD on all three objects, the scan-to-parametric step is not ready and the fitting step, not the scanner, is the bottleneck; say which error source dominated. Then a GAPS section: each source claim (perfect fit first try, Pi LiDAR good for most jobs, LLMs write Blender and CAD scripts, build-your-own CLI, text-to-CAD) marked verified, unverified or false with the fit_log row or measurement that decides it; objects or scanners not tested; and anything from LingBot-Map not run. Package the three parts as a release folder with STEP, STL, parameter table and bill of materials, the way Y-Pan and Gemma Translator ship.

Expect: report.md, GAPS list, and a release folder per part.

Audit before moving on: Recompute iteration counts from fit_log.csv with a fresh script. Fail if any claim is marked verified without a cited measurement.

4 · Gap analysis and audit

Run this after the build. It makes the agent enumerate its own claims, mark what is verified, rank the gaps and fix the top ones.

You are an independent reviewer of a scan-to-fit pipeline. Open the coupon results, capture protocols, meshes and metadata, primitives.json files, CadQuery scripts, slicecli, fit_log.csv and report.md. List every claim in report.md. For each, mark verified (cite the measurement, file or log row), unverified (say what measurement would prove it), or false. Check specifically: scale was anchored to a known reference; caliper-to-scan checks exist for every object; clearance came from the coupon on the same printer and filament; every CAD parameter cites a source; parameter changes between iterations cite a measurement; the hand-CAD control used the same constraints and was done blind; the falsifier comparison used the same fit criterion for both methods. List missing pieces such as untested scanners or organic regions forced into primitives. Rank problems by whether they could reverse the agent-versus-hand verdict, fix the top three now (for example by refitting a region or recomputing iteration counts), and report before and after. End with what needs another print or scan to resolve.

Questions the agent must ask itself before it says done:

5 · What proves it right

6 · Failure modes

7 · Agent direction (unattended runs)

Begin with the clearance coupon; it is cheap and makes every later number meaningful. Use Python throughout (CadQuery, Open3D, trimesh, pyransac3d) and call Blender headless only for overlay renders. Cache every mesh, primitives.json and STL with a version suffix per iteration so fits can be compared. Spawn a sub-agent to build slicecli in parallel with step 3, and review it by passing a bad profile name and confirming it fails. Physical steps (printing, scanning, caliper readings, hand CAD) belong to the user: write precise instructions, then pause and wait for measurements rather than inventing them. Never fabricate caliper data or fit verdicts. Stop and ask when a scan fails accuracy twice or when the user's printer or filament changes mid-study. Return report.md as the entry point with coupon files, capture protocols, meshes, primitives.json, CadQuery scripts, slicecli, fit_log.csv and a release folder per part.

Prompt system updated 2026-10-22 · all prompt systems · JSON

Browse more deep dives at DejaViewed — 846 entries across the full catalog.

Generated 2026-10-22 · curated by @6ab3 for DejaViewed