613 kHz to Mac M4: A 45-Year CAD Rewrite Turned Into a Practical Playbook for AI-Assisted Legacy Code

Every software organization eventually inherits something nobody wants to own: source files older than the current stack, an original author long gone, and a workflow that still depends on the result. The longest answer to that predicament I have studied belongs to John M. Christy, who began writing a CAD program 45 years ago on a machine clocked at 613 kHz and still builds it 45 years later on a Mac M4 that accepts spoken drafting instructions. Between those two points sit a hand-drawn artwork table, an HP BASIC prototype, a year of retraining in HP Pascal, a shelving in the 1990s, and a 2025 revival carried out mostly with Claude. Treated as an engineering teardown instead of a memoir, it hands a development team what this channel exists to circulate: a rewrite sequence, a commit-gate habit, rules that survived four hardware generations, and hard evidence that readable code has quietly become a machine-readable asset.

Why this case belongs on your delivery backlog

Google's 2025 DORA report, "State of AI-assisted Software Development", surveyed nearly 5,000 technology professionals and puts AI adoption among software development practitioners at around 90%. Its headline is a reversal: AI adoption now correlates positively with software delivery throughput, unlike the 2024 findings, but delivery instability remains elevated (blog.google, 23 September 2025). Christy's one-person shop is a small-scale preview of that same combination. Idea, implementation and verification that once took months now "sometimes take minutes instead of months", yet nothing lands without an automated gate. For a team adopting assistants this quarter, the bottleneck has moved from typing to review, and the review layer is what you must build deliberately.

The case file: one program across four machine generations

Era	Platform and language	What shipped	Durable engineering decision
Late 1970s	HP-85, HP BASIC in ROM, 613 kilohertz clock vs rival machines at 4 megahertz	CADD/85, then CADD/86-87 for the HP-86 and HP-87; listed by Hewlett-Packard as a software supplier	Buy accuracy, not clock speed: binary-coded decimal arithmetic to fifteen significant digits
1980s	HP 9816, HP Pascal	CADD 200, later CADD 200/300, published by Tensegrity, Inc. in Chicago	Store an extent per item so redraw touches only what crosses the screen; name everything descriptively and comment heavily
1983-2012 users	A succession of HP machines	John Hardy's sheet metal, injection-molded plastic, machined parts, schematics and circuit boards; CADD/200-300 drawings	Release the source to a capable customer: wide lines in the 1980s, Gerber output in 2012
2025-2026	Mac M4 plus Claude, with the Pascal printed out and an HP 340 feeding files over a serial link	C3 (short for CADD300_Modern), feature-complete by February 2026; Windows version under way	Split the human role: producer and director plus quality-control tester, instead of typist

Origin: a circle, a light table and a $500,000 problem

The revival began with a wish that predates it. During the 1970s, JMC Engineering was Christy's small company, producing audio products for musicians, instrument preamps and a phase-locked-loop frequency counter that remained accurate at low frequencies. Circuit board artwork was done by hand on a light table, using film, ink and drafting tape of various widths, drawn at four-to-one and photographically reduced, which shrank the errors along with the drawing. At the Design Engineering Show at McCormick Place in Chicago he saw a computer system that could actually draw, running on what was then called a minicomputer, priced at roughly $500,000. That was the problem: he could barely afford $500, let alone $500,000, and since no affordable machine would draw a circle, he taught himself programming and made one.

His first computer was an HP-85. One box held a five-inch screen, a thermal printer and a tape cartridge; HP BASIC came in ROM, engineering graphics came in the language, and there was an easy path to an HP plotter. While other machines ran at 4 megahertz, its clock ran at 613 kilohertz: HP had chosen complex and slow over simple and fast, doing its arithmetic in binary-coded decimal to fifteen significant digits. The answers were right, the machine was not fast. Variable names were either one letter or one letter plus one digit, so you had 286 simple variables and that was it. Inside that box he wrote CADD/85, which could draw circles, lines and boxes and grew a library of schematic symbols. Because the HP-85 sat on engineers' desks worldwide as an instrument controller, it sold quite well, and Hewlett-Packard listed him in its software catalogue as a supplier; CADD/86-87 followed for the HP-86 and HP-87.

An HP-85 computer. Wolfgang Stief / Wikimedia.

Front and back of the CADD/86-87 datasheet. John M. Christy.

The 1980s rewrite that set the rules

Then the 9816 arrived, and HP Pascal proved the only way to get real performance out of it. A year spent becoming good at the language, then a start over, producing CADD 200 and later CADD 200/300, published by Tensegrity, Inc. in Chicago. The name came from Buckminster Fuller, who personally granted permission to use it for the company on one condition: telling people, in his words, that "the word tensegrity is an invention of R. Buckminster Fuller." That line was printed on the business cards, after Fuller's lectures in the 1970s were attended several times.

The CADD/200 data sheet, with the HP 9816, the plotter and the 9111 graphics tablet. John M. Christy.

John M. Christy.

The rest of the product came from users, and one of them set the readability standard. In Evanston, Illinois, John Hardy of The John Hardy Company designs precision audio equipment; he started on CADD in 1983 and never stopped, running it across a succession of HP machines for sheet metal, injection-molded plastic, machined parts, schematics and circuit boards. He was handed the source and added what he needed, including wide lines in the 1980s and a Gerber output in 2012. The best test of readable code is a customer extending a program thirty years after it was written. For anyone shipping electronics data today, that late export is worth contextualising: the extended Gerber stream belongs to the RS-274X family, first released in September 1998 and still the industry's de facto image-format standard (en.wikipedia.org/wiki/Gerber_format), so a 2012 addition remained compatible with modern CAM pipelines.

Drawings produced with CADD/200-300 by John Hardy of the John Hardy Company. John Hardy.

Step-by-step: the 2025 revival as a repeatable sequence

During the 1990s, Christy moved into a different business and put CADD to the side, but last year, in a very different environment from the one in which he had started, he decided to revitalize it. Nothing in the restart depends on genius; each move below is transferable to an internal service that has outlived its team.

1. Choose the platform as a system, not a language. The PC was evaluated first, and no combination of language, graphics library and tools made sense as a whole. The Apple ecosystem did, because it reproduced the HP workstation world: hardware, operating system, language and tools as one coherent thing. Score candidates on coherence, not on benchmark hype.
2. Build a bridge to the original behaviour. Around October 2025 the rewrite began with the Pascal printed out and a 1980s HP 340 running beside the MacBook, feeding drawing files across a serial link. Golden input files from a retired system are the cheapest specification you will ever obtain.
3. Make the model read before you make it write. Christy started by handing pieces of the Pascal to Claude to analyze and comment on; that is how the Apple code began. Comprehension output is reviewable, while raw generated code invites rubber-stamping.
4. Redefine your own seat. The job changed from the programmer who writes the code into the producer and director who decides what gets built, plus the quality-control tester who decides whether it ships. Write that split into the team charter, otherwise review quietly stops happening.
5. Gate every commit with a fast suite. Before new code is committed, nearly two thousand tests run so the addition cannot break what already exists, and the whole suite finishes in under half a minute. Speed of the gate is what makes it non-negotiable.
6. Declare a feature-complete checkpoint. The program, now called C3 (an abbreviation of CADD300_Modern), reached feature-complete status by February 2026. A named milestone turns an open-ended revival into a project with an end.
7. Only then extend to a second target. A Windows version of C3 is now in progress, mostly written by Claude under his direction, reusing the specification the Mac round produced.

Three rules that did not change in 45 years

Accuracy before speed

HP built a machine running at 613 kilohertz that got the arithmetic right, while the competition ran six times faster and rounded. Today's C3 solves every construction, tangent circles, arc fits, intersections and offsets, in closed form, never by a grid search or an approximation, because an error nobody can see on the screen shows up at a hundred-times zoom and in the shop. That trade is still an active research problem in computational geometry: adaptive-precision floating-point arithmetic and robust geometric predicates exist precisely because naive floating-point orientation and incircle tests silently produce wrong signs and inconsistent topology (Shewchuk, paper set at people.eecs.berkeley.edu/~jrs/papers/robust-predicates.pdf). Rule for your codebase: publish the list of predicates that must stay exact, and never let a "faster" dependency quietly downgrade them.

Draw only what the screen can see

Of the choices made during that HP Pascal rewrite, two outlived every machine they ran on. The first was in the database: giving every item an extent meant a redraw touched only what passed through the screen and ignored everything that did not. Most CAD programs of that period redrew the whole file every time, which alone made CADD 200 many times faster than the products it competed with. The same structure remains the default answer in modern rendering, where axis-aligned bounding-box culling combined with a spatial index such as an R-tree is how current 2D engines cut draw calls on viewport-sized scenes (performance-optimization guide, g.antv.antgroup.com). If you draw a list, a map or a diagram today, per-item extents are not retro engineering; they are the cheap, boring fix.

Write it so the next reader can start cold

The second durable decision concerned the source. Freed from one-letter variables and their ceiling of 286 simple variables, everything was named for what it was and what it did, and commented heavily. Four decades later, any procedure in that Pascal source can be opened and understood at once, and the same readability is why a language model could read the 1985 code in 2025 and help carry the design forward. Michael Feathers' widely quoted formulation that legacy code is simply code without tests (Working Effectively with Legacy Code, summarized at ibm.com/think/topics/legacy-code) has a corollary here: code with no describable structure is also code an assistant cannot safely take over. Names, comments and plan documents are not courtesy; they are the interface between eras, which is why the new code and its plan documents are written the same way, for whoever reads them next, person or model.

John M. Christy.

Shipping features on demand: the loop in minutes

Back in the HP days a requested feature usually could be built, but it took a lot of coding, a lot of testing and a lot of time, and users invited to ask were mostly very good engineers and scientists. With Claude working as the programming partner, recent examples show where that time went. Mid-drawing, a needed function was unclear and searching the manual proved slow, so the instruction was simply: "Claude, we need context-sensitive help." The user guide, which runs over two hundred pages, was restructured, and now the help key opens the manual at the exact spot for whatever you were doing. Another time, photographs and spreadsheets inside a drawing were requested; the program could not do either yet, and within minutes it could, with the spreadsheet living inside the drawing itself and formulas for bills of materials and hole schedules saved in the same file.

The C3 assistant arrived in three steps, and the first two had nothing to do with artificial intelligence. In January, the request was voice guidance that tells you what to click next: trivial for a line, but for an angular dimension you click the start and end of one line, the start and end of the other, and then the place you want the arc. A new user has no way of knowing that sequence, and the author admits forgetting it half the time, having written the program. So in May the question became whether the program could simply be talked to, with phrases such as "lines menu," "circles menu," and similar; it now understands more than two hundred spoken commands. In September came the third step: drawing something from a plain-language request. That became the assistant, a language model driving the program through its own command catalogue, one undo step per request, and driven by dictation.

A bolt circle flange drawn entirely by the C3 assistant, with the user’s prompt on the right in blue (the gray-backed text is from the assistant itself). John M. Christy.

The C3 interface with a circuit schematic developed by John Hardy. John M. Christy.

R. Buckminster Fuller had a word for the arithmetic inside this story: ephemeralization, doing more with less, the way a growing population can be supported without anyone having less, as each generation of tools extracts more result from less material, less time and less energy. One person carrying one program across 45 years, and building in minutes what once took months, is a small instance of exactly that.

Five misconceptions this case kills

• A slower vintage machine means useless lessons. The competing machines ran six times faster and still lost the engineering argument, because rounded answers cannot be handed to a shop floor. Clock speed is never the requirement; correctness is.
• AI assistance removes the need for tests. The opposite holds here: nearly two thousand tests run before any commit, in under half a minute. Throughput gains without a gate is exactly the instability pattern the 2025 DORA findings describe.
• Rewriting means deleting the old code. The Pascal listings stayed printed, and a 1980s HP 340 stayed beside the MacBook for the whole revival, because behaviour you cannot regenerate has to be observed.
• Documentation is a courtesy for humans. Over two hundred pages of manual were restructured into context-sensitive help, and the comments that made the 1985 source legible are the same property that let a model take it over.
• Voice or chat interfaces are demos. Here they are a fix for a step sequence too easy to forget, which is a genuine usability requirement in developer tooling as well.

Checklist before you touch a legacy module

1. Print or freeze the old source and record its outputs on real inputs before changing anything.
2. Write characterization tests that capture current behaviour, bugs included, rather than ideal behaviour you cannot yet verify.
3. Confirm a full test run finishes well under a minute, or make it fast before you rely on it.
4. Give every stored object a bounding extent so the hot path can cull work.
5. Publish the exact-arithmetic boundary list: every predicate that must never be approximated.
6. Rename to intent as you enter a file, and comment at the level a stranger needs.
7. Seat one named human as producer or director, and a separate gatekeeper who decides what ships.
8. Declare a feature-complete date; add a second platform only after it passes.

90-day action plan

1. Days 1-30, map the asset. Pick the module everyone avoids. Capture its inputs, outputs and failure modes into golden files, using retired hardware or recorded sessions if needed, as the printed Pascal and the serial bridge were used here.
2. Days 31-60, build the safety net. Grow a suite toward the scale of nearly two thousand tests and time-box it to under half a minute so it stays in every commit; add the extent or index fields your render or query path lacks.
3. Days 61-90, run one assisted rewrite. Have the model read first and comment, generate second, and ship only through the gate. Then expose one customer-extensible surface with source access, following the John Hardy precedent.

FAQ: what teams ask first

How much of this transfers from a one-person CAD product to a team codebase?

All of the mechanics, none of the romance. The transferable pieces are the serial-link reference machine, the printed source used as specification, the sub-minute test gate, per-item extents for rendering, and naming for the next reader. What does not transfer is the single decision-maker and 45 years of continuity; a team substitutes written plan documents and a stated review owner.

Should we let a model rewrite code it has never explained?

No. The workflow that worked here began by handing pieces of the Pascal to Claude to analyze and comment on, which produced a reviewable artifact before any generated line existed. Treat model-written explanation as an input requirement in your pull-request template.

How large does a regression suite need to be?

Large enough to cover the behaviour you refuse to re-derive by hand. The working number in this project is nearly two thousand tests completing in under half a minute; the ratio is the point, since a slow gate gets skipped and a fast gate becomes policy.

Is exact arithmetic still worth its cost?

Where an error is visible on the screen, no; where it appears only at a hundred-times zoom or in the shop, yes. The literature on robust geometric predicates is effectively a warning that floating-point approximations in orientation and intersection tests yield inconsistent decisions, which is why closed-form solutions remain the defensible default in CAD and, by analogy, in money and scheduling code.

Do voice or chat interfaces earn their place in internal tools?

Only where a step sequence is genuinely hard to remember. In C3 the assistant exists because an angular dimension needs five ordered clicks, and more than two hundred spoken commands now cover the rest. A deploy tool with a six-step ordering is the same problem.

How is provenance handled here?

Figures stay credited to their original holders, John M. Christy, Wolfgang Stief via Wikimedia, and John Hardy, and the added industry context is attributed to named reports and specifications rather than restated as common knowledge.

Editorial note: this engineering teardown was written by James Hartley for the SoftwareDevelopment channel at ItInsightsWorld, published by IT Insights; proposals for the next legacy-code case can go to contact@itinsights.com.