Create CNC Cut Files with Claude

Turn a furniture reference into SVG and DXF quote drafts for a CNC-cut table.

Introduction

30 Second Summary

Furniture inspiration often starts with a photo. A real workshop needs more than the photo before it can price the parts.

In this project, you will use Claude Desktop to turn a furniture reference into a quote-ready fabrication packet for a four-part plywood table. The packet gives a local CNC shop enough context to review the geometry before fabrication.

What You'll Build

Rotate your table on screen before handing a local shop one packet for review.

By the end of this project, you'll have:

A rotatable table preview that lets you compare the simplified silhouette with your reference image.
Full-scale SVG plus DXF quote drafts that you can download after confirming every part stays inside one 48 x 96 inch sheet.
A shop-ready quote request supported by a parts list plus a three-picture assembly guide. It asks the shop to confirm the remaining manufacturing inputs.
Secret Mission: Generate a three-slot coupon that lets the shop compare tight, target, and loose fits before cutting the full table.

Are there any prerequisites?

You need a Mac with Claude Desktop plus the Claude Code CLI already installed.

Bring a reference image of a simple table with its target dimensions.

Before We Start

A useful CNC cut file starts with a table shape that can be described as a small set of flat parts. A complicated reference makes every later design decision harder to verify.

This step narrows your idea to one top, two slab legs, plus one cross brace. You will leave with one reference plus three target dimensions in millimetres.

In this step, get ready to:

Choose a table reference that reduces to four flat parts.
Record its overall width, depth, and height in millimetres.
Confirm that the shape can use flat plywood parts with slot joints.

Check the four-part structure

A suitable reference has a single top, two slab legs, plus one cross brace. Each major piece can be cut from flat plywood.

Return to your reference photo or drawing from earlier.
Trace the tabletop visually as one continuous flat panel.
Identify the first slab leg beneath the top.
Identify the second slab leg beneath the top.
Identify one cross brace joining the legs.
Select the reference if all four planned parts are easy to distinguish.

Record the overall dimensions

Overall dimensions define the outside boundary of your finished table. Using one unit keeps every later drawing consistent.

Record your target left-to-right width here: target width in millimetres.
Record your target front-to-back depth here: target depth in millimetres.
Record your target floor-to-top height here: target height in millimetres.

Confirm the design boundary

This check separates a promising reference from one you can describe clearly as flat parts with fitted joints. The four-part boundary keeps the project focused.

Before you check, do you expect every major piece in your reference to map cleanly to one of the four planned parts?

Point to the single tabletop in your reference.
Point to each of the two slab legs.
Point to the cross brace joining the legs.
Confirm that the four parts could fit together with slot joints.

Strong start. Your reference now has a clear four-part construction plan.

Your width, depth, and height should also be recorded in millimetres.

Your table idea now has a defined shape plus a measurable target. Next up, you will prepare the fabrication workspace that keeps the reference and generated files together.

Set Up the Fabrication Workspace

Your table reference can only guide consistent geometry when its files live in one controlled workspace. A scattered setup makes it easy for Claude to use the wrong image.

In this step, you will create a local workspace in Claude Desktop. You will confirm that the Claude Code CLI can work before you generate any geometry.

In this step, get ready to:

Start a Local session in Manual permission mode.
Prepare a project folder containing the reference image.
Verify the Claude Code installation and diagnostics.

Start a Local session

A Local session gives Claude access to a folder on your Mac. Manual permission mode lets you review proposed file changes before accepting them.

Press Cmd+Space to open the macOS search bar.
Type Claude Desktop into the search bar.
Press Enter to open Claude Desktop.
Select the Code tab.
Start a Local session.
Set the permission mode to Manual.

You will see an active Local session with Manual selected. This confirms that you remain in control of file changes.

Prepare the project folder

The project folder keeps the source image beside every generated file. Claude can then use one consistent location throughout the workflow.

Open the Terminal pane in the Local session.
Create ~/Documents/claude-cnc-table and move the terminal into it by running these commands:

mkdir -p ~/Documents/claude-cnc-table
cd ~/Documents/claude-cnc-table

What do these commands do?

The mkdir command creates the claude-cnc-table folder inside Documents.
The -p flag prevents a failure if the folder already exists.
The cd command moves the terminal into the new folder.

Select ~/Documents/claude-cnc-table as the project folder for your Local session.

The selected folder now gives Claude a clear boundary for this project.

Press Cmd+Space to return to the macOS search bar.
Type Finder into the search bar.
Press Enter to open Finder.
Navigate to the location containing your furniture reference image.
Select the furniture reference image.
Press Cmd+C to copy the image.
Open ~/Documents/claude-cnc-table in Finder.
Press Cmd+V to paste the image into the folder.

Good progress. Your visual source now lives beside every file Claude creates.

Return to the Claude Desktop Local session from earlier.
Click the + button beside the prompt.
Select the copied reference image from ~/Documents/claude-cnc-table.
Confirm that the image filename or thumbnail appears beside the prompt.

Can't find the folder or image?

Check that claude-cnc-table appears inside your Mac's Documents folder.
Return to Finder to confirm that the copied image appears inside claude-cnc-table.
Use the + button again after confirming the image location.

Ask for help with the workspace path.

Verify Claude Code

The version check confirms that the CLI responds. The diagnostic check examines the installation without changing it.

Before you run the checks, do you expect both commands to finish without a blocking installation error?

Verify the Claude Code version and installation diagnostics by running these commands:

claude --version
claude doctor

What do these checks confirm?

The --version check prints the installed Claude Code version.
The doctor check prints read-only installation and settings diagnostics.

A healthy setup prints a Claude Code version first. The diagnostics then finish without a blocking installation error.

✔️ Both checks completed

You're ready. Claude Code is responding inside the selected project workspace.

ⓧ claude --version is not found

The native installer restores the missing Claude Code command. You will reopen the Terminal pane afterward so the new installation is available.

Install Claude Code by running this command:

curl -fsSL https://claude.ai/install.sh | bash

What does this command do?

The command downloads Anthropic's native installer with curl. It passes the installer to bash so Claude Code can be installed on your Mac.

Close the current Terminal pane after the installer finishes.
Open a new Terminal pane in the same Local session.
Repeat the Claude Code checks by running:

claude --version
claude doctor

What should you see now?

The first command prints the installed Claude Code version. The second command prints diagnostics without a blocking installation error.

Still seeing an installation problem?

Confirm that you opened a new Terminal pane after the installer completed.
Run both checks again from the selected Local session.
Review the diagnostic report for the installation item that still needs attention.

Help me understand the remaining Claude Code diagnostic issue.

✔️ Awesome, I've got everything

Your Local session uses Manual permission mode. Your selected project folder contains the attached reference image.

ⓧ I'd like to double check the full code

This step creates no application code. Compare your workspace with this exact checkpoint.

Confirm that Claude Desktop shows an active Local session.
Confirm that the permission mode is Manual.
Confirm that ~/Documents/claude-cnc-table is selected as the project folder.
Confirm that the folder contains your copied furniture reference image.
Confirm that the reference image appears beside the Claude prompt.
Confirm that the Terminal pane shows a Claude Code version and diagnostics without a blocking installation error.

Strong start: your selected workspace now holds the reference image with Claude Code verified. Next, you will turn that source into a rotatable table preview.

Create the Rotatable Table Preview

Your workspace now holds the reference image. The next risk is spending time on vector geometry before the table's silhouette feels right.

A rotatable baby version lets you judge the overall shape while changes are cheap. In this step, Claude Desktop turns your reference into a four-part table preview.

In this step, get ready to:

Supply Claude with your reference image plus target dimensions.
Generate the shared design data for your table.
Review the rotatable preview through one silhouette adjustment.

Generate the first preview

The design-data.js file becomes the single source of dimensions for the project. The preview.html file reads that model to draw the table in your browser.

Click the + button beside the Claude prompt.
Select the furniture reference image inside ~/Documents/claude-cnc-table.
Confirm that the image thumbnail appears beside the prompt.
Ask Claude to generate the design model plus preview by pasting this prompt:

Study the attached table photo before writing files. Adapt its silhouette into a simple side table or coffee table with overall dimensions [[WIDTH="your target width in mm"]] x [[DEPTH="your target depth in mm"]] x [[HEIGHT="your target height in mm"]] mm.

Use flat plywood parts only: one top, two slab legs, and one cross brace. Prefer slot joints and no screws. Avoid any claim that the design is structurally certified.

Treat 18 mm as a nominal design assumption. Keep measured sheet thickness unresolved. Create design-data.js as the single source of dimensions. Create preview.html as a dependency-free, rotatable browser preview.

Start from the supplied project code. Replace the overall dimensions with mine. Adjust only the silhouette-related values. Preserve the supplied design object and every existing TABLE_MODEL helper name.

Do not create cut files yet. Label the result as a quote draft. Open preview.html in the Browser pane.

How does the preview stay consistent?

The design object holds the table's shared parameters.
The overall values set the target table envelope.
The material block preserves the nominal 18 mm assumption. Manufacturing values remain null.
The shape values control the visible proportions.
The window.TABLE_MODEL object exposes the geometry helpers to each browser file.

Review Claude's proposed changes for design-data.js plus preview.html.
Approve both file changes in the Manual permission mode from earlier.
Approve Claude's request to show preview.html in the Browser pane.

You should see a tabletop above two slab legs. A cross brace should connect the legs.

Your first visual checkpoint is live. You can now judge the table before creating manufacturing geometry.

Preview missing or incomplete?

Confirm that the reference image thumbnail is still attached to the Claude prompt.
Confirm that ~/Documents/claude-cnc-table remains the selected workspace.
Ask Claude to reopen preview.html in the Browser pane.

Help me diagnose my missing table preview.

Refine the silhouette

One focused change keeps cause and effect visible. The overall dimensions stay fixed while one silhouette value moves.

Compare the current preview against your reference image.
Choose one silhouette adjustment that makes the preview closer to the reference.
Ask Claude to apply that single adjustment by pasting this prompt:

Compare the current browser preview with the attached reference image.

Keep one top, two slab legs, and one cross brace. Make only this silhouette adjustment: [[SILHOUETTE_CHANGE="increase the leg inset to 120 mm"]].

Update only the relevant silhouette-related values in design-data.js. Keep the overall dimensions unchanged. Preserve the existing four-part construction. Reopen preview.html in the Browser pane after the edit.

Which values shape the silhouette?

The legInsetMm value moves the slab legs toward or away from the table ends.
The legEdgeInsetMm value changes the visible width of each slab leg.
The braceCenterHeightMm value raises or lowers the cross brace.
The four-part requirement keeps the design inside this project's fabrication scope.

Review Claude's proposed change to design-data.js.
Approve the focused file change in the Manual permission mode from earlier.
Return to the refreshed Browser pane.

You should see only the requested silhouette difference. The four visible parts remain in place.

Did too much change?

Ask Claude to restore the previous overall values.
Ask Claude to preserve exactly one top with two slab legs plus one cross brace.
Request the silhouette adjustment again as a single value change.

Help me isolate the intended silhouette change.

Verify the rotatable model

A useful preview proves both the table structure and the interaction. Your final check covers the dimensions, four-part silhouette, draft label, and pointer-drag rotation.

Before you drag the model, predict whether all four parts move as one assembly.

Drag across the table canvas in the Browser pane.
Read the Overall value beside the canvas.
Compare the final silhouette against your furniture reference.

You'll see one tabletop with two slab legs beneath it. The cross brace stays between the legs as the whole model rotates.

The Overall line shows your target width in mm x your target depth in mm x your target height in mm mm. The page remains labelled QUOTE DRAFT.

That is your first fabrication checkpoint complete. The table's form is now visible before any cut file exists.

Table not rotating correctly?

Confirm that you are dragging inside the table canvas.
Confirm that preview.html still loads design-data.js.
Ask Claude to restore the existing pointer-drag handlers from the supplied project code.

Help me restore pointer-drag rotation.

Your table now has a reviewed silhouette plus a shared geometry model. Next, you'll turn that model into a one-sheet quote layout.

Generate the One-Sheet Cut Layout

Your rotatable preview proves that the four-part table captures the silhouette you chose. The next goal is to arrange those parts on one full plywood sheet.

The layout must also reveal whether nominal material values provide enough evidence for machining. This first export tests that boundary while keeping the geometry useful for a shop quote.

In this step, get ready to:

Generate a one-sheet layout with downloadable SVG and DXF quote drafts.
Test the intended draft status against the missing manufacturing inputs.
Inspect the exported extents and closed-contour counts.

Generate the quote-draft exporter

An SVG and a DXF can carry full-scale vector contours for CNC quoting. The exporter keeps browser labels separate from the downloaded cut geometry.

Before you send the request, what status do you expect while the measured stock and cutter details remain unconfirmed?

Switch back to the prompt in the Code tab.
Ask Claude to build the exporter by sending this request:

Using design-data.js, create cut-layout.html from the supplied project code. Lay every part out within a 48 x 96 inch sheet footprint. The on-screen view may show a sheet boundary and labels, but downloaded cut geometry must contain only closed part and slot contours at 1:1 scale in millimetres. Export table-sheet-layout.svg and an ASCII R12-style table-sheet-layout.dxf. Do not generate G-code, toolpaths, kerf offsets, tabs, or invented shop tolerances.

If measured plywood thickness, fit clearance, router-bit diameter, or inside-corner strategy is missing, keep the files downloadable for quoting but mark them QUOTE DRAFT. Open cut-layout.html and verify the sheet fit and warnings.

What does this request do?

The exporter reads the existing geometry from design-data.js so the layout stays synchronized with the accepted table design.
The browser preview adds a sheet boundary and part labels for visual review.
The downloaded files keep only the closed contours a shop needs for quoting.
The status check prevents the geometry from being presented as approved G-code or finished toolpaths.

Review Claude's proposed cut-layout.html file change.
Approve the reviewed file change.
Switch to the Browser pane when Claude opens cut-layout.html.

You should see the Top, Left Leg, Right Leg, and Cross Brace inside the sheet boundary. You should also see an amber QUOTE DRAFT status with the unconfirmed manufacturing checks marked PENDING.

Good. The exporter is working while openly showing that nominal 18 mm slots and an unresolved inside-corner strategy are insufficient for fabrication approval.

Don't see all four parts?

Confirm that cut-layout.html sits beside design-data.js in ~/Documents/claude-cnc-table.
Confirm that the page loads design-data.js before the layout script.
Ask Claude to compare the browser file with the accepted getParts() geometry if a part is missing.

Help me diagnose why cut-layout.html does not show all four table parts.

Download the quote drafts

The on-screen sheet includes review aids that do not belong in cut geometry. Each download removes the labels and sheet frame while preserving the closed part contours at full scale.

Click Download SVG quote draft in the toolbar.
Choose ~/Documents/claude-cnc-table as the save location if your Mac asks where to place the file.
Click Download DXF quote draft in the toolbar.
Choose ~/Documents/claude-cnc-table as the save location if your Mac asks where to place the file.
Use Finder to move any file saved in your Downloads folder into ~/Documents/claude-cnc-table.

That is the export path proven. Your workspace now contains table-sheet-layout.svg and table-sheet-layout.dxf as quote drafts.

Why keep both formats?

The SVG gives you a browser-friendly view of the vector geometry. The DXF provides a separate vector handoff that a shop can inspect in its own workflow.

The shop still decides whether it wants the combined sheet or separate part files. These downloads make that conversation concrete.

Downloads missing from the workspace?

Check your Mac's Downloads folder for the two filenames. Move both files into ~/Documents/claude-cnc-table before asking Claude to inspect them.

Help me find the downloaded SVG and DXF files and place them in my Claude workspace.

Inspect the exported geometry

A text inspection checks the geometry independently from the browser preview. It reveals the coordinate extents and confirms how many closed contours each exporter produced.

Switch back to the prompt in the Code tab.

Before Claude inspects the files, how many outer contours and slot contours do you expect from a top, two legs, and one cross brace?

Compare both downloaded files by sending this request:

Inspect the text of table-sheet-layout.svg and table-sheet-layout.dxf. Report the overall numeric extents, the number of closed outer contours, and the number of slot contours. Confirm that the downloaded geometry contains no labels, sheet frame, G-code, toolpaths, kerf offsets, tabs, or invented tolerances.

What does this inspection check?

The numeric extents show whether every exported coordinate stays within the declared sheet size.
The outer-contour count checks that all four physical parts reached each file.
The slot-contour count checks the four top slots and the two brace slots.
The content check confirms that preview aids and machining instructions stayed outside the quote geometry.

Claude should report extents within 2438.4 x 1219.2 mm. It should also find four closed outer contours and six closed slot contours in each export.

Leave the amber QUOTE DRAFT status in place.

This shortfall is intentional. The files can support a quote while continuing to name the shop evidence required before fabrication.

✔️ Awesome, I've got everything!

Your four parts fit inside the declared sheet. Both quote-draft files are downloaded with matching closed-contour counts.

ⓧ I'd like to double check the full code

Compare your generated cut-layout.html with this complete file:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>CNC Quote-Draft Layout</title>
  <style>
    body { margin: 0; font: 15px system-ui; background: #f3f5f7; color: #18202a; }
    main { max-width: 1150px; margin: auto; padding: 22px; }
    .toolbar { display: flex; gap: 10px; flex-wrap: wrap; margin: 14px 0; }
    button { padding: 10px 14px; border: 0; border-radius: 8px; background: #145da0; color: white; cursor: pointer; }
    #sheet { background: white; border: 3px solid #7b8794; }
    #sheet svg { display: block; width: 100%; height: auto; }
    .panel { background: white; border: 1px solid #ccd3da; border-radius: 10px; padding: 15px; margin: 14px 0; }
    .warn { color: #8a5300; font-weight: 800; }
    .ok { color: #176b35; font-weight: 800; }
    li { margin: 5px 0; }
  </style>
</head>
<body>
<main>
  <h1>One-Sheet CNC Quote Layout</h1>
  <div id="status" class="panel"></div>
  <div class="toolbar">
    <button id="svgDownload">Download SVG quote draft</button>
    <button id="dxfDownload">Download DXF quote draft</button>
  </div>
  <div id="sheet"></div>
  <div id="legend" class="panel"></div>
</main>
<script src="design-data.js"></script>
<script>
  const { design, getParts, slotWidthMm, isPositiveNumber } = TABLE_MODEL;
  const parts = getParts();
  const sheet = design.sheet;

  const rectPoints = r => [[r.x,r.y],[r.x+r.width,r.y],[r.x+r.width,r.y+r.height],[r.x,r.y+r.height]];
  const pathData = (points, ox, oy) => points.map(([x,y], i) => `${i ? "L" : "M"}${x+ox} ${y+oy}`).join(" ") + " Z";

  function geometryMarkup() {
    return parts.map(part => {
      const outer = `<path d="${pathData(part.outer, part.layout.x, part.layout.y)}"/>`;
      const holes = part.holes.map(hole => `<path d="${pathData(rectPoints(hole), part.layout.x, part.layout.y)}"/>`).join("");
      return outer + holes;
    }).join("");
  }

  function buildSvg(preview) {
    const frame = preview ? `<rect x="1" y="1" width="${sheet.widthMm-2}" height="${sheet.heightMm-2}" fill="#fffdf7" stroke="#7b8794" stroke-width="2"/>` : "";
    const labels = preview ? parts.map(part => `<text x="${part.layout.x+8}" y="${part.layout.y+24}" font-size="18" fill="#145da0">${part.name}</text>`).join("") : "";
    return `<svg xmlns="http://www.w3.org/2000/svg" width="${sheet.widthMm}mm" height="${sheet.heightMm}mm" viewBox="0 0 ${sheet.widthMm} ${sheet.heightMm}">${frame}<g fill="none" stroke="#111" stroke-width="1">${geometryMarkup()}</g>${labels}</svg>`;
  }

  function pair(code, value) { return `${code}\n${value}\n`; }

  function dxfPolyline(points, ox, oy) {
    let text = pair(0,"POLYLINE") + pair(8,"0") + pair(66,1) + pair(10,0) + pair(20,0) + pair(30,0) + pair(70,1);
    for (const [x,y] of points) {
      text += pair(0,"VERTEX") + pair(8,"0") + pair(10,x+ox) + pair(20,sheet.heightMm-(y+oy)) + pair(30,0);
    }
    return text + pair(0,"SEQEND") + pair(8,"0");
  }

  function buildDxf() {
    let text = pair(0,"SECTION") + pair(2,"HEADER") + pair(9,"$ACADVER") + pair(1,"AC1009") + pair(0,"ENDSEC") + pair(0,"SECTION") + pair(2,"ENTITIES");
    for (const part of parts) {
      text += dxfPolyline(part.outer, part.layout.x, part.layout.y);
      for (const hole of part.holes) text += dxfPolyline(rectPoints(hole), part.layout.x, part.layout.y);
    }
    return text + pair(0,"ENDSEC") + pair(0,"EOF");
  }

  function bounds(points) {
    const xs = points.map(p => p[0]), ys = points.map(p => p[1]);
    return { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
  }

  function partFits(part) {
    const b = bounds(part.outer);
    return part.layout.x+b.minX >= sheet.marginMm &&
      part.layout.y+b.minY >= sheet.marginMm &&
      part.layout.x+b.maxX <= sheet.widthMm-sheet.marginMm &&
      part.layout.y+b.maxY <= sheet.heightMm-sheet.marginMm;
  }

  const material = design.material;
  const checks = [
    [isPositiveNumber(material.measuredThicknessMm), "Actual plywood thickness confirmed"],
    [Number.isFinite(material.fitClearanceMm) && material.fitClearanceMm >= 0, "Fit clearance confirmed"],
    [isPositiveNumber(material.routerBitDiameterMm), "Router-bit diameter or equivalent cutter constraint confirmed"],
    [typeof material.insideCornerStrategy === "string" && material.insideCornerStrategy.trim(), "Inside-corner strategy confirmed"],
    [parts.every(partFits), "Every part stays within the declared sheet margin"]
  ];
  const ready = checks.every(([pass]) => pass);
  document.querySelector("#status").innerHTML = `
    <div class="${ready ? "ok" : "warn"}">${ready ? "SHOP INPUTS CONFIRMED" : "QUOTE DRAFT"}</div>
    <p>Slot width used: ${slotWidthMm()} mm${ready ? ` = ${material.measuredThicknessMm} mm measured stock + ${material.fitClearanceMm} mm confirmed clearance` : " using the nominal fallback until the shop confirms inputs"}.</p>
    <ul>${checks.map(([pass,label]) => `<li>${pass ? "PASS" : "PENDING"}: ${label}</li>`).join("")}</ul>
    <p>This file contains geometry, not G-code or shop-approved toolpaths.</p>
  `;

  document.querySelector("#sheet").innerHTML = buildSvg(true);
  document.querySelector("#legend").innerHTML = `<b>Parts:</b> ${parts.map(part => part.name).join(", ")}<br><b>Sheet:</b> 48 x 96 in (${sheet.heightMm} x ${sheet.widthMm} mm)<br><b>DXF numeric units:</b> millimetres`;

  function download(content, mediaType, filename) {
    const link = document.createElement("a");
    link.href = `data:${mediaType};charset=utf-8,${encodeURIComponent(content)}`;
    link.download = filename;
    document.body.appendChild(link);
    link.click();
    link.remove();
  }

  document.querySelector("#svgDownload").addEventListener("click", () => download(buildSvg(false), "image/svg+xml", "table-sheet-layout.svg"));
  document.querySelector("#dxfDownload").addEventListener("click", () => download(buildDxf(), "text/plain", "table-sheet-layout.dxf"));
</script>
</body>
</html>

How does the full file fit together?

The page gets every part from getParts().
The SVG builder separates preview-only elements from downloaded geometry.
The DXF builder writes each outer boundary and slot as a closed polyline.
The status panel keeps the result in draft mode until all manufacturing checks pass.

Your table now has a visible sheet layout and two inspectable quote files. Next, you'll replace assumptions only when a shop provides evidence for the material and machining process.

Audit the Slots Against the Shop Process

Your Claude Desktop workspace now has a rotatable table preview plus downloadable quote-draft geometry. The next goal is to test its manufacturing assumptions against a real shop process.

Nominal thickness alone cannot define a reliable slot. This audit requires measured stock thickness, fit clearance, cutter constraints, plus an inside-corner strategy from a CNC routing shop.

In this step, get ready to:

Collect the shop's manufacturing constraints.
Update the material evidence without introducing guessed values.
Audit the revised geometry against the recorded evidence.

Collect the shop's manufacturing inputs

A reliable slot depends on the shop's stock plus its machining process. Finding all eight answers can be fiddly because shops publish different levels of detail.

Keep this at quote stage

This project ends with a quote request. Do not approve production or enter payment details during this audit.

Keep describing the geometry as a quote draft. Do not describe the table as structurally certified.

Switch back to the Browser pane from earlier.
Search for a local shop that offers plywood CNC routing.
Choose a shop whose published capabilities include plywood.
Review the shop's material pages for relevant manufacturing values.
Use the shop's listed contact channel to ask about any unpublished values.

Why actual thickness leads the audit

A nominal plywood label can differ from the sheet's measured thickness. Slot geometry needs the stock value that the shop expects to machine.

The shop's cutter also leaves rounded inside corners. Its preferred relief method determines how the square tabs can enter those corners.

Record the actual stock thickness as confirmed stock thickness in mm or unresolved.
Record the preferred fit clearance as confirmed fit clearance in mm or unresolved.
Record the cutter diameter or minimum inside radius as confirmed cutter diameter or inside radius in mm or unresolved.
Record the dogbone or corner-relief preference as confirmed corner-relief strategy or unresolved.
Record the usable sheet dimensions as confirmed usable sheet size or unresolved.
Record the required edge margin as confirmed edge margin in mm or unresolved.
Record the required part spacing as confirmed part spacing in mm or unresolved.
Record the preferred nesting format as confirmed nesting format or unresolved.

Update the material evidence

The material block acts as an evidence ledger. A null value clearly records that the shop has not confirmed an input.

How the evidence maps to code

The measuredThicknessMm field stores an explicitly confirmed stock thickness in millimetres.
The fitClearanceMm field stores the shop's confirmed clearance.
The routerBitDiameterMm field stores an explicitly confirmed cutter diameter. A minimum inside radius stays in the notes until the shop also confirms the diameter.
The insideCornerStrategy field stores the shop's stated corner-relief preference.
The slotWidthMm() function adds measured thickness to confirmed fit clearance only when both values are available.

Return to the Local session chat from earlier.
Ask Claude to inspect the current design-data.js plus your shop manufacturing notes.

Claude should identify which material fields have direct support before proposing a file change.

Ask Claude to update only the material block from the explicit answers in your notes.
Keep every unsupported manufacturing field set to null.
Review the proposed diff under Manual permission mode.
Reject any guessed number or invented strategy.
Accept the diff when every changed value has direct support in your notes.
Confirm that slotWidthMm() still preserves the confirmed-thickness plus confirmed-clearance rule.

Your accepted file now separates evidence from assumptions. Any missing input remains visible through the nominal fallback plus the quote-draft status.

Re-audit the layout and downloads

Before you reload, which status does your current evidence support?

Switch back to the Browser pane.
Reload cut-layout.html.

✔️ I see SHOP INPUTS CONFIRMED

You'll see SHOP INPUTS CONFIRMED in green. The page also shows the measured-stock plus confirmed-clearance equation.

Compare the displayed slot equation with your shop manufacturing notes.
Confirm that every listed check shows PASS.

ⓧ I still see QUOTE DRAFT

You'll see the amber QUOTE DRAFT status. Each unavailable requirement remains marked PENDING.

Compare every PENDING item with the unresolved entries in your shop manufacturing notes.
Correct design-data.js if the page status disagrees with your evidence.
Reload cut-layout.html after any correction.

The visible status proves how much manufacturing evidence you have. The export audit checks whether the geometry stayed coherent.

What the final audit must prove

Every outer part contour plus every slot contour is closed.
The exported geometry contains no duplicate lines.
The numeric extents stay within the declared sheet footprint.
The SVG plus DXF remain full-scale millimetre files.
The slot width matches confirmed thickness plus confirmed clearance only when both exist.
The inside-corner strategy is either confirmed or explicitly unresolved.

Click Download SVG quote draft.
Click Download DXF quote draft.
Return to the Local session chat.
Ask Claude to inspect the latest table-sheet-layout.svg plus table-sheet-layout.dxf against the six checks above.

You should receive an audit report covering contours, duplicates, extents, scale, slot math, plus corner status. This is the key safeguard: your files now communicate exactly what the evidence supports.

Does the audit disagree with the page?

Check that Claude inspected the latest downloads instead of an earlier pair.
Confirm that unsupported fields still contain null.
Reload cut-layout.html after correcting the material evidence.

Ask for help with the mismatch: Help me compare my cut-layout status with my shop notes and exported geometry.

Your packet now states exactly what the shop has confirmed. Next, you'll pair that evidence with an assembly guide plus a complete quote request.

Build the Quote Packet and Request a Quote

Your audit has turned the CNC geometry into an honest quote draft. A shop still needs part names, assembly intent, units, and manufacturing questions before it can price the job accurately.

This step turns those files into a quote packet that someone can review without guessing. You will submit the packet without approving production or entering payment details.

In this step, get ready to:

Build a parts list and illustrated assembly guide.
Capture the preview, sheet layout, and assembly guide for the shop.
Submit a quote request and save evidence of the submission.

Build the assembly guide and quote request

The vector files describe shapes. The assembly guide shows how those shapes become a table.

Switch back to the Local session in Claude Desktop from earlier.
Ask Claude to create assembly.html from the supplied project code.
Tell Claude to generate the parts list with TABLE_MODEL.getParts().
Tell Claude to illustrate the cross brace entering the first leg, the second leg joining the brace, and the top lowering onto the leg tabs.
Ask Claude to create quote-request.md from the supplied project code.
Tell Claude to preserve the quote-draft status and every unresolved manufacturing question.
Review Claude's proposed changes in Manual permission mode.
Accept the changes after both files match the requirements.

Why include an assembly guide?

Closed contours show where a cutter travels. The guide shows which part is the top, which parts support it, and how the brace connects the frame.

That context helps the shop identify joint or machining questions before it prepares a price.

Ask Claude to open assembly.html in the Browser pane.
Compare the four listed parts with the parts shown in cut-layout.html.
Confirm the first picture shows the cross brace entering the first leg.
Confirm the second picture shows the second leg joining the brace.
Confirm the third picture shows the top lowering onto the leg tabs.
Review quote-request.md in Claude Desktop.
Confirm the request identifies the finished size, four-part construction, scale, material preference, quote-draft status, and delivery location.

Good progress. The shop can now see the same four-part construction in the geometry, parts list, and assembly sequence.

✔️ Awesome, I've got everything!

Great. Double check that assembly.html and quote-request.md are saved inside ~/Documents/claude-cnc-table.

ⓧ I'd like to double check the full code

Compare your complete assembly.html file with this reference:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Table Parts and Assembly</title>
  <style>
    body { font: 16px system-ui; margin: 0; background: #f5f2ec; color: #26221d; }
    main { max-width: 1050px; margin: auto; padding: 24px; }
    .steps { display: grid; grid-template-columns: repeat(3,1fr); gap: 14px; }
    article, table { background: white; border: 1px solid #d4cdc2; border-radius: 10px; }
    article { padding: 14px; } svg { width: 100%; height: auto; }
    table { width: 100%; border-collapse: collapse; overflow: hidden; margin: 18px 0; }
    th,td { padding: 9px; border-bottom: 1px solid #ddd; text-align: left; }
    .note { color: #8a5300; font-weight: 700; }
    @media (max-width: 760px) { .steps { grid-template-columns: 1fr; } }
  </style>
</head>
<body>
<main>
  <h1>Parts and Assembly Guide</h1>
  <p class="note">Dry-fit only after the shop confirms stock, clearance, cutter, and corner relief. This guide is not structural certification.</p>
  <table><thead><tr><th>Part</th><th>Quantity</th><th>Role</th></tr></thead><tbody id="parts"></tbody></table>
  <div class="steps">
    <article><h2>1. Start the frame</h2>
      <svg viewBox="0 0 300 210" aria-label="Brace entering the first leg">
        <rect x="45" y="25" width="28" height="155" fill="#bf8245"/><rect x="73" y="95" width="180" height="25" fill="#9a663a"/>
        <path d="M245 55v30" stroke="#145da0" stroke-width="5"/><path d="M235 76l10 12 10-12" fill="#145da0"/>
      </svg><p>Slide the cross brace through the first leg's confirmed slot.</p>
    </article>
    <article><h2>2. Add the second leg</h2>
      <svg viewBox="0 0 300 210" aria-label="Second leg joining the brace">
        <rect x="45" y="25" width="28" height="155" fill="#bf8245"/><rect x="73" y="95" width="150" height="25" fill="#9a663a"/><rect x="235" y="25" width="28" height="155" fill="#bf8245"/>
        <path d="M275 102h-35" stroke="#145da0" stroke-width="5"/><path d="M247 92l-12 10 12 10" fill="#145da0"/>
      </svg><p>Slide the second leg onto the opposite end and center the frame.</p>
    </article>
    <article><h2>3. Lower the top</h2>
      <svg viewBox="0 0 300 210" aria-label="Top lowering onto both legs">
        <rect x="35" y="35" width="230" height="24" fill="#d8aa68"/><rect x="75" y="78" width="25" height="105" fill="#bf8245"/><rect x="200" y="78" width="25" height="105" fill="#bf8245"/><rect x="100" y="125" width="100" height="20" fill="#9a663a"/>
        <path d="M150 4v25" stroke="#145da0" stroke-width="5"/><path d="M140 21l10 12 10-12" fill="#145da0"/>
      </svg><p>Align the four top slots with the leg tabs and lower the top evenly.</p>
    </article>
  </div>
</main>
<script src="design-data.js"></script>
<script>
  const roles = { "Top":"Work surface and frame lock", "Left Leg":"First slab support", "Right Leg":"Second slab support", "Cross Brace":"Connects and spaces the legs" };
  document.querySelector("#parts").innerHTML = TABLE_MODEL.getParts().map(part => `<tr><td>${part.name}</td><td>${part.quantity}</td><td>${roles[part.name]}</td></tr>`).join("");
</script>
</body>
</html>

How does the assembly guide work?

The page loads design-data.js so its parts list stays aligned with the cut layout.
The parts table body receives the four results from TABLE_MODEL.getParts().
The three illustrations communicate the intended order without presenting the design as structurally certified.

Compare your complete quote-request.md file with this reference:

# CNC plywood table quote request

Hello,

I would like a quote to CNC-route the attached four-part plywood table design.

Project details:
- Finished size: [WIDTH] x [DEPTH] x [HEIGHT] mm
- Parts: one top, two slab legs, one cross brace
- Quantity: one table
- Units in the SVG and DXF: millimetres at 1:1 scale
- Preferred material: furniture-grade plywood near 18 mm nominal thickness
- Current file status: quote draft, not G-code or approved toolpaths
- Delivery or pickup location: [LOCATION]

Please confirm before production:
1. The material and actual measured sheet thickness you would supply.
2. Your recommended slot-fit clearance for that material and finish.
3. The cutter diameter or minimum inside radius that affects the slots.
4. Whether you prefer dogbones, another corner-relief method, or shop-applied CAM compensation.
5. Whether you want the pre-nested sheet file or separate part files.
6. Your required edge margin, spacing, hold-down tabs, and usable sheet dimensions.
7. Whether this appears manufacturable as drawn and whether you recommend a fit coupon first.

Please quote material, routing, setup, finishing if applicable, tax, delivery, and lead time separately.

Attachments:
- table-sheet-layout.dxf
- table-sheet-layout.svg
- 3D preview screenshot
- sheet-layout screenshot
- assembly-guide screenshot

Thank you.

What does the request cover?

The request separates project facts from questions that only the shop can answer. It also tells the shop that the attached vectors are quote geometry instead of approved toolpaths.

The final section names the files that give the shop visual and geometric context.

Does the guide look incomplete?

Check that assembly.html and design-data.js are inside the same claude-cnc-table folder.
Check that the script loads design-data.js before it calls TABLE_MODEL.getParts().
Ask Claude to compare your file with the reference if a part row or assembly picture is missing.

Help me diagnose why my assembly guide is missing parts or illustrations.

Capture the quote packet screenshots

A local HTML file is useful for your review. Screenshots let the shop understand the design before opening any attachments.

Choosing the save location is a little fiddly because the screenshot controls hide it inside an options menu. Set it once so every image lands beside the project files.

Return to preview.html in the Browser pane.
Drag the table to an angle that clearly shows the top, both slab legs, and the cross brace.
Press Shift-Command-5 to open the screenshot controls.
Click Options in the screenshot toolbar.
Choose Other Location under the save options.
Select ~/Documents/claude-cnc-table as the destination.

Capture useful evidence

Include the page title, visible table, and dimension summary in the preview image. Keep unrelated windows outside the selected area.

Capture the selected portion of the table preview.
Select the new screenshot in Finder.
Rename the selected file to preview-screenshot.png by pressing Return before and after typing the name.
Return to cut-layout.html in the Browser pane.
Capture the sheet layout with its visible status and manufacturing checks.
Select the new screenshot in Finder.
Rename the selected file to cut-layout-screenshot.png by pressing Return before and after typing the name.

What do the first two images prove?

The preview image communicates the finished silhouette. The layout image shows that the parts fit inside the declared sheet while preserving the visible manufacturing status.

Return to assembly.html in the Browser pane.
Capture the parts table and all three assembly pictures.
Select the new screenshot in Finder.
Rename the selected file to assembly-guide-screenshot.png by pressing Return before and after typing the name.
Confirm Finder lists all three named screenshot files inside claude-cnc-table.

Your packet now has three visual checkpoints. A shop can see the intended table, inspect the sheet layout, and understand the assembly sequence.

Submit the quote request

The final handoff asks the shop to price the work and resolve the remaining manufacturing questions. The outgoing message uses your real dimensions while quote-request.md remains the reusable template in your workspace.

This is a quote request only

Submitting this packet asks for information and pricing. Do not approve production, enter payment details, or describe the design as structurally certified.

Return to the selected shop's email thread or contact form.
Copy the body of quote-request.md into the outgoing message.
Replace the four bracketed fields in the outgoing message with your finished dimensions and pickup or delivery location.
Attach the vector format preferred by the shop from your manufacturing notes.
Attach preview-screenshot.png.
Attach cut-layout-screenshot.png.
Attach assembly-guide-screenshot.png.

What should the shop confirm?

The material and actual measured stock thickness.
The recommended slot-fit allowance.
The cutter diameter or minimum inside radius.
The preferred inside-corner relief strategy.
The preferred nesting format.
The price, lead time, and delivery options.

Before you check, ask yourself whether the workspace and outgoing message now tell the same story.
Submit the quote request through the shop's selected channel.
Save the sent-email copy or contact-form confirmation inside ~/Documents/claude-cnc-table with the base name quote-submission-confirmation.
Update the shop manufacturing notes with the submission date.
Mark price as unresolved until the shop responds.
Mark lead time as unresolved until the shop responds.
Mark delivery options as unresolved until the shop responds.
Return to the claude-cnc-table folder in Finder to check the packet.

You should see the original project files, both vector files, assembly.html, quote-request.md, all three screenshots, and the saved submission confirmation. Your sent message should show the same dimensions and attachments.

Unable to submit the packet?

Use the shop's email channel if its contact form does not accept the preferred vector file.
Attach only the vector format requested by the shop if the form limits file types.
Save a screenshot of the completed confirmation page if the form does not send a confirmation email.

Help me work out how to submit my CNC quote packet without losing the vector file or confirmation.

That is the handoff complete. Your local shop now has the geometry, visual context, assembly intent, and questions needed to prepare a quote without treating the draft as a fabrication order.

Secret mission

Make a Slot-Fit Test Coupon

A full table is an expensive place to discover a poor slot fit. Build a three-slot coupon that lets the shop test tight, target, and loose fits before committing material to the complete table.

Clean Up Your Resources

There are no ongoing project costs because your fabrication packet lives entirely on your Mac. Choose whether to keep the packet ready, pause your Claude Desktop session, or delete the local folder.

Resources you used:

The ~/Documents/claude-cnc-table folder containing the complete local quote packet.

Keep everything running

No action is needed. Choose this option while you review the quote or wait for shop feedback.

Keep the ~/Documents/claude-cnc-table folder on your Mac.
Return to the Claude Desktop Local session when you are ready to revise the packet.

Pause - I'll come back to this later

Pausing ends the active workspace while preserving every file. The saved folder creates no ongoing project cost.

Close the current Local session in Claude Desktop.
Leave the ~/Documents/claude-cnc-table folder in your Documents folder.

Delete - I don't want to use this again

Deleting this folder permanently removes the complete quote packet from your Mac. A backup protects any files you want to keep.

A quote request already sent to the shop remains sent. This project has not created a fabrication order or payment approval.

Copy any files you want to keep to a location outside ~/Documents/claude-cnc-table.
Return to the Terminal pane in the Claude Desktop Local session.
Delete the complete project folder by running this command:

rm -rf ~/Documents/claude-cnc-table

What does this command do?

The command recursively removes the named folder without asking for confirmation. Every file in the local quote packet is removed with it.

Check the Documents folder in Finder for claude-cnc-table.

You should no longer see the project folder or its fabrication packet.

Still See the Project Folder?

Check whether macOS denied the terminal access to your Documents folder. Grant the requested folder access before running the deletion command again.

Ask for help removing the local project folder.

Nice Work!

You did it! Your furniture reference is now a local-shop-ready CNC quote packet created with Claude Desktop.

You've learned how to:

Turn a furniture reference into a rotatable browser preview with target dimensions and a four-part construction.
Produce a full-scale one-sheet layout as SVG and DXF quote drafts with unresolved manufacturing inputs kept visible.
Submit a local-shop quote packet with a parts list, an illustrated assembly sequence, and explicit manufacturing questions.
Secret Mission: Built a three-slot fit coupon that compares tight, target, and loose fits before full-table production.

Ready to quiz yourself?