Research question
Five Markdown files were enough to rebuild the compiler.
That was the good news.
The bad news was considerably more interesting.
The previous experiment ended with a natural-language version of ProgSync containing 34 Program documents: one shared type file and one Markdown counterpart for each of the 33 JavaScript files in the package. It looked sensible. It was complete in a very literal way. It was also based on a mistake.
We had taken an existing JavaScript implementation, inspected its files and exports, and built a readable Program graph which largely preserved that structure. The prose improved over several generations. Types became more exact. Calls acquired proper argument groups. Errors and return values stopped changing their names. Yet we were describing the wrong thing ever more accurately.
An exported JavaScript helper is not necessarily part of a program’s architecture. It may be exported because one other file happens to use it. It may exist because it was convenient to test in isolation. It may merely be the place where the original programmer chose to put twenty lines of code. None of those facts means that a human-readable source language should preserve it forever.
The correction came just after 1:30 in the morning:
A callable belongs in Program when it is a real external boundary, or when it is deliberately used by at least two distinct production Program modules. Tests do not count.
Everything else is private implementation owned by the nearest surviving Program module.
That rule gave us a new research question:
Can an AI reconstruct a working self-hosted compiler from a deliberately smaller Program which preserves public behaviour and intentional architecture, but does not preserve the former implementation’s file and helper graph?
There was a second question hiding inside the first. If the reconstruction worked, could its generated JavaScript be treated like object code—something which could be deleted and recreated at any time—or would the generated implementation itself contain knowledge worth preserving?
We expected the experiment to answer the first question. We did not expect it to answer the second quite so decisively.
Intended new knowledge
The purpose of the work was to identify the correct authority boundary between Program and the code it creates.
Program is our proposed human-readable source: Markdown which names the operations a module provides, the public operations it uses, the complex data which crosses its boundary, and its observable behaviour, effects and failures. The managed implementation is conventional code—JavaScript in this experiment—which realizes that meaning on a particular target.
The earlier corpus had demonstrated that a very detailed Program could be made to regenerate a large package after enough correction. It had not established that the resulting Program was a good source language. If every private helper, file boundary and testing seam survives assimilation, then Program becomes an English transcription of JavaScript. A person must understand essentially the same architecture, only with more words.
We wanted to learn whether aggressive architectural compression was possible. Specifically:
- Could the 33 target-shaped Program modules be replaced by four actual production modules and one shared type registry?
- Could a new model reconstruct all necessary private files without being told what those files used to be called or how the old implementation divided the work?
- Could an independent test oracle judge behaviour without requiring the new package to resemble its ancestor?
- Could failures be separated into missing Program meaning, model synthesis errors, defective tests and acceptable private variation?
- If a generated implementation acquired a verified repair, could later synchronization retain it without turning private mechanics into Program?
The final point changes the compiler analogy. In an ordinary compiler, generated machine code is disposable because the compiler is intended to be deterministic: compile the same source for the same target and it should make the same relevant decisions again. An AI does not provide that guarantee. If it can make a mistake despite sufficient source, then throwing away a repaired implementation may throw away knowledge.
Existing knowledge
The starting evidence was the first ProgSync self-hosting experiment, not a fresh literature question.
That work had already established several useful facts:
- natural language can describe real modules rather than merely product requirements;
- names, signatures, parameter groups, shared types and exact observed values form a necessary deterministic spine around the prose;
- independent behavioural tests reveal failures which syntax and export checks cannot see;
- regenerated files can differ substantially from their predecessors while retaining tested behaviour; and
- tests generated from the same Program cannot independently certify that Program.
It also exposed the central weakness in our existing corpus. We had used the former JavaScript graph as both evidence and architecture. White-box test exports became Program functions. One-consumer helpers became cross-module contracts. Implementation filenames appeared to carry meaning merely because they existed.
Conventional compiler practice supplied one tempting assumption: source is authoritative and generated output is replaceable. Conventional round-trip engineering supplied the opposite warning: once people make valuable changes to a generated target, regeneration can destroy them. Neither body of practice could tell us how a probabilistic translator should divide authority between a readable semantic source and a tested, target-specific implementation.
The relevant prior evidence therefore left two technically plausible outcomes. A smaller Program might be a better abstraction and still generate the same public behaviour. Or it might omit so much working knowledge that a model could only produce a plausible imitation. Likewise, a generated implementation might be safely reproducible from Program, or it might accumulate verified realization details which Program deliberately does not contain.
Only a clean build and an implementation-independent oracle could distinguish those outcomes.
Technical uncertainty
The uncertainty was not whether an AI could write JavaScript. It plainly could. The uncertainty was whether it could write the right JavaScript after we removed most of the structure it had previously been given.
The new root Program module provided seven public operations. It did not
prescribe a parser file, a Git file, a state file, a lock file, a candidate
file, a prompt file and a service file. It simply owned any private
implementation below src/index/. The model could create one large file, ten
small files, or twenty private auxiliaries. It could rename private operations,
replace algorithms and choose a different checkpoint representation.
That freedom created four distinct risks.
Compression could erase architecture rather than clarify it
The rule about two production consumers is a heuristic for identifying intentional shared architecture. A function used by only one module may still encode an important conceptual boundary. Conversely, a helper used by several files may be an accident of code reuse rather than a semantic service. It was not knowable in advance whether the rule would preserve enough of ProgSync’s meaning.
The old test suite could smuggle the old implementation back in
A test which imports src/index/checkpoint.js, examines a private lock-file
shape, or demands one exact internal diagnostic sentence is not an independent
behavioural oracle. It makes the former implementation mandatory through the
back door.
The tests therefore had to use only the package root, its public CLI subpath, the executable and the exported package descriptor. Yet they still had to exercise concurrency, rollback, parsing, file modes, Git state, cancellation and clean synchronization strongly enough to catch a superficially convincing compiler.
A correct Program could still produce incorrect code
Natural language may be sufficient while an individual translation is not. That distinction is essential. If an observed failure always causes us to add more prose, Program will eventually absorb every private branch of one implementation. If every difference is dismissed as model variation, the compiler will silently be wrong.
We needed a classification with four outcomes:
- Program omission: necessary observable meaning was absent or materially ambiguous.
- Synthesis defect: Program said enough, but the generated implementation did not honour it.
- Oracle defect: a test constrained a private representation or wording which Program intentionally left free.
- Acceptable variation: behaviour remained correct through a different private design.
Successful generation might still lose durable knowledge
Even if a clean package passed every test, a later model invocation could make a different mistake. We did not know whether ordinary development should regenerate a module from Program, patch the existing implementation, or reconcile both against their previous accepted state.
That could only become visible after the generated compiler had been asked to take over its own maintenance.
Competent professional assessment
The relevant fields are programming-language design, program synthesis, software architecture, static analysis and LLM-assisted development.
A competent engineer could design a formal intermediate language and write a deterministic compiler for it. That would not answer this question: Program is intended to remain readable English, with formal islands for symbols, types, links and exact values. A competent engineer could also expose every exported JavaScript function in Program. That would produce a more predictable translation, but would preserve the implementation architecture we were specifically testing whether we could remove.
Existing software-engineering methods do not determine which parts of an arbitrary implementation are its durable semantic architecture. Static analysis can count consumers and identify exports, but it cannot by itself decide whether an exported helper exists for public use, for testing, or by historical accident. Nor can model capability benchmarks establish whether one particular five-file Program corpus is sufficient to reconstruct a Git-aware, concurrent, self-hosting compiler.
The competent-professional assessment was therefore that the reduced architecture was plausible and informed by the previous experiment, but its sufficiency and the durability of generated code could not be deduced in advance. A source-free build, a withheld public oracle and a no-AI handoff were required.
Hypothesis
The hypothesis was recorded when the implementation-shaped corpus was rejected and the production-surface rule was adopted:
If Program retains only genuine external boundaries and operations intentionally shared by at least two distinct production Program modules, while expressing their complete observable behaviour and public data contracts, then a five-file Program corpus should be sufficient for isolated AI translators to reconstruct a working ProgSync package without access to its former source or private architecture.
The hypothesis would be supported if:
- the reduced corpus passed its deterministic Program check;
- all four production targets could be created in a clean repository containing no former production JavaScript or tests;
- the resulting private file graph could differ from the mature implementation;
- the generated package could be brought through Program-driven synchronization to pass every implementation-independent public test without hand-editing generated JavaScript; and
- with Codex unavailable, the generated compiler could accept its own verified state and subsequently report no change without altering a byte.
The hypothesis would be rejected if the former private file graph or private test access had to be restored, or if a working result required direct manual repair of generated JavaScript.
We also carried a secondary conjecture from the first experiment: once Program was sufficient, managed implementation might be disposable. That was not required to support the primary hypothesis, and the observations ultimately rejected it.
Experiment design
The experiment began with a non-AI production-surface audit of every export in the mature package. For each symbol we recorded its production consumers, test consumers, external status, whether two distinct production modules needed it, its proposed disposition, and the Program module which would own the behaviour if the symbol became private.
The resulting v2 corpus had five files:
| Program file | Public responsibility |
|---|---|
program/src/index.js.md |
Seven package-root operations and ownership of private src/index/ implementation |
program/src/cli.js.md |
The public runCli() operation |
program/bin/progsync.js.md |
The executable command boundary |
program/package.descriptor.mjs.md |
The exported package descriptor |
program/types.md |
Shared complex data contracts |
There were no Program test modules.
A clean Git repository was then prepared with those five files and retained
inputs such as package metadata, compiler prompts, the result schema and
documentation. It contained no production src/, executable implementation,
descriptor implementation, former JavaScript, or tests.
Four fresh Sol/xhigh model invocations generated the executable, descriptor, CLI and root library. The smaller targets were generated independently while the root generation ran. Candidates were accepted only after deterministic syntax, ownership and public-surface checks. Production source was committed inside the experimental repository before the withheld oracle was introduced.
The oracle was audited so that it could import only documented public boundaries. Failures were classified against Program before any change was made. Program omissions and compiler rules could be corrected; private implementation differences could not be turned into requirements merely to make the new package resemble the mature one. Generated JavaScript was never edited by hand.
Finally, Codex was removed from PATH. Each generated production module had to
accept a committed baseline without AI and then converge under an ordinary
invocation. Before-and-after hashes had to remain identical.
Variables and controls
| Role | Measure |
|---|---|
| Varied | Program architecture: 33 implementation-shaped target modules were replaced by four production modules plus one shared type registry |
| Held constant | ProgSync target, retained package inputs, Sol/xhigh model class within each generation, bounded per-module context, candidate ownership rules and public behavioural requirements |
| Observed | Generated targets and files, candidate acceptance, Program diagnostics, public-oracle pass count, hand repairs, no-Codex convergence and byte hashes |
| Success threshold | Generate all four targets from the five-file corpus; reach a complete pass of the implementation-independent oracle using only Program/compiler reconciliation; then return NO_CHANGE for all four targets with Codex unavailable and byte-identical files |
| Failure threshold | Require former private source or test modules, constrain the result to the old private graph, directly edit generated JavaScript, or fail the public oracle after bounded Program/compiler correction |
The test count grew from 53 to 55 when the handoff exposed two new public behavioural cases. This was a recorded extension of the oracle, not a reduction of the success threshold.
Work performed
On 23 July 2026, the following experimental work was performed:
- stopped the in-progress v1 generation when it became clear that its Program corpus preserved accidental JavaScript architecture;
- recorded the production-consumer rule and the distinction between public meaning and private realization;
- audited the complete existing export surface without using an AI to decide which test-only and one-consumer helpers should survive;
- rewrote the Program corpus from scratch as four production modules and one shared type file;
- rewrote the independent oracle so it exercised public behaviour without importing private helpers or requiring private storage layouts and wording;
- created several clean generation repositories while correcting general candidate-runner, parser, dependency and validation defects;
- executed the definitive source-free generation with separate isolated model calls for all four production targets;
- introduced the withheld oracle only after the generated source had been frozen in the experimental repository;
- classified each observed failure as Program omission, synthesis defect, oracle defect or acceptable variation;
- used Program-driven minimal reconciliation to evolve the generated package without directly editing its JavaScript;
- expanded the public oracle for forwarded exports and explicit-baseline precedence;
- removed Codex from the execution path and performed baseline acceptance, ordinary convergence and byte-hash checks;
- recorded the detailed chronology, model timings, test counts and architectural findings in the retained source session and experiment files linked below; and
- consolidated the completed work in Vibe64 commit
0ab44e2f.
The public total for this continuation is 15 research hours. Private company time and expenditure records remain the accounting source for any later eligibility or expenditure assessment.
Observations
Fewer Program files produced more implementation files
The old corpus contained 34 Program documents and attempted to preserve 33 target files. The v2 corpus contained five documents.
From those five documents, the definitive clean build produced all four
production targets. The pure-generation commit added 23 production
implementation files and four deterministic Program projections: 27 generated
files in total. Nineteen of the production files were private root auxiliaries
beneath src/index/. Program did not name those auxiliaries because their
names and boundaries were not part of the package’s meaning.
All four production candidates were accepted on their first attempt:
| Target | Generation time |
|---|---|
| Executable | approximately 58 seconds |
| Package descriptor | approximately 68 seconds |
| CLI | approximately 4 minutes 29 seconds |
| Root library | approximately 37 minutes 30 seconds |
The timing is not a performance claim. It does reveal why module boundaries matter. Three small public boundaries could be generated independently while the much larger root was working. It also explains why a mature root implementation should normally receive a small reconciled patch rather than a 37-minute reconstruction.
The result supports the architectural compression. A Program module did not need a one-to-one relationship with every private implementation file. One readable root module could own a private implementation graph chosen by the target translator.
An export is not automatically architecture
The production-surface audit removed a large number of symbols from Program. Test-only exports disappeared. One-consumer helpers disappeared. Wrapper functions which merely duplicated a more general public operation disappeared. Their behaviour did not disappear: it was absorbed into the public operation which owned it.
There are necessary exceptions. A command, an HTTP handler, a package API, a framework callback or an executable entrypoint may be genuinely public even when no second Program module calls it. The rule is not “count to two and stop thinking.” It is:
Preserve intentional public collaboration. Do not preserve an implementation seam merely because JavaScript can import it.
This changed the role of tests. Tests constrain behaviour, but they do not create Program symbols. If a test can only exercise an observable guarantee by importing a private helper, the test should normally be rewritten through a public boundary rather than promoting the helper into the source language.
Correctness had to stop meaning resemblance
The clean implementation did not always use the mature package’s private files, names, diagnostics, lock representation or checkpoint encoding. That was expected and desirable.
The oracle initially contained assertions which treated some of those differences as errors. One test required a particular internal evidence-field name. Another assumed a lock directory and owner-record schema. A retry test expected one exact English phrase even though the generated diagnostic carried the required symbol, provider and export facts.
Those assertions were defects in the experiment. They tested genealogy—whether the new compiler descended visibly from the old one—rather than behaviour. They were replaced with representation-independent checks.
This gave us a practical definition:
A clean implementation is correct when it satisfies Program and its public evidence, not when it looks like the implementation from which Program was assimilated.
That definition prevented two opposite mistakes. We did not bloat Program with private details merely to satisfy old tests. We also did not excuse actual failures as creative implementation differences.
The first public result was 44 out of 53
The definitive source-free package parsed, loaded, exposed the correct public symbols and passed its own five-file Program check. Its first withheld oracle run passed 44 of 53 tests.
The nine failures did not represent nine missing paragraphs. They reduced to four observable implementation errors and one test assertion which depended on incidental wording:
- changing a shared type scheduled modules which did not reference it;
- single-file synchronization treated unrelated project-wide Program diagnostics as fatal;
- assimilation could not state that consumer evidence was incomplete or ambiguous;
- dry-run output omitted newly created files; and
- one test required the mature implementation’s diagnostic sentence.
Program and the compiler guidance were clarified, the wording assertion was generalized, and Sol/xhigh reconciled the owning root module. The package reached 52/53, then 53/53 after the dry-run rule was made unambiguous. No generated JavaScript was hand-edited.
One particularly useful correction concerned shared types. The early
implementation treated a change to types.md as a reason to schedule every
module. That is safe but destroys locality. The corrected compiler computes the
reachable type closure for each Program module and schedules only consumers of
the changed definitions. A shared type registry can therefore remain global
without turning every type edit into a whole-project generation.
The compiler could compile itself—and still be wrong
Passing the oracle was not the end of the experiment. The generated compiler then had to take over its own accepted state with Codex unavailable.
The first handoff exposed a forwarding defect. The root package publicly
re-exported an operation from one of its owned private files. The generated
validator recognised the root barrel but could not follow that public export
through the private auxiliary tree when validating a consumer. One
implementation-independent regression raised the oracle to 54 tests. A
Program-driven reconciliation changed only src/index/validate.js, and the
package passed 54/54.
The next handoff found the decisive defect.
ProgSync accepts an explicit Git base so that a caller can deliberately ignore
private accepted state. Program already stated that this explicit base takes
precedence. The generated compiler selected NO_CHANGE correctly—and then
consulted an older private dependency hash anyway, escalating the operation
back into AI generation.
This was not missing Program meaning. It was not an acceptable private choice. The source was sufficient and the generated code was wrong.
The independent oracle made the failure reproducible as test 55. A later
Sol/xhigh reconciliation changed two conditions in one private file,
src/index/sync.js, while preserving the rest of the generated
implementation. Both the mature and independently generated compilers then
passed all 55 tests. The canonical package completed the suite in 72.95
seconds; the generated one completed it in 39.67 seconds. The timing difference
was observed but not investigated as a performance result.
With Codex physically unavailable, all four generated modules then accepted the
committed baseline and, on ordinary invocation, independently returned
NO_CHANGE. No tracked file changed and the before-and-after hashes were
identical.
The final package result was then tested in the complete Vibe64 repository, not only in the isolated ProgSync archive. Vibe64 passed 1,433 server tests, 633 client tests, its production build, all 19 workspace package contracts and project doctor. The final package dry run contained 48 files.
Most of the generated compiler survived intact
The preserved Git ledger let us compare the pure-generation commit with the final verified generated package.
Eighteen of the 23 production files were byte-for-byte unchanged. Only five private root files changed during the complete oracle and handoff sequence:
| Private file | Reconciliation |
|---|---|
src/index/candidate.js |
+1 / −0 lines |
src/index/context.js |
+31 / −15 lines |
src/index/source.js |
+94 / −37 lines |
src/index/sync.js |
+77 / −29 lines |
src/index/validate.js |
+140 / −25 lines |
| Total | +343 / −106 lines |
The public root, CLI, executable and descriptor implementations required no later source edits. The large private tree was not repeatedly thrown away and recreated: the system retained the first successful realization and changed only the parts implicated by new evidence.
This is important because “the generated package eventually passed” could conceal a complete rewrite. It did not. More than three quarters of the production files survived untouched, while every later production change was confined to five private files owned by one Program module.
The implementation is not disposable output
The explicit-base defect changed our model of the entire system.
If we deleted the repaired generated implementation and asked the AI to rebuild it, the next version might reintroduce that defect or make a different one. Putting the two private conditions into Program would be the wrong response: Program already expressed the observable precedence rule. Encoding one JavaScript repair in English would leak realization mechanics into the semantic source.
The verified repair belongs in the managed implementation.
The resulting model has two writable artifacts and a common ancestor:
last accepted pair (P0, I0)
+ current Program P1
+ current managed implementation I1
+ independent verification evidence
→ next accepted pair
Program owns observable meaning and intentional public composition. The managed implementation owns compatible accumulated realization knowledge: verified repairs, private structure, optimizations, target-specific refinements and visual tuning. The last accepted pair tells the synchronizer what changed on either side. Tests and runtime evidence decide whether the result conforms, but they are not a hidden third source which invents behaviour.
Fresh generation is still essential. It tests whether Program is sufficient and whether another target could be built without the current realization. It is not the normal maintenance operation for a mature module.
The most important lesson of the day can therefore be stated quite simply:
An AI may generate the implementation, but verification makes the implementation valuable.
The experiment produced a better name for the relationship
“Compiler” remains a useful analogy, but it is no longer a complete description.
ProgSync does compile a missing implementation from Program. It also decompiles meaningful implementation changes back into Program. More importantly, it reconciles two overlapping representations without allowing either to erase knowledge owned by the other.
A conventional compiler transforms one authoritative source into a derived target. ProgSync is closer to a versioned, verification-driven reconciliation between semantic source and realized source.
That sounds less magical than “English is the only source code.” It is also much more likely to work.
Evaluation
The primary hypothesis was supported for this experiment.
The implementation-shaped corpus was not necessary. Five Program files were sufficient to generate all four production targets, comprising 23 production files plus four deterministic projections, without access to the former source or tests. The resulting package was evolved only through Program/compiler reconciliation, passed the same 55-case public oracle as the mature implementation, checked its own five Program files with zero diagnostics, and converged byte-for-byte with Codex unavailable.
| Measure | Result |
|---|---|
| Program files | 5 |
| Target-bound Program modules | 4 |
| Generated production files in the definitive clean build | 23 |
| Generated deterministic projections | 4 |
| Production files unchanged after pure generation | 18/23 |
| Production files changed during reconciliation | 5/23 |
| Total production reconciliation | +343 / −106 lines |
| Production candidates accepted on first attempt | 4/4 |
| First withheld-oracle result | 44/53 |
| Final public-oracle result, generated implementation | 55/55 |
| Final public-oracle result, mature implementation | 55/55 |
| Program diagnostics | 0 |
| Manual edits to generated JavaScript | 0 |
No-Codex ordinary synchronizations returning NO_CHANGE |
4/4 |
| Tracked byte changes during final convergence | 0 |
| Complete Vibe64 server tests | 1,433 passed |
| Complete Vibe64 client tests | 633 passed |
| Workspace package contracts | 19 passed |
The support is narrower than a claim of deterministic compilation. The definitive clean package did not pass every eventual test on its first untouched run. Program and general compiler guidance were refined after observable failures, and the generated implementation was incrementally reconciled. That is evidence that the reduced representation can support a working compiler; it is not evidence that every fresh stochastic generation will do so without correction.
The secondary disposable-output conjecture was rejected. The explicit-base error demonstrated a generated implementation defect despite sufficient Program. The smallest correct response was to preserve the working implementation and reconcile two private conditions, not to regenerate the module or leak those conditions into Program.
Several limitations remain:
- only one complete v2 source-free reconstruction has been brought through the full public oracle;
- repeated stochastic reproducibility has not been demonstrated;
- the experiment concerns ProgSync and JavaScript, not arbitrary applications or target languages;
- no controlled user study has shown that people understand or change the five-file Program more successfully than conventional source;
- the generated package’s faster test time was not analysed and must not be interpreted as a performance improvement;
- candidate isolation is not yet a complete hostile-source security boundary.
Conjectures produced by the work
Program may be architectural compression rather than natural-language translation. The useful transformation was not replacing JavaScript tokens with English words. It was deciding which relationships deserve to survive. The reduction from 33 target-shaped modules to four production modules may be more important than the prose itself.
A smaller public graph may improve both human and model reasoning. A person can consider seven root operations more easily than dozens of exported helpers. A model also receives a smaller semantic surface and can choose its own private decomposition. This may reduce coupling, but it needs comparative experiments rather than intuition.
Verification is part of an AI compiler’s semantics. With a deterministic compiler, tests normally validate the program produced by the compiler. Here, independent evidence also distinguishes a sufficient Program followed incorrectly from an insufficient Program. The compiler architecture may need to treat that classification as a first-class operation.
Generated code can become more valuable over time. Every verified repair, optimization and target refinement increases the information held by the managed implementation. The strange consequence is that generated code begins as replaceable experimental output and gradually becomes precious source.
A three-way synchronizer may be safer than pretending one side always wins. The accepted pair gives Program and implementation a common ancestor. That should allow the system to preserve a CSS refinement on the implementation side while applying a behavioural change from Program, or to reflect a genuine implementation-side semantic change back into Program. We have established the need for this model, not yet its behaviour under deliberate simultaneous edits.
A new target is now the cleanest test of portability. Regenerating more JavaScript demonstrates stochastic reproducibility. Generating the same Program module in a second language would test whether Program actually owns meaning rather than JavaScript assumptions written in English.
Logical conclusion
The hypothesis is supported, with an important qualification.
ProgSync did not need a natural-language twin for every implementation file. Four production Program modules and one shared type registry were enough to create a complete, independently structured implementation. After Program-driven correction, that implementation passed 55 public tests, checked its own Program graph, took over its accepted state without Codex, and converged without changing a byte.
That is the strongest evidence so far that Program can describe software at a useful boundary above conventional source.
It does not establish that AI is a trustworthy drop-in replacement for a deterministic compiler. The generated compiler violated an explicit rule. The oracle caught it. A two-condition repair fixed it. Discarding the repaired implementation would discard verified knowledge without improving Program.
We began the day trying to remove implementation details from the source.
We ended it understanding that implementation details and implementation knowledge are not the same thing.
Private mechanics do not belong in Program. Verified realization knowledge does belong in the project. Program and managed implementation must therefore remain complementary sources, reconciled against the last accepted pair and judged by independent evidence.
The compiler wrote itself.
It also made a mistake.
Those two facts belong together.
Supporting activities
The following work was directly related to designing, conducting or evaluating the experiment:
- auditing production and test consumers to define the reduced Program architecture;
- rewriting the self-hosting Program corpus and public behavioural oracle;
- creating source-free Git repositories and bounded candidate workspaces;
- improving deterministic parsing, linking, dependency closure, process cancellation and candidate validation where failures prevented the experiment from being conducted safely;
- adding implementation-independent regressions for observable defects found during generation and handoff;
- running the mature and generated packages against the same public oracle;
- recording model calls, generation durations, rejected assumptions, test results, file hashes and no-Codex convergence; and
- documenting the durable-implementation and three-way reconciliation finding.
Routine Vibe64 product work, deployment, marketing, unrelated test maintenance and future user-interface integration are outside this entry unless separately assessed and recorded. This technical record does not itself determine R&D Tax Incentive eligibility or the treatment of any expenditure.