Cad construction

CAD Construction

A structured workflow for translating a finalized design into a parametric CAD model. This skill assumes the design exploration phase is done — the concept is decided, the remaining work is turning it into geometry.

When to use this skill

• The design concept is settled (possibly via design-first-iteration) and implementation can start
• The user needs to plan component decomposition before opening CAD
• The user wants a parameter table structured before sketching begins
• The user needs a step-by-step construction sequence (sketches → features → assembly)
• The user wants a construction plan document they can follow or hand over

When NOT to use

• Open exploration of design options → design-first-iteration
• General mechanical design rules (overhang, wall thickness, snap-fits) → mechanical-design-principles
• Writing scripts or Python code for CAD automation → cad-api-scripting
• Reviewing an existing CAD model for quality issues → use a dedicated design-review pass with CAD context

Workflow — 4 phases

Phase 1: Requirements consolidation

The design exploration has already happened. This phase is about confirming and writing down the requirements that will drive the CAD work — not re-opening decisions.

Inputs to capture:

• Primary function (what the part must do)
• Secondary requirements (nice-to-have, optional features)
• Environmental conditions (temperature, moisture, UV, vibration, IP rating if relevant)
• Manufacturing method (FDM 3D print, SLA, CNC, injection molding — each has different CAD implications)
• Unresolved conflicts carried over from design phase (if any — flag them explicitly)

Output: A short requirements block at the top of the construction plan. Not a re-exploration.

Clarifying questions (if gaps remain): Max 2–3 targeted questions for truly unresolved aspects. Example:

• "IP rating confirmed at IP65, or still IP54 as earlier?"
• "Final material choice — ABS or ASA?"
• "Tool-less opening stays as requirement?"

Phase 2: Component decomposition

Break the assembly into logical components — each component is a unit that will have its own sketches, features, and manufacturing.

Tree structure (generic, applies to most CAD systems):

Main Assembly
├── Component 1 (e.g., housing bottom)
│   ├── Body: main structure
│   └── Body: mounting features
├── Component 2 (e.g., housing lid)
└── Purchased parts (screws, inserts, seals, electronics)

For each component, define:

• Function: what it does mechanically / functionally
• Material: PLA / PETG / ASA / ABS / PA-CF / aluminum / steel / etc.
• Manufacturing method: FDM 3D print, SLA, CNC, sheet metal, injection
• Critical interfaces: where it mates with other components (tolerances come from these interfaces)
• Manufacturing constraints: print orientation, support strategy, post-processing needs

Purchased parts list:

• Fasteners (type, size, length, count)
• Threaded inserts (heat-set / press-fit, M-size)
• Seals (O-rings with dimensions, gaskets)
• Electronics if relevant (part numbers help later)

Rule: Start with the fewest components that make the design buildable. Every additional component adds a tolerance stackup and an assembly step. See mechanical-design-principles → Principle 3 ("Monolithic before assembled") and Principle 7 ("Minimum interfaces") for the underlying reasoning. Justify each split.

Phase 3: Parameter design

The most important phase. A well-parameterized model can adapt to new requirements in minutes; a hard-coded one takes hours to change. See mechanical-design-principles → Principle 5 ("Parametric construction from day one") for the underlying rationale.

Parameter hierarchy — three tiers:

Tier 1: Primary parameters (independent)

Base dimensions that fundamentally define the design. These are the values the user actually thinks about and adjusts:

main_length = 120 mm
main_width = 85 mm
main_height = 40 mm

Tier 2: Derived parameters (formulas)

Values computed from Tier 1. Never hard-coded — always expressions:

wall_thickness = nozzle_diameter * 4         # 4 perimeters
inner_height = main_height - wall_thickness * 2
seal_groove_width = seal_diameter * 1.05

Tier 3: Tolerances and fastener specs

Manufacturing-specific values, grouped separately so they can be adjusted independently:

screw_diameter = 4 mm                  # M4
heat_insert_diameter = 5.2 mm          # M4 heat-set + 0.2 mm tolerance
clearance_fit_tolerance = 0.3 mm       # moving parts
press_fit_tolerance = -0.15 mm         # permanent fits

Naming convention: category_description. Descriptive names, no abbreviations like w1, d2. Examples:

• housing_wall_thickness (not wt)
• mounting_screw_spacing
• tolerance_clearance_fit

Reference values for FDM 3D print tolerances: See mechanical-design-principles → Decision heuristics for the authoritative tolerance grid (press fits, clearance fits, heat-set inserts, O-ring grooves). Use those values here — do not re-derive.

Phase 4: Construction sequence

A step-by-step plan the CAD session will follow. This is the document that turns "I know what I'm building" into "I know which sketch to draw next."

Template structure:

Step 1: Setup

• Create new design / document
• Create user parameters (from Phase 3 table)
• Create top-level component structure (from Phase 2)

Step 2: Main geometry (for each major feature)

• Sketch: plane, geometry, constraints, dimensions (referencing parameters by name)
• Operation: extrude / revolve / loft / sweep, with parameters
• Result: what body / feature this produces

Step 3: Detail features

• Fillets and chamfers (with parameters, not literal radii)
• Holes (location, size, depth — all parameterized)
• Grooves, pockets, ribs
• Thread features if applicable

Step 4: Sub-components and assembly

• Sub-component creation and positioning
• Joints / mates / constraints between components
• Interference checks

Step 5: Manufacturing annotations

• Print orientation with justification
• Support strategy (where, why)
• Post-processing steps (insert pressing temperature, sanding zones, etc.)

Output format

The deliverable of this skill is a construction plan document — markdown-first, optionally expanded into an interactive HTML tool for parameter editing.

Minimum viable construction plan:

• Requirements block (Phase 1 output)
• Component tree with per-component specs (Phase 2 output)
• Parameter table with three tiers (Phase 3 output)
• Construction sequence (Phase 4 output)

Template: see assets/construction_plan_template.md in this skill folder.

Interactive tool (optional): if the user wants live parameter adjustment, an HTML artifact with a parameter editor and live calculation of derived values. Good match for mobile / handy-friendly review during CAD work.

Best practices

Parametrization discipline

• Every dimension comes from a parameter. If a literal number appears in a sketch, something is wrong.
• Hierarchy: primary → derived → tolerances. Never mix the levels.
• Naming: descriptive always. The parameter table should be readable by someone who didn't build the model.

Design for manufacturing in the CAD sequence

Manufacturing constraints (print orientation, overhang angle, layer adhesion direction, wall-thickness grid) are covered in detail by mechanical-design-principles. This skill applies those rules in the CAD sequence — specifically:

• Print orientation is decided in Phase 2, together with component decomposition, not deferred to export.
• Every component's critical surfaces are identified against the chosen orientation before sketching begins.
• Support-requiring geometry is redesigned here, not accepted as "we'll just add supports later."

For the underlying rules (45° overhang, wall-thickness = n × perimeters × nozzle, layer-adhesion anisotropy) see mechanical-design-principles Principle 4.

When to not parameterize

• Logos, serial number plates, cosmetic text — not worth parameterizing.
• One-off test parts that will never be iterated — parameters add friction for no benefit. But this is a trap: "one-off" parts often turn out to need iteration.

Anti-patterns

• Starting CAD without a parameter table. Every dimension ends up hard-coded, and the first design change wastes an afternoon.
• Over-decomposition. Splitting into 8 components because "that's how it would be molded." FDM doesn't have injection-mold constraints. See mechanical-design-principles → Principle 3.
• Premature detailing. Adding fillets and chamfers before the main shape is proven. Fillets go in late.
• Hard-coded tolerances. 5.2 mm for an M4 insert is a magic number. M4_nominal + tolerance_insert is the same value, expressed as intent.
• Ignoring print orientation until export. Leads to geometry that can't be printed without aggressive support.

Handover checklist

Before calling a construction plan complete:

• Requirements block written (confirmed, not re-opened)
• Every component has: function, material, manufacturing method, critical interfaces
• Purchased parts list with sizes and counts
• Parameter table with three tiers, all names descriptive
• Construction sequence written step by step
• Print orientation stated and justified
• Unresolved issues flagged explicitly (not hidden)