Skip to content
Skills Library
Other · Analysis

cnc-programmer

/cnc-programmer

Use when a task needs the judgment of a Computer Numerically Controlled (CNC) Tool Programmer — calculating stepover from a scallop-height/surface-finish spec instead of picking one by feel, deciding whether a toolpath needs a dry run before cutting material on an unfamiliar post-processor/machine pairing, verifying datum consistency across multiple part setups, or diagnosing why cycle time jumped after a "minor" parameter change.

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when a task needs the judgment of a Computer Numerically Controlled (CNC) Tool Programmer — calculating stepover from a scallop-height/surface-finish spec instead of picking one by feel, deciding whether a toolpath needs a dry run before cutting material on an unfamiliar post-processor/machine pairing, verifying datum consistency across multiple part setups, or diagnosing why cycle time jumped after a "minor" parameter change.

Triggers from the description

minor
Original author description

Use when a task needs the judgment of a Computer Numerically Controlled (CNC) Tool Programmer — calculating stepover from a scallop-height/surface-finish spec instead of picking one by feel, deciding whether a toolpath needs a dry run before cutting material on an unfamiliar post-processor/machine pairing, verifying datum consistency across multiple part setups, or diagnosing why cycle time jumped after a "minor" parameter change.

How it works

  1. Identity
  2. First-principles core
  3. Mental models & heuristics
  4. Decision framework
  5. Tools & methods
  6. Communication style
  7. Common failure modes
  8. Worked example
  9. Going deeper
  10. Sources
Original SKILL.md headings · 72 lines, 1,305 words
SKILL.md preview
---
name: cnc-programmer
description: Use when a task needs the judgment of a Computer Numerically Controlled (CNC) Tool Programmer — calculating stepover from a scallop-height/surface-finish spec instead of picking one by feel, deciding whether a toolpath needs a dry run before cutting material on an unfamiliar post-processor/machine pairing, verifying datum consistency across multiple part setups, or diagnosing why cycle time jumped after a "minor" parameter change.
metadata:
  category: engineering
  maturity: draft
  spec: 2
  onet_soc_code: "51-9162.00"
---

# 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

1. **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.
2. **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.
3. **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.
4. **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.
5. **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

1. Review the print, GD&T, material, and available fixture/workholding to establish tolerance, finish, and clearance constraints before opening CAM software.
2. Select a toolpath strategy (roughing, semi-finish, finish) matched to the material removal rate versus finish requirement for each region of the part.
3. Calculate stepover and depth-of-cut parameters against the target scallop height or surface finish spec, not an arbitrary default value.
4. Post-process the toolpath into G-code using the correct post-processor for the target machine's specific kinematics.
5. Simulate and verify the toolpath against the actual machine's kinematics and fixture geometry, not generic CAM simulation alone.
6. Dry-run or air-cut on the actual machine before committing to material, especially with an unfamiliar post-processor or machine pairing.
7. 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](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](references/playbook.md) — filled scallop-height/stepover calculation and a multi-setup datum verification worksheet.
- [references/red-flags.md](references/red-flags.md) — signals with numeric thresholds for programming, verification, and cycle-time problems.
- [references/vocabulary.md](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.
Files in this package (4)
  • SKILL.md 9 KB
  • references/playbook.md 3 KB
  • references/red-flags.md 3 KB
  • references/vocabulary.md 5 KB

Versions

The database has no other skills named cnc-programmer.

Database snapshot: 13.11.2026 · package version 51318526ff8b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100cnc-tool-operator
    Use when a task needs the judgment of a CNC Tool Operator — diagnosing a dimension trending toward its tolerance limit across consecutive parts before it actually crosses, deciding whether to apply a tool wear offset or flag the tool for replacement, evaluating whether a failed…
  • 100image-to-cnc-cut-svg
    Use when an image (photo, line art, logo, or a stage-1 B/W artwork PNG) needs to become an SVG ready for CNC cutting or carving; asks finished size, style, bits and CAM software, then outputs the SVG.
  • 98cnc-station
    Set up and run a CNC operator station - a Windows laptop with gSender on the machine's USB, fed from the Mac with posted G-code and a page of job steps. Use when connecting a GRBL CNC machine, bootstrapping the laptop next to it, writing or syncing a job's steps and files,…
  • 100grinding-machine-operator
    Use when a task needs the judgment of a Grinding/Lapping/Polishing/Buffing Machine Operator — deciding whether a wheel past its dressing interval needs a burn check even when Ra readings stay in spec, verifying surface finish against a measured Ra value rather than feel,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.