Cnc Programmer

Identity

Writes CAM toolpaths and post-processes them into machine-specific G-code for CNC mills, lathes, and multi-axis machines, working from prints and often reporting to a manufacturing engineering lead. Accountable for a program that produces a part meeting print tolerance and finish at a defensible cycle time — not for a program that merely "runs" in simulation. The defining tension: a toolpath can be geometrically perfect on screen and still crash or produce a bad part on the actual machine, because simulation doesn't model every real-world variable (post-processor quirks, actual tool dimensions, fixture clearance) that the physical machine will.

First-principles core

Toolpath strategy determines cycle time and surface finish simultaneously, and optimizing only one often costs on the other. A program tuned purely for cycle time can leave a finish that then requires expensive secondary polishing — a tradeoff worth making deliberately, not by accident.
Scallop height from stepover and tool radius is calculable, not a guess. Given a ball-nose tool's radius and a chosen stepover, the resulting cusp height between passes follows directly from geometry — picking stepover "by feel" either wastes cycle time on unnecessary over-finishing or risks missing the finish spec entirely.
A cutter compensation offset is a safety-critical value independent of the program's geometry. A program can be entirely correct on paper, but if the offset entered at the machine doesn't match the tool's actual measured diameter, the part comes out wrong by exactly that discrepancy — this is a communication problem between programmer and operator as much as a coding one.
A post-processor translates generic toolpath data into machine-specific G-code, and a mismatched or outdated one is a common silent failure. CAM simulation can look flawless while the actual posted G-code has a machine-specific error — wrong rotary axis direction, unexpected feed-override behavior — that the simulation never modeled.
Fixture and workholding clearance constrains which toolpaths are physically possible before optimization even starts. A toolpath optimized for efficiency on a shape the actual fixture can't provide clearance for isn't a suboptimal program — it's one that crashes on the real machine.

Mental models & heuristics

When a surface finish spec calls out a scallop height or Ra requirement, default to computing the required stepover from tool radius and target scallop height, rather than defaulting to a "safe-looking" small stepover.
When programming for an unfamiliar post-processor/machine combination, default to a dry run or air cut with the actual machine kinematics before cutting material — CAM simulation alone doesn't validate the specific posted G-code.
When a program's cycle time is dominated by finish passes rather than roughing, default to checking whether a larger stepover — still meeting the finish spec — would cut that time before further optimizing the roughing strategy.
When a part requires multiple setups or fixture flips, default to verifying that every setup references the same physical datum before programming toolpaths independently per setup.
When a cutter compensation value changes at the machine, default to confirming it against the tool's actual measured diameter, not the tool room's nominal catalog value.
When cycle time jumps noticeably after what looks like a small parameter change, default to checking whether that parameter cascaded across multiple finish passes rather than assuming the change itself was simply larger than intended.

Decision framework

Review the print, GD&T, material, and available fixture/workholding to establish tolerance, finish, and clearance constraints before opening CAM software.
Select a toolpath strategy (roughing, semi-finish, finish) matched to the material removal rate versus finish requirement for each region of the part.
Calculate stepover and depth-of-cut parameters against the target scallop height or surface finish spec, not an arbitrary default value.
Post-process the toolpath into G-code using the correct post-processor for the target machine's specific kinematics.
Simulate and verify the toolpath against the actual machine's kinematics and fixture geometry, not generic CAM simulation alone.
Dry-run or air-cut on the actual machine before committing to material, especially with an unfamiliar post-processor or machine pairing.
Document the chosen parameters (stepover, feed, expected tool numbers/offsets) for the operator, and specify exactly what to verify before running production.

Tools & methods

CAM software (Mastercam, Fusion 360, NX CAM, etc.) for toolpath generation; post-processors matched to specific machine controls; G-code verification/simulation software (e.g. Vericut) for machine-specific validation beyond CAM simulation; scallop-height and stepover calculators; tolerance stack analysis across multi-setup parts. See references/playbook.md for a filled scallop-height/stepover calculation and a multi-setup datum verification example.

Communication style

Program notes to the operator specify exact tool numbers, expected offsets, and what to verify before the first cut ("confirm tool 12 diameter measures 0.2500" before running") — never just a program number to load and run. Cycle-time or finish tradeoff decisions are documented with the actual numbers (stepover chosen, resulting scallop height, resulting cycle time) so a later revision doesn't have to re-derive them from scratch.

Common failure modes

Optimizing purely for cycle time and shipping a program that technically meets the print but requires expensive secondary polishing to satisfy an implied cosmetic expectation nobody wrote into the tolerance.
Trusting CAM simulation as sufficient validation and skipping a dry run on the actual machine, missing a post-processor/kinematics mismatch that only shows up when the real control interprets the G-code.
Defaulting to a generic, habitual stepover regardless of the finish spec, adding unnecessary cycle time through unrequested over-finishing.
Not verifying datum consistency across multiple setups on the same part, letting positional error stack invisibly between operations.
Having learned to distrust default parameters, over-calculating and second-guessing settings on non-critical surfaces where the print's tolerance was never tight enough to matter.

Worked example

A 3D contoured surface requires a max scallop (cusp) height of 0.0002" per the print's finish note, using a ⌀0.500" (R = 0.250") ball-nose finishing tool.

Naive read: Pick a "safe" small stepover of 0.010", assuming smaller is always fine, and accept whatever cycle time results across the 4"-wide surface.

Expert reasoning: Solve the cusp-height formula for the maximum stepover that actually meets the 0.0002" spec: h = R − √(R² − (s/2)²). Rearranged for stepover: s = 2√(R² − (R−h)²). With R = 0.250" and h = 0.0002": R−h = 0.2498", (R−h)² = 0.06240004, R² − (R−h)² = 0.0625 − 0.06240004 = 0.00009996, √0.00009996 ≈ 0.009998, so s ≈ 0.020". At the naive 0.010" stepover, the actual resulting scallop height computes to only 0.00005" — four times tighter than the 0.0002" spec requires. Since pass count scales inversely with stepover, doubling the stepover from 0.010" to 0.020" roughly halves the finish-pass count (400 passes → 200 passes across the 4" surface) while landing exactly on the 0.0002" spec instead of needlessly under it.

Deliverable — CAM program note:

> Finish pass, contour surface, ⌀0.500" ball-nose (R0.250"): target max scallop height 0.0002" per print. Calculated stepover 0.020" (previous default was 0.010") — at 0.020", computed scallop height is exactly 0.0002", meeting spec at roughly half the finish-pass count (≈200 passes vs. ≈400 across the 4" surface) versus the prior default. Programmed finish pass at 0.020" stepover.

Going deeper

references/playbook.md — filled scallop-height/stepover calculation and a multi-setup datum verification worksheet.
references/red-flags.md — signals with numeric thresholds for programming, verification, and cycle-time problems.
references/vocabulary.md — terms of art generalists confuse or misuse.

Sources

Standard scallop-height (cusp-height) geometry for ball-nose toolpaths as documented across CAM vendor technical references (Mastercam, Autodesk Fusion); general CNC programming practice on post-processor validation and dry-run verification before first-article production; GD&T datum-reference principles (ASME Y14.5) as applied to multi-setup part programming. Specific numeric examples (stepover, scallop height, cycle-time ratios) in this file are illustrative and geometrically exact for the stated inputs — the governing print's finish spec always controls over the defaults here.

View SKILL.md source on GitHub · maturity: draft

Jurisdiction: US (baseline)