How AI Clones Software: Calculator Rebuild Raises Ownership Question

Someone recently announced a full AI-built copy of Photoshop, then another of the entire Office suite. Software is too cheap to meter, the saying goes. Dave, a retired Windows engineer, threw his own question into that wind: give an AI a finished Windows program, no source and no symbols, and ask for a new program that does the same job. Rust was picked as the target; the only bridge between start and finish would be the program itself.

The test: from a shipped Calculator to a Rust program

Calculator was chosen for three reasons. First, permission: Microsoft opened the modern Calculator under MIT in 2019 through GitHub, and the Windows team announcement plus the GitHub page say so plainly. Second, custody: Dave once managed that very program, so he knew its habits. Third, difficulty: Calculator looks like a small single-window tool, yet it carries arithmetic, programmer and accounting modes, several number bases and infinite-precision math. Buttons are easy to imitate; habits are not.

The main instrument was Ghidra, which an American intelligence agency released to the public years ago. Ghidra pulls processor instructions apart and produces readable C-like output; this tool has earned more than seventy thousand stars on GitHub and reasons through a shared vocabulary that ignores processor brands. Roughly, each instruction becomes small steps such as load, compute, store and choose a path. The AI model reads those steps and writes the Rust counterpart. A loaded value becomes a field inside a structure; a tangled fork in the road becomes a match expression. The loss stays large: variable names, remarks and late-night notes all vanish during compilation.

Dave handed the model a one-sentence order: unpack the binary, carry the logic fully into Rust, ship a walking program under a new name, and keep repairing it until the checks pass. The agent found 10,195 functions in the math library, sorted 131,077 instruction classes and solved 18,959 interface functions without a single failure. Then it set 357 instruction chains and 8,032 in-between screens against the original; trial sums like 2 plus 3 passed before any window even opened. The striking detail: the agent caught its own errors and walked back to repair them. That honesty also proves the copy is imperfect; it invents material while filling blanks.

What compilers erase, what courts say

The result is genuinely a working Rust program; the face matches the original and the sums come out right. But perfectly identical is a phrase that has burned programmers before. The model also built a check suite that runs tens of thousands of cases against the original, yet a split may still sleep behind a key combination nobody has pressed since 1997. Just as chip makers with solid math tests can still slip, a large test count is no promise. What the demo shows is a working rebuild, not proven equivalence.

This is where I change direction, because the heart of the matter sits in what compilers discard. A name like total is not kept for sentiment; the processor keeps the instructions it needs and drops the story of the writer. So the same computation can be told in completely different texts; language shifts, names shift, the math stays. Think of a food recipe: two cooks describe one dish in different sentences and the taste matches. That is why the claim of using none of the original material misleads; a shipped file is compiled text, and studying it does not turn it into a pile of ownerless facts.

Dave calls the unauthorized version piracy and says a language swap does not soften his view; the law speaks in finer lines. Section 102 of the American copyright statute splits thought from telling: nobody owns addition, and the Cornell law archive carries the clause in plain words. In the 1992 Sega case the court treated a teardown for compatibility as fair use; in the 2000 Sony ruling the in-between copies were cleared on similar grounds. Both summaries sit in the American Copyright Office files. Yet neither ruling hands a blank check for duplicating a finished product; the permission covered the repair of incompatibility.

History keeps a ready example for this dispute. Builders who wanted IBM-compatible computers could not simply copy the IBM BIOS program, so a firm named Phoenix set up a clean-room method. One crew read the IBM text and wrote down functions only; a second crew, who had never seen the IBM text, wrote fresh text from those notes alone. The first BIOS shipped in May 1984, licensed at 290 thousand dollars with a 2 million dollar backstop; the Wikipedia company entry tells the tale. But that BIOS door had only 12 entry points; in a program with thousands of linked interfaces, writing the specification alone is a giant job.

Dave shows his own measure here too. For his monitor program TMOG he fed no existing product to the model; he authored a 107-page request document and then cooked the product through some 400 to 500 small revision rounds. His rule: when the road starts from your request, the AI carries out your design; when it starts from another team's shipped file, the result descends from that program, licensed or not. A specification alone does not clean hands either; borrowed telling can be hidden inside a request to disguise the copy. The split is about who decided the behavior.

Seen wide, Calculator is a deceptively easy rival; picture and video programs lean on libraries, file formats, plug-ins and years of buildup that no Rust call can carry over. Still, the direction is set: as study work gets faster and cheaper, the math of unauthorized substitution shifts while legal ideas stay put. On the licensed side the same power does clean jobs, like rescuing lost work or carrying an old program into a living language. Dave closes with the question everyone should ask themselves: if the program on that bench were yours, would you applaud the show?