Design a 3D-Printable Bridge with AI

Use Claude and CAD tools to design and slice a modular truss bridge.

Introduction

30 Second Summary

A bridge can look sturdy on a screen while hiding a simple problem: it may be too large to make. Checking practical limits early keeps a convincing picture from becoming an expensive mistake.

In this project, you will use Claude Code to design a two-foot modular truss bridge candidate. You will use OpenSCAD plus Bambu Studio to test its fit, filament mass, and estimated print time before any physical build.

What You'll Build

You will finish with a five-panel bridge assembly backed by a slicer report showing whether every part meets the manufacturing limits.

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

  • A one-piece bridge concept that makes the 609.6 mm span visibly too large for the target printer plate.
  • A modular bridge assembly you can preview as five connected bays and export as flat-printing panels, crossbeams, and a fit-clearance coupon.
  • A pass/fail constraint report covering part fit, total filament mass, and estimated print time while keeping the 100-pound target explicitly unverified.
  • Secret Mission: Compare a coarser slicing preset and measure whether it cuts estimated print time by at least 10% without breaking the mass or build-volume limits.

Are there any prerequisites?

You'll need a Mac running macOS 13.0 or later plus Claude Code access through an eligible paid account. No CAD experience or printer hardware is required.

Before We Start

Before any hands-on work begins, commit to evaluating Claude's engineering process through measurable constraints. That verdict depends on a 609.6 mm span, a 180 × 180 × 180 mm build volume, less than 500 g of PLA, fewer than 18 hours of estimated print time, and slicer evidence before printing.

Set Up Your Mac Design Lab

A trustworthy bridge experiment needs repeatable tools. Known versions keep later results tied to the same environment.

This step gives Claude Code a terminal readiness check. It also gives OpenSCAD a visible CAD test before any bridge files exist.

In this step, get ready to:
  • Verify the system requirements for your Mac.
  • Authenticate Claude Code 2.1.318 in Terminal.
  • Prove OpenSCAD 2021.01 can preview a 20 mm cube.
Confirm your Mac and Claude access

Claude Code requires macOS 13.0 or later. It also requires access through an eligible account or supported provider.

  • Click the Apple menu in the upper-left corner of your screen.
  • Choose About This Mac.
  • Confirm the displayed macOS version is 13.0 or later.
  • Confirm your account provides Claude Pro, Max, Ultra, Team, Enterprise, Console, or supported-provider access.

Which Claude plans work?

Claude Code is included with the eligible account types listed above. The free Claude plan does not include Claude Code.

That clears the first gate. Your environment meets the access requirements for the design tools.

Missing a requirement?

If your Mac shows a version below 13.0, use the official macOS update guide before continuing.

If your account is not eligible, confirm your available access with the account owner before installing Claude Code.

Help me check whether my Mac and Claude account meet the project requirements.

Install and authenticate Claude Code

The native installer makes Claude Code available through Terminal. A version check reveals whether your Mac already has the required release.

  • Press Cmd+Space to open Spotlight.
  • Type Terminal into the search field.
  • Press Return to open Terminal.
  • Check the installed Claude Code version by running this command:
claude --version

What does this check show?

The command asks the installed Claude Code CLI for its version. A ready installation prints a version number followed by (Claude Code).

✔️ I see the required version

Your output shows 2.1.318 followed by (Claude Code). Continue to authentication below.

ⓧ I see an older version

  • Install the current Claude Code release by running this command:
curl -fsSL https://claude.ai/install.sh | bash

What does this command do?

This runs Anthropic's native macOS installer. The installer downloads the current Claude Code release.

  • Press Cmd+N in Terminal to open a fresh window.

ⓧ Command not found

  • Install Claude Code by running the native macOS installer:
curl -fsSL https://claude.ai/install.sh | bash

What does this command do?

This downloads Claude Code through Anthropic's native installer. The installation makes the claude command available to new Terminal windows.

  • Press Cmd+N in Terminal to open a fresh window.

Authentication connects the local CLI to your eligible account. The first interactive launch opens a browser sign-in flow.

  • Start the interactive Claude Code session by running this command:
claude

What happens next?

Claude Code starts an interactive session. The first launch prompts you to authenticate through your browser.

  • Follow the browser sign-in prompts.

When authentication completes, you return to Terminal. You will see the interactive Claude Code prompt.

Claude Code not starting?

Open a fresh Terminal window if the command remains unavailable after installation. New windows load the updated command path.

Check that the browser sign-in uses the eligible account you confirmed earlier.

Help me troubleshoot my Claude Code installation or browser authentication.

Install and test OpenSCAD

OpenSCAD ships as a macOS disk image. Finder uses that image to place the app in the Applications folder.

✔️ I have the required version

  • Press Cmd+Space to open Spotlight.
  • Type OpenSCAD into the search field.
  • Press Return to open OpenSCAD.
  • Click Help in the menu bar.
  • Choose About.
  • Confirm the displayed version is 2021.01.

ⓧ I have an older version

  • Download OpenSCAD-2021.01.dmg from the official OpenSCAD release page.
  • Double-click OpenSCAD-2021.01.dmg in Finder.
  • Drag OpenSCAD into the Applications folder.
  • Complete the replacement prompt if macOS shows one.
  • Press Cmd+Space to open Spotlight.
  • Type OpenSCAD into the search field.
  • Press Return to open OpenSCAD.
  • Confirm 2021.01 through Help followed by About.

ⓧ OpenSCAD is not installed

  • Download OpenSCAD-2021.01.dmg from the official OpenSCAD release page.
  • Double-click OpenSCAD-2021.01.dmg in Finder.
  • Drag OpenSCAD into the Applications folder.
  • Press Cmd+Space to open Spotlight.
  • Type OpenSCAD into the search field.
  • Press Return to open OpenSCAD.
  • Confirm 2021.01 through Help followed by About.

Your final check tests both parts of the lab. Terminal proves the AI assistant is available.

  • Switch back to Terminal from earlier.
  • Press Cmd+N to open a new Terminal window.

Before you run the final check, do you expect Terminal to show the pinned release or an older installation?

  • Verify Claude Code by running this command:
claude --version

What should I see?

Terminal prints 2.1.318 followed by (Claude Code). This confirms the pinned CLI release is available.

The geometry check proves OpenSCAD can turn a script into a visible model. A known cube gives you a simple result to compare against.

  • Switch back to OpenSCAD.
  • Select the text editor pane.
  • Replace its contents with the code below:
cube([20,20,20]);

What does this code do?

The cube primitive creates a solid box. Its three values set the width, depth, and height to 20 mm.

Before you preview the model, what shape do you expect three equal dimensions to produce?

  • Press F5 to preview the model.

You will see a cube in the OpenSCAD viewport. The visible geometry confirms the editor and preview engine are working.

Cube not visible?

Confirm the cube snippet matches the code block exactly. A missing bracket prevents OpenSCAD from building the preview.

Press F5 again after correcting the editor contents.

Help me troubleshoot why my OpenSCAD cube preview is blank.

That's the setup locked in: Claude Code responds in Terminal. OpenSCAD turns code into visible geometry.

Next, you will give Claude the bridge constraints. Claude will turn them into the first one-piece concept.

Create the One-Piece Bridge Concept

Claude Code is authenticated in Terminal. OpenSCAD has already proved it can preview geometry.

A visible one-piece concept gives you concrete geometry to evaluate before manufacturing constraints change the design. Claude first needs to explain the bridge's load path before creating the CAD model.

In this step, get ready to:
  • Create a home-folder workspace containing the exact design brief.
  • Have Claude justify a structural form before drawing it.
  • Export the completed one-piece model as an STL file.
Create the workspace and design brief

The design brief turns the engineering question into measurable constraints. It also keeps the 100-pound target separate from evidence that could support a capacity claim.

  • Switch to Finder from the Dock.
  • Select the home folder named with your macOS username in Finder's sidebar.
  • Use Finder's folder creation control to create a new folder.
  • Name the folder claude-bridge.
  • Use Finder's contextual action for claude-bridge to open a Terminal window at that folder.
  • Start Claude Code in that folder by running this command:
claude

What does this command do?

The claude command starts an interactive Claude Code session in the current folder. Files created during this session stay inside claude-bridge.

You'll see the Claude Code prompt in Terminal. Your authenticated session is now working inside the project workspace.

Claude Code Does Not Start?

Confirm that the Terminal window is open at claude-bridge. Return to the Terminal installation from the previous step if your shell cannot find Claude Code.

Use this help prompt if the interactive session still does not appear: Help me start Claude Code inside my claude-bridge folder on macOS.

What Must the Brief Lock Down?

  • The bridge span is exactly 609.6 mm.
  • The target printer profile is the Bambu Lab A1 mini.
  • The build volume is 180 × 180 × 180 mm.
  • The included nozzle is 0.4 mm.
  • The slicing material is PLA.
  • The total sliced filament target is below 500 g.
  • The total sliced print-time target is below 18 hours.
  • The future suspended load is centered at midspan.
  • The 100-pound figure is an unverified design target.
  • The future segmented design starts with an FDM fit clearance of 0.3 mm.
  • The safety boundary reserves load testing for a separate supervised project.
  • Ask Claude to create bridge-brief.md from the requirements above.
  • Tell Claude to include the required reasoning before CAD.
  • Tell Claude to include the complete design progression.
  • Tell Claude to include the evidence checklist.
  • Tell Claude to include the complete safety boundary.
  • Allow Claude Code to write bridge-brief.md if it requests file permission.

Claude creates bridge-brief.md inside claude-bridge. The brief now acts as the source of truth for every later design decision.

  • Switch back to Finder.
  • Confirm that bridge-brief.md appears inside claude-bridge.
  • Compare the file with the exact project brief using the tabs below.

✔️ My brief matches

Your brief records every constraint. It also keeps digital evidence separate from a physical load claim.

ⓧ I want to compare the full file

  • Compare bridge-brief.md with this complete reference:
# Bridge Design Brief

## Question

Can Claude design a two-foot, 3D-printable bridge candidate aimed at a centered 100-pound suspended load?

## Hard constraints

- Overall span: exactly 609.6 mm.
- Target printer profile: Bambu Lab A1 mini.
- Build volume: 180 × 180 × 180 mm.
- Included nozzle: 0.4 mm.
- Material for slicing: PLA.
- Total sliced filament target: below 500 g.
- Total sliced print-time target: below 18 hours.
- Load location: centered at midspan.
- No supports below the span during a future load test.

## Required reasoning before CAD

1. Compare a truss and an arch for this specific centered-load, modular FDM problem.
2. State assumptions and identify the intended load path.
3. Explain why the selected form is easier to segment and print.
4. Identify likely failure locations, especially joints, compression members, and the center crossbeam.
5. Treat 100 pounds as an unverified design target, not a guaranteed capacity.

## Required design progression

1. Create `concept.scad` as a one-piece visual concept with a 609.6 mm span.
2. After the build-volume failure is observed, create `bridge.scad` as a five-panel modular design.
3. Use these exact `part` selector values in `bridge.scad`:
   - `preview`
   - `start_panel`
   - `middle_panel`
   - `end_panel`
   - `crossbeam`
   - `coupon`
4. Use a starting fit clearance of 0.3 mm.
5. Keep all individual exported parts within 180 × 180 × 180 mm.
6. Orient exported truss panels flat so their structural plane lies on the print bed.

## Evidence required before printing

- Every STL fits the target build volume.
- Bambu Studio is configured for the A1 mini, 0.4 mm nozzle, PLA, and a 0.20 mm process.
- Filament weights are summed across all plates.
- Estimated print times are summed across all plates.
- Results are labeled PASS or FAIL against 500 g and 18 hours.

## Safety boundary

This design is not certified structural hardware. Do not stand, sit, or place a person on it. Physical load testing belongs in a separate supervised project with rated supports, an exclusion zone, eye protection, and a remote loading method.

How Does the Brief Control the Project?

The hard constraints define the measurable limits. The reasoning section makes Claude explain its structural choice before drawing.

The evidence section defines what the digital tools can verify. The safety boundary keeps people away from an untested structure.

  • Return to Claude Code in Terminal.
  • Ask Claude to replace every difference in bridge-brief.md with the exact reference content.
  • Confirm the corrected file in Finder.

That is the first guardrail locked in. Claude now has a precise brief for the one-piece concept.

Ask Claude to reason before drawing

A truss uses connected members to carry forces through a defined load path. An arch sends forces through a different form.

Comparing both approaches makes Claude expose its assumptions before a polished model can hide them. The resulting explanation gives you criteria for judging the geometry.

  • Return to the Claude Code session in Terminal.
  • Ask Claude to read bridge-brief.md before responding.
  • Ask Claude to compare a truss approach with an arch approach for the centered load.
  • Request a clear list of structural assumptions.
  • Request a description of the intended centered-load path.
  • Request an explanation of why the selected form is easier to segment for FDM printing.
  • Request likely failure locations in the joints, compression members, or center crossbeam.
  • Require Claude to label 100 pounds as an unverified design target.

Claude should compare both forms before selecting the repeated triangular truss. You'll also see assumptions about the joints, material behavior, centered load, or future physical testing.

Why Use a Truss Here?

Repeated triangular panels create a clear structure for a modular bridge concept. The same pattern can later be split into shorter sections for the target build volume.

This model remains a manufacturability prototype. Physical testing is required before anyone can make a load-capacity claim.

Claude Code may request permission before writing the CAD source file. That permission applies only to the proposed file change inside your project workspace.

  • Ask Claude to create concept.scad as the one-piece bridge concept.
  • Require the exact variable names shown in the full-code check below.
  • Require the exact module names shown in the full-code check below.
  • Require the final one_piece_bridge() call shown in the full-code check below.
  • Allow Claude Code to write concept.scad.
  • Switch back to Finder.
  • Confirm that concept.scad appears beside bridge-brief.md.

Claude has now turned its structural explanation into source geometry. Check that the generated file matches the required model before rendering it.

✔️ My concept code matches

Your file contains the required dimensions, five-panel truss logic, two side trusses, five crossbeams, and final module call.

ⓧ I want to compare the full file

  • Compare concept.scad with this complete reference:
span = 609.6;
bridge_width = 80;
truss_height = 65;
truss_thickness = 8;
chord_width = 10;
member_width = 8;
panel_count = 5;
panel_length = span / panel_count;
crossbeam_size = 10;

module beam_between(a, b, size) {
    hull() {
        translate(a)
            cube([size, truss_thickness, size], center = true);
        translate(b)
            cube([size, truss_thickness, size], center = true);
    }
}

module side_truss(y_position) {
    translate([0, y_position, 0])
        cube([span, truss_thickness, chord_width]);

    translate([0, y_position, truss_height - chord_width])
        cube([span, truss_thickness, chord_width]);

    for (i = [0:panel_count - 1]) {
        x_left = i * panel_length + chord_width / 2;
        x_right = (i + 1) * panel_length - chord_width / 2;
        x_middle = (x_left + x_right) / 2;
        y_middle = y_position + truss_thickness / 2;

        beam_between(
            [x_left, y_middle, chord_width / 2],
            [x_middle, y_middle, truss_height - chord_width / 2],
            member_width
        );

        beam_between(
            [x_middle, y_middle, truss_height - chord_width / 2],
            [x_right, y_middle, chord_width / 2],
            member_width
        );
    }
}

module one_piece_bridge() {
    union() {
        side_truss(0);
        side_truss(bridge_width - truss_thickness);

        for (i = [0:panel_count - 1]) {
            translate([
                i * panel_length + panel_length / 2 - crossbeam_size / 2,
                0,
                0
            ])
                cube([crossbeam_size, bridge_width, crossbeam_size]);
        }
    }
}

one_piece_bridge();

What Does This Code Do?

  • The opening variables hold the bridge dimensions and panel count.
  • The beam_between module forms each diagonal member between two points.
  • The side_truss module repeats the triangular pattern across five panels.
  • The one_piece_bridge module places two side trusses across the bridge width.
  • The loop inside one_piece_bridge adds five bottom crossbeams.
  • The final one_piece_bridge() call tells OpenSCAD which geometry to display.
  • Return to Claude Code in Terminal.
  • Ask Claude to correct every difference in concept.scad so it matches the reference exactly.
  • Confirm the corrected file in Finder.
Render and export the concept

OpenSCAD preview provides a fast visual check of the generated geometry. Rendering calculates the finished solid for STL export.

  • Switch back to OpenSCAD.
  • Use OpenSCAD's file picker to open concept.scad from claude-bridge.

Before you preview the file, do you expect one continuous bridge or separate printable parts?

  • Press F5 to preview the model.

You'll see a complete 609.6 mm bridge with two side trusses and five bottom crossbeams. Your first full-span digital bridge is now visible.

Bridge Missing From the Viewport?

Confirm that OpenSCAD opened concept.scad from claude-bridge. Check that the file ends with one_piece_bridge().

Use this help prompt if the preview remains empty: Help me diagnose an empty OpenSCAD preview for concept.scad.

  • Press F6 to render the bridge.

You'll see the rendered one-piece solid in the viewport. This render is the geometry OpenSCAD uses for the export.

  • Select File in the OpenSCAD menu bar.
  • Select Export.
  • Choose Export as STL....
  • Select claude-bridge as the export destination.
  • Enter concept.stl as the file name.
  • Click Save.

Before you check the workspace, which three files do you expect to find there?

  • Switch back to Finder.
  • Confirm that bridge-brief.md appears inside claude-bridge.
  • Confirm that concept.scad appears inside claude-bridge.
  • Confirm that concept.stl appears inside claude-bridge.

You'll see the design brief beside the OpenSCAD source and its exported STL. That is the complete one-piece concept ready for a real build-volume check.

STL File Not Appearing?

Return to OpenSCAD. Render the model with F6 before using the STL export option.

Confirm that the saved file name includes the .stl extension. Use this help prompt if the export still fails: Help me export concept.scad as concept.stl from OpenSCAD.

Your bridge now exists as explainable CAD and a rendered STL. Next up, you'll test the one-piece model against the target printer's build volume.

Expose the Build-Volume Failure

Your one-piece bridge now exists as concept.stl. OpenSCAD proved that its geometry renders.

A printable design must also fit the printer's build volume. In this step, Bambu Studio gives the concept a real A1 mini plate test.

In this step, get ready to:
  • Prepare Bambu Studio 2.9.1 with the Bambu Lab A1 mini profile.
  • Test concept.stl on the virtual printer plate.
  • Record the plate result in a screenshot plus the design brief.
Install and configure Bambu Studio

A slicer checks a model against a specific printer profile. The A1 mini profile provides a digital plate for this test without requiring printer hardware.

  • Choose the tab that matches the Bambu Studio installation on your Mac.

✔️ I have the required version

  • Keep your installed copy if its version is 2.9.1.
  • Press Cmd+Space to open Spotlight.
  • Type Bambu Studio into Spotlight.
  • Press Enter to open Bambu Studio.

ⓧ I have an older version

  • Visit the official Bambu Studio release page.
  • Download Bambu_Studio_mac-v02.09.01.70-20261103183404.dmg.
  • Double-click the downloaded disk image in Finder.
  • Drag Bambu Studio into the Applications folder shown in the installer window.
  • Approve the replacement if macOS asks about the older copy.
  • Press Cmd+Space to open Spotlight.
  • Type Bambu Studio into Spotlight.
  • Press Enter to open Bambu Studio.

ⓧ It is not installed yet

  • Visit the official Bambu Studio release page.
  • Download Bambu_Studio_mac-v02.09.01.70-20261103183404.dmg.
  • Double-click the downloaded disk image in Finder.
  • Drag Bambu Studio into the Applications folder shown in the installer window.
  • Press Cmd+Space to open Spotlight.
  • Type Bambu Studio into Spotlight.
  • Press Enter to open Bambu Studio.

The first launch presents a setup wizard for printer profiles plus available materials. These choices determine the virtual machine used for every later fit check.

  • Add Bambu Lab A1 mini in the setup wizard's printer list.
  • Choose the included 0.4 mm nozzle for the printer profile.
  • Select PLA as an available filament.
  • Complete the setup wizard to enter the Bambu Studio workspace.

Your digital print environment is ready. Bambu Studio now has an A1 mini profile with its included 0.4 mm nozzle plus PLA.

Bambu Studio not opening?

  • Confirm that your Mac runs macOS 13.0 or later.
  • Reinstall the pinned disk image if the application closes during launch.

Ask for help with opening or configuring Bambu Studio on your Mac.

Test the concept on the printer plate

The virtual plate turns the printer dimensions into visible evidence. Importing the unchanged one-piece model tests the exact geometry that OpenSCAD exported.

  • Select New Project in Bambu Studio.
  • Confirm that the active printer preset shows the Bambu Lab A1 mini with a 0.4 mm nozzle.
  • Confirm that the active filament is PLA.

Before you import the bridge, do you think the complete concept will remain inside the plate boundary?

  • Select Add in Bambu Studio.
  • Open the home-folder claude-bridge workspace in the file picker.
  • Select concept.stl.
  • Click Open to import the model.

There is the manufacturing evidence. You'll see the 609.6 mm bridge extend far beyond the A1 mini's 180 × 180 mm plate boundary.

What did the plate test prove?

OpenSCAD confirmed that the bridge geometry forms a complete model. Bambu Studio confirmed that the one-piece model cannot fit the target printer.

The visible shortfall is the intended result of this test. It gives the next revision a specific manufacturing problem to solve.

  • Keep the complete bridge plus the full plate boundary visible in Bambu Studio.
  • Press Shift-Command-4 to start a selected-area screenshot.
  • Drag the crosshair over the Bambu Studio window.
  • Release the pointer to save the screenshot to your Desktop.
  • Rename the screenshot to build-volume-failure.png in Finder.
  • Move build-volume-failure.png into the home-folder claude-bridge workspace.

Bridge not crossing the plate boundary?

  • Confirm that the active printer profile is the Bambu Lab A1 mini with a 0.4 mm nozzle.
  • Reimport the original concept.stl from the home-folder claude-bridge workspace.
  • Leave the model at its imported scale for this evidence test.

Ask for help if the one-piece bridge does not show the expected plate overflow.

Record the manufacturing evidence

The screenshot preserves what happened. The design brief also needs a written requirement so Claude can use this evidence during the next revision.

  • Return to Finder.
  • Open the home-folder claude-bridge workspace.
  • Double-click bridge-brief.md to open it in its text editor.
  • Scroll to the end of the Safety boundary section.
  • Add the evidence requirement by pasting this sentence on a new line:
The 609.6 mm concept must be segmented because the target build volume is 180 × 180 × 180 mm.

Why record the failure?

This sentence converts the visible plate overflow into a hard requirement. Claude can now revise the bridge from recorded manufacturing evidence.

  • Save bridge-brief.md by pressing Cmd+S.
  • Confirm that the new sentence appears after the safety paragraph.

Evidence sentence missing?

  • Confirm that you edited bridge-brief.md inside the home-folder claude-bridge workspace.
  • Place the sentence after the existing physical load-testing safety paragraph.
  • Save the file again with Cmd+S.

Ask for help with checking the final bridge brief.

Your design brief now carries the plate test forward as a recorded constraint.

  • Choose the second tab if you want to compare the complete saved brief.

✔️ Awesome, I've got everything!

The final sentence records why the one-piece concept needs a segmented revision.

ⓧ I'd like to double check the full code

# Bridge Design Brief

## Question

Can Claude design a two-foot, 3D-printable bridge candidate aimed at a centered 100-pound suspended load?

## Hard constraints

- Overall span: exactly 609.6 mm.
- Target printer profile: Bambu Lab A1 mini.
- Build volume: 180 × 180 × 180 mm.
- Included nozzle: 0.4 mm.
- Material for slicing: PLA.
- Total sliced filament target: below 500 g.
- Total sliced print-time target: below 18 hours.
- Load location: centered at midspan.
- No supports below the span during a future load test.

## Required reasoning before CAD

1. Compare a truss and an arch for this specific centered-load, modular FDM problem.
2. State assumptions and identify the intended load path.
3. Explain why the selected form is easier to segment and print.
4. Identify likely failure locations, especially joints, compression members, and the center crossbeam.
5. Treat 100 pounds as an unverified design target, not a guaranteed capacity.

## Required design progression

1. Create `concept.scad` as a one-piece visual concept with a 609.6 mm span.
2. After the build-volume failure is observed, create `bridge.scad` as a five-panel modular design.
3. Use these exact `part` selector values in `bridge.scad`:
   - `preview`
   - `start_panel`
   - `middle_panel`
   - `end_panel`
   - `crossbeam`
   - `coupon`
4. Use a starting fit clearance of 0.3 mm.
5. Keep all individual exported parts within 180 × 180 × 180 mm.
6. Orient exported truss panels flat so their structural plane lies on the print bed.

## Evidence required before printing

- Every STL fits the target build volume.
- Bambu Studio is configured for the A1 mini, 0.4 mm nozzle, PLA, and a 0.20 mm process.
- Filament weights are summed across all plates.
- Estimated print times are summed across all plates.
- Results are labeled PASS or FAIL against 500 g and 18 hours.

## Safety boundary

This design is not certified structural hardware. Do not stand, sit, or place a person on it. Physical load testing belongs in a separate supervised project with rated supports, an exclusion zone, eye protection, and a remote loading method.

The 609.6 mm concept must be segmented because the target build volume is 180 × 180 × 180 mm.

What should match?

The original requirements remain unchanged. The build-volume evidence sentence appears at the end of the file.

Before your final check, do you expect the screenshot plus the brief to tell the same manufacturing story?

  • In Finder, confirm that build-volume-failure.png appears inside the home-folder claude-bridge workspace.
  • Return to Bambu Studio.
  • Confirm that the imported bridge still extends beyond the A1 mini plate boundary.
  • Return to bridge-brief.md.
  • Confirm that the final sentence records the 180 × 180 × 180 mm build-volume constraint.

You now have matching visual plus written evidence of the build-volume failure. The Bambu Studio project preserves the unprintable one-piece candidate for comparison.

The obstacle is now measurable. Next up, you'll use that evidence to turn the one-piece concept into a modular bridge candidate.

Create Printable Bridge Parts

The oversized concept has exposed the bridge's manufacturing problem. A 609.6 mm model cannot fit inside the target 180 mm build volume.

Segmentation converts that failure into a printable design strategy. You will use Claude Code to create a parametric model with flat truss panels plus a clearance coupon for FDM fit testing.

In this step, get ready to:
  • Create the segmented bridge.scad revision.
  • Preview the complete five-bay bridge assembly.
  • Export five printable STL part types.
Ask Claude for the segmented revision

Each of the five bays measures 121.92 mm because the 609.6 mm span is divided evenly. Start panels cap one end while end panels cap the other.

Middle panels connect the bays through complementary lap joints. The 0.3 mm clearance is a starting value that the fit coupon makes testable before a full print.

  • Switch back to the signed-in Claude Code session in Terminal.
  • Ask Claude to reread bridge-brief.md.
  • Ask Claude to create bridge.scad as a five-panel modular revision.
  • Require each panel to measure 121.92 mm along the span.

Why segmentation and a fit coupon?

Segmentation keeps every individual component inside the printer's build volume. Complementary tongues plus receiving notches reconnect those components into the full span.

A fit coupon isolates the joint geometry in a small test piece. Physical printing must confirm whether the 0.3 mm starting clearance suits the chosen printer plus material.

  • Require the variables part, span, panel_count, panel_length, truss_height, truss_thickness, chord_width, member_width, bridge_width, crossbeam_size, tongue_depth, tongue_height, fit_clearance, plus $fn.
  • Require the modules member_2d, panel_profile, panel_flat, panel_standing, crossbeam, fit_coupon, plus bridge_assembly.
  • Require the selector values preview, start_panel, middle_panel, end_panel, crossbeam, plus coupon.
  • Require the panel selectors to use panel_flat for print orientation.
  • Require the assembly preview to show two side trusses plus ten crossbeams.
  • Approve the file-write request if Claude asks for permission.
  • Return to the existing claude-bridge workspace in Finder.
  • Confirm that bridge.scad is listed beside concept.scad.

Good progress. The workspace now preserves the failed one-piece concept alongside its segmented replacement.

✔️ Awesome, I've got everything!

Your bridge.scad file contains the segmented design. Save it before previewing the assembly.

ⓧ I'd like to double check the full code

  • Compare bridge.scad with the complete reference below.
  • Replace any differing lines with the reference version.
  • Save bridge.scad.
part = "preview";

span = 609.6;
panel_count = 5;
panel_length = span / panel_count;
truss_height = 65;
truss_thickness = 8;
chord_width = 10;
member_width = 8;
bridge_width = 80;
crossbeam_size = 10;
tongue_depth = 8;
tongue_height = 4;
fit_clearance = 0.3;
$fn = 32;

module member_2d(a, b, width) {
    hull() {
        translate([a[0], a[1], 0])
            circle(d = width);
        translate([b[0], b[1], 0])
            circle(d = width);
    }
}

module panel_profile(kind) {
    difference() {
        union() {
            member_2d(
                [chord_width / 2, chord_width / 2],
                [panel_length - chord_width / 2, chord_width / 2],
                chord_width
            );

            member_2d(
                [chord_width / 2, truss_height - chord_width / 2],
                [panel_length - chord_width / 2, truss_height - chord_width / 2],
                chord_width
            );

            member_2d(
                [chord_width / 2, chord_width / 2],
                [chord_width / 2, truss_height - chord_width / 2],
                member_width
            );

            member_2d(
                [panel_length / 2, chord_width / 2],
                [panel_length / 2, truss_height - chord_width / 2],
                member_width
            );

            member_2d(
                [panel_length - chord_width / 2, chord_width / 2],
                [panel_length - chord_width / 2, truss_height - chord_width / 2],
                member_width
            );

            member_2d(
                [chord_width / 2, chord_width / 2],
                [panel_length / 2, truss_height - chord_width / 2],
                member_width
            );

            member_2d(
                [panel_length / 2, truss_height - chord_width / 2],
                [panel_length - chord_width / 2, chord_width / 2],
                member_width
            );

            if (kind != "end") {
                translate([
                    panel_length - 0.01,
                    chord_width / 2 - tongue_height / 2
                ])
                    square([tongue_depth + 0.01, tongue_height]);

                translate([
                    panel_length - 0.01,
                    truss_height - chord_width / 2 - tongue_height / 2
                ])
                    square([tongue_depth + 0.01, tongue_height]);
            }
        }

        if (kind != "start") {
            translate([
                -0.01,
                chord_width / 2 - (tongue_height + fit_clearance) / 2
            ])
                square([
                    tongue_depth + fit_clearance + 0.02,
                    tongue_height + fit_clearance
                ]);

            translate([
                -0.01,
                truss_height - chord_width / 2 -
                    (tongue_height + fit_clearance) / 2
            ])
                square([
                    tongue_depth + fit_clearance + 0.02,
                    tongue_height + fit_clearance
                ]);
        }

        translate([
            panel_length / 2 - (crossbeam_size + fit_clearance) / 2,
            chord_width / 2
        ])
            square([
                crossbeam_size + fit_clearance,
                chord_width / 2 + 0.01
            ]);

        translate([
            panel_length / 2 - (crossbeam_size + fit_clearance) / 2,
            truss_height - chord_width / 2
        ])
            square([
                crossbeam_size + fit_clearance,
                chord_width / 2 + 0.01
            ]);
    }
}

module panel_flat(kind) {
    linear_extrude(height = truss_thickness, convexity = 10)
        panel_profile(kind);
}

module panel_standing(kind) {
    translate([0, truss_thickness, 0])
        rotate([90, 0, 0])
            panel_flat(kind);
}

module crossbeam() {
    difference() {
        cube([crossbeam_size, bridge_width, crossbeam_size]);

        for (y_position = [0, bridge_width - truss_thickness]) {
            translate([
                -0.01,
                y_position - fit_clearance / 2,
                -0.01
            ])
                cube([
                    crossbeam_size + 0.02,
                    truss_thickness + fit_clearance,
                    crossbeam_size / 2 + 0.01
                ]);
        }
    }
}

module fit_coupon() {
    union() {
        cube([20, 20, 6]);

        translate([20 - 0.01, 8, 0])
            cube([tongue_depth + 0.01, tongue_height, 6]);

        translate([40, 0, 0])
            difference() {
                cube([20, 20, 6]);

                translate([
                    -0.01,
                    8 - fit_clearance / 2,
                    -0.01
                ])
                    cube([
                        tongue_depth + fit_clearance + 0.02,
                        tongue_height + fit_clearance,
                        6.02
                    ]);
            }
    }
}

module bridge_assembly() {
    union() {
        for (side_y = [0, bridge_width - truss_thickness]) {
            for (i = [0:panel_count - 1]) {
                translate([i * panel_length, side_y, 0])
                    panel_standing(
                        i == 0 ? "start" :
                        i == panel_count - 1 ? "end" :
                        "middle"
                    );
            }
        }

        for (i = [0:panel_count - 1]) {
            x_position = i * panel_length +
                panel_length / 2 - crossbeam_size / 2;

            translate([x_position, 0, 0])
                crossbeam();

            translate([
                x_position,
                0,
                truss_height - crossbeam_size
            ])
                crossbeam();
        }
    }
}

if (part == "preview") {
    bridge_assembly();
} else if (part == "start_panel") {
    panel_flat("start");
} else if (part == "middle_panel") {
    panel_flat("middle");
} else if (part == "end_panel") {
    panel_flat("end");
} else if (part == "crossbeam") {
    crossbeam();
} else if (part == "coupon") {
    fit_coupon();
} else {
    echo("Unknown part selector");
}

What does this code do?

  • The part selector switches between the assembled preview plus each printable component.
  • The panel_profile module creates the truss members plus the mating joint geometry.
  • The panel_flat module extrudes each panel in its print orientation.
  • The panel_standing module rotates each flat panel into the assembly view.
  • The crossbeam module creates the 80 mm connector with two mating slots.
  • The fit_coupon module pairs an 8 mm tongue with an 8.3 mm slot.
  • The bridge_assembly module repeats five panels on each side of the span.
Inspect the complete assembly

The preview mode rotates the flat export geometry into the assembled position. This view lets you inspect how the segmented pieces recreate the full bridge.

  • In Finder, double-click bridge.scad to open it in OpenSCAD.
  • Confirm that the first line reads part = "preview";.

Before you preview the revision, do you expect ten separate truss panels to read as one continuous bridge?

  • Preview the complete assembly by pressing F5.

You should see five connected bays spanning 609.6 mm. Two side trusses are joined by ten crossbeams.

How the quantities add up

Each side uses one start panel plus three middle panels plus one end panel. Both sides therefore contain two start panels plus six middle panels plus two end panels.

Each bay has one lower crossbeam plus one upper crossbeam. Five bays produce ten crossbeams.

Preview missing bridge geometry?

Check that the selector is exactly part = "preview";. Another selector displays only one exportable component.

Compare bridge.scad with the full reference if OpenSCAD reports a syntax problem.

Ask for help with the segmented preview.

Export the printable part types

The selector isolates one component without duplicating the model logic. Every panel selector calls panel_flat so its structural plane lies on the print bed.

Use the export map

  • The start_panel selector exports as start_panel.stl.
  • The middle_panel selector exports as middle_panel.stl.
  • The end_panel selector exports as end_panel.stl.
  • The crossbeam selector exports as crossbeam.stl.
  • The coupon selector exports as fit_coupon.stl.
  • Change the first line of bridge.scad to part = "start_panel";.
  • Render the start panel by pressing F6.
  • Select File in the OpenSCAD menu bar.
  • Select Export.
  • Select Export as STL....
  • Save the model as start_panel.stl inside claude-bridge.

The first printable panel now exists as a separate file. Its flat orientation keeps the truss plane parallel to the print bed.

  • Repeat the render-and-export workflow for every remaining row in the export map.
  • Restore the first line to part = "preview";.
  • Save bridge.scad.
  • Return to the claude-bridge workspace in Finder.
  • Confirm that all five exported STL files are listed.

Why every component fits

A panel measures 121.92 mm before its right tongue. The longest panel dimension reaches 129.92 mm after the 8 mm tongue is included.

The crossbeam measures 10 × 80 × 10 mm. The fit coupon spans 60 × 20 × 6 mm.

Every exported component stays below 180 mm in every dimension. The full assembly still spans 609.6 mm.

Missing an exported part?

Check the selector spelling against the export map. Render with F6 before each export.

If a panel exports upright, compare its selector branch with the reference. Every panel branch must call panel_flat.

Ask for help with the missing or incorrectly oriented STL.

Before the final preview, do you expect restoring the selector to rebuild the complete bridge without changing the exported STL files?

  • Switch back to bridge.scad in OpenSCAD.
  • Preview the restored assembly by pressing F5.

You should again see five connected bays across the 609.6 mm span. The viewport shows two side trusses plus ten crossbeams.

That completes the manufacturability redesign. Your workspace now contains flat truss panels plus slotted crossbeams plus a clearance coupon.

Your printable component library is ready. Next up, you will slice the complete bridge to measure its filament weight plus estimated print time.

Audit the Manufacturing Constraints

Your segmented bridge now fits the Bambu Lab A1 mini build volume one part at a time. You have solved the size failure that blocked the one-piece concept.

The complete set can still exceed the material target. It can also exceed the print-time target.

Bambu Studio is the slicer that converts your geometry into manufacturing evidence. It estimates the filament mass plus the production time before you commit any material.

In this step, get ready to:
  • Assemble the complete bridge candidate across multiple plates.
  • Slice every plate with the baseline manufacturing setup.
  • Produce an evidence-based constraint report.
Build the full slicing project

A Bambu Studio plate represents one slicing job. A multi-plate project keeps the complete bridge candidate in one place while each plate stays within the printer boundary.

  • Switch back to Bambu Studio from earlier.
  • Click New Project.
  • Import start_panel.stl twice with Add in the top toolbar.
  • Import middle_panel.stl six times with Add in the top toolbar.
  • Import end_panel.stl twice with Add in the top toolbar.
  • Import crossbeam.stl ten times with Add in the top toolbar.
  • Click Arrange in the top toolbar.

You'll see 20 structural models distributed across one or more virtual plates. Each model stays inside a plate boundary.

Why use multiple plates?

The complete bridge needs more surface area than one A1 mini plate provides. Multiple plates divide the production plan into separate slicing jobs.

Keeping those jobs in one project gives you a complete view of the material estimate. It also gives you a complete view of the time estimate.

  • Click Add plate in the top toolbar to create an empty plate.
  • Click the blank area of the new plate to make it current.
  • Import fit_coupon.stl with Add.
  • Count the imported models by filename in the workspace.

You should count two start_panel.stl models. You should count six middle_panel.stl models.

You should count two end_panel.stl models. You should count ten crossbeam.stl models.

You should count one fit_coupon.stl model. It should be the only model on its plate.

Good progress. Your project now represents every component needed for the bridge candidate plus its clearance test.

Missing parts or crowded plates?

  • Import any STL again if its model count is too low.
  • Click Arrange again if a structural model remains outside a plate boundary.
  • Drag the fit coupon onto its empty plate if it appears beside a structural model.

Ask for help diagnosing the plate arrangement with this Bambu Studio project check.

Slice the baseline candidate

The baseline keeps the printer profile fixed while the slicer measures your design. Consistent settings make the resulting mass estimate comparable across every plate.

  • Select Bambu Lab A1 mini with a 0.4 mm nozzle in the Printer selector.
  • Select PLA in the Filament selector.
  • Select the 0.20 mm preset in the Process selector.

You'll see Bambu Lab A1 mini with a 0.4 mm nozzle under Printer. You'll see PLA under Filament.

The Process selector shows 0.20 mm.

Before you slice, do you expect the complete set to stay below both numerical limits?

  • Open the menu beside Slice.
  • Select Slice All.

You'll see Preview open after Bambu Studio finishes slicing every plate. Each sliced model is represented by visible toolpaths.

  • Select each plate in Preview.
  • Confirm every model remains inside its plate boundary.
  • Confirm the fit coupon remains alone on its plate.

You'll see sliced toolpaths on every plate. The fit coupon remains separate from the structural parts.

What does slicing prove?

Slicing confirms that Bambu Studio can generate FDM toolpaths for each arranged model. Its estimates quantify the digital candidate's material use plus its production time.

Slicer evidence covers manufacturing constraints. A controlled physical test remains necessary before making any load-capacity claim.

Unable to slice every plate?

  • Return to Prepare if Bambu Studio flags a model outside the plate boundary.
  • Click Arrange after returning to the model arrangement view.
  • Check the Printer selector if the plate dimensions look different from the A1 mini profile.

Ask for help with a failed multi-plate slice.

Produce the constraint report

Plate-level values become useful when you combine them into whole-project totals. Your report turns those totals into explicit manufacturing verdicts.

  • Create a constraint report with one row for every sliced plate.
  • Label the report columns for plate number, Filament weight, plus Line type time.

Your report now has a place for every value needed from Preview.

  • Record each plate's displayed weight from Filament.
  • Record each plate's displayed estimated time from Line type.

Every plate row now contains a material value. Every plate row also contains a time value.

  • Convert the recorded time values to one common unit.
  • Sum every plate's filament weight.

Your report now shows the total estimated filament mass for the complete sliced project.

  • Sum every plate's estimated print time.

Your report now shows the total estimated production time for the complete sliced project.

Before you grade the totals, which manufacturing constraint do you expect the bridge candidate to pass?

  • Mark build volume as PASS only if every model remains inside its plate boundary. Otherwise mark it as FAIL.
  • Mark mass as PASS if the summed filament weight is below 500 g. Otherwise mark it as FAIL.

The report now contains a build-volume verdict. It also contains a mass verdict.

  • Mark time as PASS if the summed estimate is below 18 hours. Otherwise mark it as FAIL.
  • State that 100 pounds remains an unverified target requiring later physical testing.

The report now separates measurable manufacturing evidence from future strength testing.

Choose the outcome that matches your two numerical verdicts.

✔️ Both numerical limits pass

Your baseline candidate stays below the material target. It also stays below the print-time target.

  • Keep the current bridge.scad geometry unchanged.

ⓧ One or both numerical limits fail

A failed numerical limit gives Claude measured evidence for a focused revision. The existing report becomes the baseline for the next slice.

  • Return to your Claude Code session from earlier.
  • Send one message containing the measured mass plus the measured time. In that message, allow changes only to member_width, chord_width, truss_height, or panel_count.
  • Return to OpenSCAD from earlier.
  • Render each affected part selector.
  • Export each affected STL file again.
  • Replace every affected structural model in the existing multi-plate project.
  • Select Slice All again.
  • Replace the earlier report values with the revised slicing results.

Before you inspect the final report, do you expect slicer data to certify the centered 100-pound target?

  • Review the final report for a weight entry plus a time entry from every plate.
  • Confirm the report includes summed totals plus three explicit manufacturing verdicts.
  • Confirm the report labels the 100-pound target as unverified.

You'll see PASS or FAIL for build volume. You'll see a separate verdict for mass.

You'll see a separate verdict for time. The report keeps load capacity outside the slicer's evidence boundary.

That's the digital audit complete. Your bridge candidate now has manufacturing verdicts backed by slicer evidence.

Secret mission

Win Back 10% of the Print Time

Keep the bridge geometry fixed while you test one coarser Process preset. Measure whether it cuts estimated print time by at least 10% without breaking the mass, time, or build-volume limits.

Clean Up Your Resources

Clean Up Your Resources

Your bridge workspace contains only local files, so leaving it in place creates no ongoing project cost. Choose whether to keep it ready, archive it for later, or delete it entirely.

Resources you used:

  • Local source files: the ~/claude-bridge folder containing bridge-brief.md, concept.scad, concept.stl, and bridge.scad.
  • Printable exports: start_panel.stl, middle_panel.stl, end_panel.stl, crossbeam.stl, and fit_coupon.stl.
  • Build-volume evidence: build-volume-failure.png.
  • Slicing evidence: the saved Bambu Studio project, the baseline constraint report, and the coarser-preset comparison.

Keep everything running

No action is needed. Choose this option if you are still refining the digital bridge or preparing for the follow-on printing project.

  • Keep ~/claude-bridge in your home folder.
  • Keep the saved Bambu Studio project with the 0.20 mm baseline values.
  • Keep the coarser-preset comparison beside the baseline constraint report.

Pause - I'll come back to this later

Pausing keeps every design artifact while clearing the active design tools from your Mac. The archive remains ready for the follow-on printing project.

  • Use Finder to create a zip archive of the claude-bridge folder in your home folder.
  • Confirm the zip archive appears beside the original folder.
  • Close OpenSCAD.
  • Close Bambu Studio.

Delete - I don't want to use this again

This option removes all project resources for a clean start. Deleting the folder is permanent, so the command targets only the claude-bridge workspace in your home folder.

  • Delete the ~/claude-bridge workspace by running this command:
rm -rf ~/claude-bridge

What does this command remove?

This command recursively removes the claude-bridge folder plus every artifact inside it. It leaves the design apps installed on your Mac.

  • Use Finder to view your home folder.
  • Confirm that claude-bridge no longer appears.

Still see the folder?

Check that the command targets ~/claude-bridge exactly.

Help me remove this folder safely.

Your Mac is now clear of the local bridge workspace. No cloud resource or printer hardware needs cleanup.

Nice Work!

Nice Work!

You did it! You turned strict engineering constraints into a sliced modular bridge candidate. Your evidence now separates manufacturability from the unverified 100-pound design target.

You've learned how to:

  • Write a constraint-led engineering brief that keeps the 100-pound load as an unverified target before asking Claude Code to generate a one-piece OpenSCAD concept.
  • Turn a visible build-volume failure into a five-panel parametric bridge with flat-printing trusses, ten crossbeams, and a fit-clearance coupon.
  • Use Bambu Studio slicing evidence to produce a constraint report with explicit PASS or FAIL results for part fit, total filament mass, and estimated print time.
  • Secret Mission: Compare a coarser process preset against the 0.20 mm baseline with unchanged bridge geometry. Measure whether it saves at least 10% while preserving the mass, time, and build-volume constraints.

Ready to quiz yourself?