Washington, D.C. — Federal regulators are reportedly evaluating new restrictions on compilers after concluding that the decades-old software tools may be functionally similar to artificial intelligence coding assistants, in that both produce, in the words of one draft memorandum, “code the user did not personally type.”
The concern stems from an internal review at the Department of Commerce, which determined that programmers across the country routinely write source code and then permit a separate program to generate entirely different machine code on their behalf — a workflow officials described as “automated authorship at industrial scale.”
“The computer is literally writing instructions on the user’s behalf,” one regulator reportedly stated during a closed-door briefing. “The human types a few hundred lines. The machine produces tens of thousands. Nobody reads them. Nobody signs off on them. And we’re supposed to believe this is fine because it’s been happening since 1957.”
The remark, according to two people present, was met with silence, followed by a single staffer quietly asking what happened in 1957.
The Investigation
Officials say they became suspicious after a routine oversight session on AI coding tools veered into broader questions about “machine-assisted software production.” During the session, a contractor demonstrated a modern AI assistant generating a function from a plain-English prompt.
A regulator reportedly asked how this differed from “the regular way.” The contractor explained that, in the regular way, the developer writes the code themselves. A follow-up question — “and then what happens to it?” — produced an answer that the room found deeply alarming.
According to a draft report, developers were found to routinely:
- write high-level code in a human-readable language
- press a single button, or in some cases type a short command
- receive thousands of machine instructions they never personally authored
- ship those instructions to the public without reading any of them
“This workflow raises serious questions regarding authorship, accountability, and excessive convenience,” the draft states. A footnote adds that the convenience appeared to be “the most troubling part.”
Investigators were reportedly especially disturbed to learn that the generated instructions are often different every time, depending on settings the developer selects from a menu. One official described this as “the machine deciding, on its own, how to interpret what the human meant.”
“So the human says what they want,” the official said slowly, “and the machine figures out how to do it. And we just... allow this.”
The Scope of the Problem
Preliminary estimates compiled by the Department’s newly formed Office of Computational Provenance suggest the scale of undisclosed machine code generation is “effectively total.”
“We ran the numbers,” said a senior analyst who requested anonymity because the numbers were generated using a spreadsheet, the disclosure status of which is now itself under review. “Roughly one hundred percent of commercial software contains machine-generated instructions. Possibly more.”
When asked how a figure could exceed one hundred percent, the analyst explained that some programs are compiled multiple times.
The report identifies several categories of offender, ranked by severity:
- Tier 1 — Interpreted languages: “The machine generates instructions in real time, while you watch, and you still don’t read them.”
- Tier 2 — Compiled languages: “Premeditated. The machine generates the instructions in advance and stores them for later distribution.”
- Tier 3 — Optimizing compilers: “The machine generates instructions, then secretly rewrites them to be faster, without telling the human what it changed.”
- Tier 4 — Just-in-time compilation: “Officials declined to comment, citing an ongoing emotional situation.”
Proposed Regulations
Under the leaked proposal, developers would be required to disclose whenever compiled code was used in the production of a software product, and to characterize the degree of machine involvement.
New software packages may be required to carry a label, prominently displayed at installation, reading:
WARNING: This application contains machine-generated instructions. The human responsible may not have read all, most, or any of them.
Additional disclosures under consideration include:
- percentage of shipped code generated by a compiler rather than typed by a human
- the optimization level used, and whether the human understood what it did
- estimated amount of manual labor avoided, measured in “laziness prevented”
- a signed attestation that the developer “could have written the machine code by hand if society had not made it so easy not to”
A draft enforcement annex proposes a tiered penalty system, with the harshest sanctions reserved for developers who used “aggressive optimization” — a phrase officials reportedly found self-incriminating on its face.
“If it’s aggressive,” one regulator noted, “then on some level they already know.”
Industry Reaction
Programmers reacted negatively.
“The compiler has existed for decades,” said one developer, speaking on the condition that we mention the compiler has existed for decades.
Officials reportedly responded: “Exactly. The problem has gone unchecked for too long.”
Industry groups attempted to clarify that a compiler is a deterministic tool that translates instructions a human already specified, and does not “decide” anything in the colloquial sense. Regulators reportedly thanked them for the explanation and asked whether the translation produced “code the human did not type.” Told that it did, the regulators recorded this as a confession.
“We kept trying to explain the difference between translation and authorship,” said one trade association representative. “And they kept asking us to point to the line where the human typed the ones and zeros. We couldn’t, because nobody does that. And every time we couldn’t, they wrote something down.”
A coalition of technology firms issued a joint statement noting that requiring disclosure of compiler use was “approximately as coherent as requiring novelists to disclose the use of a printing press.” The Department reportedly opened a preliminary inquiry into printing presses the following morning.
Expansion of the Inquiry
Buoyed by early findings, investigators are reportedly examining a widening list of suspicious technologies suspected of performing cognitive tasks on the user’s behalf, including:
- calculators
- spellcheck
- databases, which were found to “remember things so humans don’t have to”
- copy-and-paste, described in one memo as “authorship laundering”
- the search bar, “which finds information the user did not personally recall”
- autocomplete, “which finishes thoughts the human merely started”
One internal memo warns, in bolded text, that “humans may be relying on machines for routine cognitive tasks,” and recommends the formation of a standing task force to determine “how long this has been going on.”
A separate working group was reportedly assigned to investigate the keyboard itself, on the theory that it “converts physical gestures into symbols the user did not draw by hand,” but the group disbanded after three days, citing “philosophical exhaustion.”
The Briefing That Changed Everything
In an effort to resolve the matter, several computer science professors were invited to Washington to explain what a compiler actually does. The briefing, scheduled for ninety minutes, reportedly ended after twenty.
According to attendees, the session proceeded smoothly until a professor, attempting to reassure lawmakers, mentioned that a compiler is simply a more convenient alternative to writing machine code directly — and that programmers used to write something called assembly language, which also generates machine code.
The room reportedly went quiet.
“So this didn’t start with the compiler,” one lawmaker said.
The professor, sensing the conversation drifting, attempted to add context by noting that assembly is itself assembled into machine code by an assembler, and that even machine code is ultimately decoded by the processor’s microcode into still lower-level operations the programmer never sees.
One official reportedly whispered: “My God. It goes deeper.”
Another is said to have asked, in a thin voice, whether the electricity itself was “making decisions.” The professors declined to answer, on the grounds that there was no longer a productive direction for the conversation to go.
The Hardware Revelation
The deeper inquiry produced what investigators describe as their most destabilizing finding to date: the discovery that the processor does not execute the machine instructions in the order, or even the form, in which they were written.
A briefing on “out-of-order execution” reportedly had to be paused twice. Officials learned that modern processors reorder instructions, predict which branches a program will take before it takes them, and speculatively execute work that may later be discarded — all without informing the software, the compiler, or the human.
“So the chip,” one regulator said, reading from notes, “guesses what the program is about to do, does it early, and throws the answer away if it guessed wrong.”
Told this was correct, the regulator set down the notes.
“The hardware is improvising,” the regulator said. “The hardware has been improvising this entire time.”
A proposal to mandate that every CPU display a real-time disclosure reading “THIS RESULT WAS PREDICTED” was tabled after engineers explained that the prediction occurs billions of times per second and the label “would not have time to render.”
Academic Response
The academic community responded with a mixture of alarm and resignation.
“We have spent seventy years building abstractions specifically so that humans would not have to think about the layer below,” said Dr. Eleanor Voss, a professor of computer architecture. “The entire field is, in a sense, a stack of machines doing work on behalf of humans so the humans can do slightly higher-level work on behalf of other humans. If you object to that, you are not objecting to compilers. You are objecting to engineering.”
Asked whether disclosure was workable in principle, Dr. Voss said that a fully honest disclosure for a single modern application “would be longer than the application, would itself need to be compiled, and would therefore require its own disclosure.”
“It’s disclosures all the way down,” she said. “At some point you are simply printing the universe.”
A rival faction of educators reportedly welcomed the proposal, arguing that students no longer “feel the bare metal” and that a generation of programmers has grown up “never having suffered a segmentation fault they truly earned.”
The Twelve Minutes
As word of the proposed restrictions spread through developer communities, a small but committed group of programmers announced they would preempt regulation by writing machine code entirely by hand, eliminating the compiler from their workflow as a matter of principle.
The effort lasted approximately twelve minutes.
“I got through declaring the entry point,” said one participant. “Then I needed to print a string. To print a string you have to set up a system call, which means loading the right values into the right registers in the right order, and I realized I’d have to look up the calling convention, and the calling convention is documented in a manual that was, you know. Compiled.”
Another developer reportedly completed a working program that added two numbers and displayed the result. It took four hours, contained a single bug that returned the wrong answer for one specific pair of inputs, and was, according to a witness, “genuinely beautiful and completely useless.”
“I have never respected the compiler more,” the developer said, “than in the moment I tried to be one.”
By the end of the day, all but one of the participants had quietly returned to using compilers. The holdout continued for a further three days before being found at his desk, surrounded by hexadecimal printouts, attempting to hand-optimize a loop. He is said to have looked up and asked, simply, “Why did anyone ever do it this way?”
It was explained to him that, before compilers, this was the only way. He reportedly stared at the wall for some time and then requested the rest of the week off.
The Compliance Industry Emerges
As with every disclosure regime before it, the proposal’s primary effect was the immediate creation of an industry devoted to satisfying it.
Within weeks, startups began offering “Compiler Provenance Attestation” services, in which a third party would generate a certificate confirming that a developer’s build was “machine-generated, as expected, like everyone else’s.” The certificates were themselves generated by a program.
A more premium service, marketed under the name HumanBuild, advertised “artisanal compilation,” in which a human operator would manually press the compile button while making sustained eye contact with a webcam.
“Every build is touched by human hands,” the company’s materials read. “A person was present. A person consented. A person watched the progress bar.”
Enterprise clients reportedly paid up to forty thousand dollars per release for builds that were identical in every respect to ordinary builds, except for the accompanying video of a contractor solemnly observing the compiler do its work.
International Reaction
Other governments responded to the American proposal with characteristic variation.
The European Union announced it would go further, requiring not merely disclosure of compiler use but a full “Translation Provenance Dossier” documenting every intermediate representation the code passed through on its way to machine instructions, the optimization passes applied, and a statement of whether the developer “emotionally consented” to each.
Compliance reportedly added eleven hours to the build process for a program that displays the current time.
China announced it would ban foreign compilers entirely, citing “translation sovereignty,” and accelerate development of a domestic compiler that produces machine code only after the developer completes a short questionnaire. State media praised the initiative under a headline noting that domestic developers were “reclaiming authorship from imported toolchains,” a headline that was, observers noted, almost certainly typeset using imported software.
Japan adopted a voluntary honor system in which developers were trusted to disclose compiler use of their own accord. Compliance was measured at four percent, with most respondents indicating that the compiler “had opened on its own” or that they were “only checking whether the code built.”
The Logical Conclusion
The inquiry reached its natural endpoint when a junior analyst, tasked with drafting the disclosure template, raised a procedural question that no one in the room could answer.
The disclosure software, the analyst pointed out, would have to be written. And to be distributed, it would have to be compiled. The tool intended to disclose compiler use would therefore itself contain undisclosed machine-generated instructions.
“To comply with the rule,” the analyst said, “the rule’s own enforcement tool would have to violate the rule.”
A senior official reportedly suggested the disclosure tool be written by hand, in machine code, to keep it clean.
It was explained that the team capable of doing this had taken the rest of the week off twelve minutes into an unrelated experiment.
Closing Statement
The government has not announced a final decision. A spokesperson said the matter remains “under active review,” and that the Department “remains committed to transparency in software authorship,” a statement that was released as a PDF, a format the Department now declines to discuss.
However, leaked drafts suggest that future certifications may require developers to attest that:
“No unauthorized compiler assistance was used in the creation of this software. Any compiler assistance that did occur was authorized, expected, ordinary, and the only realistic way to produce software, which the signatory acknowledges with a heavy heart.”
At press time, programmers were reportedly preparing, once more, to write machine code by hand.
For approximately twelve minutes.
The Bottom Line
Regulators set out to address concern that machines were writing code on behalf of humans, and discovered, by working downward through the stack, that this has been the entire arrangement since the invention of the field: every layer exists to do work so the layer above it doesn’t have to. The proposed disclosure regime collapsed not because anyone defeated it, but because, taken to its logical end, it required the enforcement tool to incriminate itself, and required humanity to write its software by hand — a task it remains committed to, in principle, for about twelve minutes at a time.
¹ The 1957 reference is to the first commercial release of the FORTRAN compiler, a fact the briefing staffer eventually located using a search engine, which finds information the user did not personally recall, and which is now also under review.
² At no point did any party dispute that a compiler produces code the human did not type. This was, throughout, the only undisputed claim. It was also the entire point of inventing the compiler.
³ This article was written by a human, edited with spellcheck, formatted by a layout engine, transmitted by protocols no one in this office could implement, and rendered on your screen by a browser containing tens of millions of lines of machine-generated instructions, none of which we read. We disclose this freely. It was the only realistic way to reach you.