Inspectable Control for Structure-Preserving Software Regeneration

Many software-engineering tasks are better described as controlled modification than as free-form generation: a developer wants to preserve a high-level plan, regenerate only a bounded region, and inspect where change propagates (barke2023groundedcopilot, ; zhang2023repocoder, ). Surface-token interfaces make that awkward because the directly manipulable object is text.

We therefore study hierarchical discrete latents as an inspectable control layer for software artifacts. Our system combines a hierarchical VQ-VAE with masked discrete regeneration (razavi2019vqvae2, ; austin2021d3pm, ; sahoo2024simple, ). Each 64-token Python function is encoded into 16 top-level codes and 32 lower-level codes. Control is exposed through lock-and-regenerate: selected latent positions are frozen, the rest are regenerated, and the decoder reconstructs the final function. Developers therefore do not edit embeddings directly; they choose which latent positions remain fixed. We intentionally study a narrow setting—short Python functions, argmax decoding, and structural proxies—to isolate controllability before broader evaluations.

We evaluate on 2,000 Python functions from a preprocessed CodeParrot Clean subset. All diagnostics use argmax decoding. Parse is the fraction of outputs accepted by the Python parser; Skeleton measures coarse program-form preservation; Signature tracks the function-interface region; Unlocked change is the fraction of editable positions that change; and Diversity is sample uniqueness under repeated regeneration. Pipeline checks confirm exact recovery under full locking and perfect preservation of locked positions.

Table 1 shows the main top-level result. Partial latent locking improves parse rate over unconditional generation while preserving non-trivial freedom in editable regions. Locking four prefix codes raises parse from 0.453 to 0.591; locking the latent span aligned to the function signature reaches 0.600. Unlocked change remains 0.936 and conditional diversity remains 0.998. Exact signature preservation stays low, which suggests that the earliest top-level codes capture coarse structural regularities more strongly than exact lexical interfaces.

A prefix sweep shows a clean controllability–freedom trade-off. At $k{=}0$, the conditional model matches the unconditional baseline (parse 0.460; unlocked change 0.995). At $k{=}8$, parse rate rises to 0.675 while 86.7% of unlocked positions still change. At $k{=}16$, the process reduces to codec reconstruction (parse 0.857; unlocked change 0.0). Lower-level diffusion under fixed top-level context is weaker but remains monotonic under locking, supporting a coarse-to-fine reading: the top level is the stronger structural control point, while the lower level supports bounded implementation refinement.

The main implication is practical: hierarchical discrete latents can act as an inspectable control layer above tokens. They expose explicit control points that improve structural stability during regeneration while preserving freedom in editable regions, which is closer to bounded modification than to unconstrained code generation. This is the main benefit beyond parse rate alone: exact preservation of locked positions, bounded scope of change, and diagnostics that make the control surface inspectable.

The current evidence is intentionally narrow. We do not yet evaluate downstream correctness, refactoring utility, or optimized wall-clock latency; nor do we claim semantic equivalence. The present poster therefore establishes structural controllability rather than full functional preservation. Future work should evaluate larger-scale settings and broader software-engineering tasks such as bounded repair and structure-preserving refactoring, while also assessing practical properties such as downstream correctness and latency.