AG
All publications

Inspectable Control for Structure-Preserving Software Regeneration

Controllable code editing that preserves selected program structure without regenerating the entire program.

Alexey Gavrilov1Alan-Barsag Gazzaev1Mikhail Mozikov2Ilya Makarov2Sergey Muravyov1

  1. ITMO University, Saint Petersburg, Russian Federation
  2. AXXX, Moscow, Russian Federation

Published at Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering

2026pp. 1406–1407Companion poster

DOI 10.1145/3803437.3807386

PaperPDFBibTeX

Author camera-ready manuscript with the final author list and DOI. CC BY 4.0 author manuscript; the ACM DOI page remains the version of record.

Paper in 30 seconds

Problem

AI-assisted code modification often needs one bounded change while selected program structure remains fixed. Regenerating the entire program can disturb unrelated regions, and token-level constraints do not expose a coarse control surface.

Approach

The study encodes 64-token Python functions with a hierarchical VQ-VAE, locks selected coarse discrete codes, and uses masked discrete generation for localized code regeneration in the remaining latent positions.

Main result

Locking four top-level codes raises parse rate from 0.453 to 0.591 while unlocked positions still change at rate 0.936 and conditional samples remain 0.998 unique.

Why it matters

The results show a measurable stability–freedom trade-off for controllable code editing and partial program regeneration. They provide early evidence for an inspectable latent control layer, not proof of semantic equivalence or functional correctness.

Method

The method compresses a short Python function into two levels of discrete codes, freezes selected coarse positions, and regenerates the remaining positions before decoding back to code.

  1. Encode

    Compress a 64-token Python function into 16 top-level codes and 32 lower-level codes with a hierarchical VQ-VAE.

  2. Lock

    Choose coarse code positions that represent structure to preserve, such as a prefix covering the function-signature span.

  3. Regenerate

    Run masked discrete generation only over unlocked positions and decode the completed hierarchy back to source code.

  4. Inspect

    Measure parse rate, structural proxies, change in unlocked positions, and sample uniqueness before accepting a regeneration.

Selected coarse program codes remain fixed while masked fine discrete codes are regenerated and decoded into a modified Python function.
Hierarchical discrete latent code editing preserves selected coarse program structure while regenerating fine codes in the editable region.Source: Inspectable Control for Structure-Preserving Software Regeneration.Reuse terms: publisher license.Suggested attribution: Gavrilov et al. (2026). Download SVG.

Key idea

Control is applied to a learned representation above tokens: coarse latent positions define explicit places where structure can be frozen while nearby implementation details remain editable.

Difference from nearby approaches

Prompt-level or token-level constraints operate on surface text. The proposed interface exposes coarse and fine discrete control points and measures the resulting stability–freedom trade-off.

What is new

The work introduces and evaluates an inspectable hierarchical latent control layer for bounded software-artifact regeneration.

Key results

Inspectable Control for Structure-Preserving Software Regeneration key results
SettingParse rateSkeletonSignatureUnlocked change
Input (truncated)0.9940.9940.994—
Codec reconstruction0.8570.8480.4930
Unconditional generation0.4530.0800.995
Conditional, prefix k=40.5910.2950.0610.936
Conditional, signature span0.60.3020.063not reported

Key result. Coarse latent locking improves syntactic stability without collapsing change in the editable region; the result demonstrates structural control, not guaranteed functional equivalence.

Dataset
2,000 preprocessed Python functions from a CodeParrot Clean subset
Sample size
2,000 preprocessed Python functions; conditional sample uniqueness is 0.998.
Metrics
Parse rate; Skeleton and signature preservation proxies; Unlocked-position change rate; Sample uniqueness and entropy
Uncertainty
The two-page study reports point estimates without confidence intervals or multi-seed statistical analysis.
Conditions
64-token functions, argmax decoding, 16 top-level codes and 32 lower-level codes; full locking exactly recovers the codec reconstruction.

Download results:CSVJSONMarkdown

Comparison with nearby approaches

Inspectable Control for Structure-Preserving Software Regeneration factual comparison with nearby approaches
CapabilityToken-level controlHierarchical latent control
Freeze coarse structureLimitedNative coarse-code locking
Partial regenerationFragile surface constraintsMasked resampling of selected codes
Inspectable control pointsNo explicit intermediate layerCoarse and fine discrete positions
Evidence in this paperNot evaluated as a complete baselineSyntactic stability and edit-freedom diagnostics

The table describes interfaces and the study's measured evidence; it does not claim functional correctness or universal superiority.

Abstract

Software-engineering workflows such as constrained repair, staged refinement, and structure-preserving modification require control over what changes and what remains fixed. Token-level generation is a weak control surface for these operations because it constrains local surface text rather than the coarse structural invariants that software engineering often aims to preserve. We study hierarchical discrete latents as an inspectable intermediate representation for software artifacts: a hierarchical VQ-VAE compresses a 64-token Python function into coarse and fine discrete codes, and masked discrete generation regenerates only selected positions under partial constraints. On 2,000 preprocessed Python functions, locking four top-level codes improves parse rate from 0.453 to 0.591 while preserving substantial change in unlocked positions (edit freedom, 0.936) and near-maximal sample uniqueness (diversity, 0.998). Under fixed coarse context, lower-level refinement is weaker but remains monotonic, supporting a coarse-to-fine reading of the hierarchy. Overall, these results provide early evidence for a practical control layer that supports bounded, structure-preserving software-artifact regeneration above the token level.

When to cite this paper

This paper may be relevant when discussing:

  • controllable code editing and AI-assisted code modification
  • localized code regeneration or partial program regeneration
  • structure-preserving code generation under explicit constraints
  • hierarchical discrete latent representations for source code
  • masked discrete generation for source code
  • latent control for software artifacts and controllable neural code generation
  • localized program repair, bounded refactoring, or controlled software regeneration

Limitations

  • The study is limited to short Python functions truncated to 64 tokens.
  • Evaluation uses argmax decoding and syntactic or structural proxies rather than tests of functional equivalence.
  • Exact signature preservation remains weak.
  • Lower-level control is weaker than top-level control.
  • Latent positions are not yet aligned to semantic regions such as AST spans, signatures, or control-flow structure.
  • The results do not establish correctness for practical repair, refactoring, or repository-level changes.

Related research areas

The paper is most relevant to work that needs explicit control over what an AI-assisted code transformation may change and which parts of a program should remain stable.

  1. Controllable and structure-preserving code generation

  2. Localized program repair and bounded refactoring

  3. Hierarchical discrete representations for source code

  4. Masked generation over partially fixed latent states

  5. Developer-facing inspection of AI-assisted modifications

Scope. The experiments use a hierarchical VQ-VAE and masked discrete generation, not an LLM. They evaluate short Python functions with syntactic and structural proxies rather than functional correctness, exact AST preservation, or repository-scale repair.

Resources & reproducibility

Publisher
ACM
Code
Not publicly released; no inactive Code button is shown.
Installation
A public installation recipe is not yet available; no inactive Code button is shown.
Minimal run
The published workflow is encode → lock selected top-level codes → regenerate unlocked positions → decode → inspect validity and change scope.
Configurations
Hierarchical VQ-VAE with 16 top-level and 32 lower-level positions; masked discrete generation under partial constraints.
Release / commit
No public release identifier is available.
Checkpoints
The publication page does not distribute model checkpoints.
Expected result
Prefix k=4 parse rate 0.591, unlocked change 0.936, and conditional sample uniqueness 0.998.
Hardware
Hardware requirements are not reported in the published two-page paper.

Data statement

Source
A preprocessed subset of CodeParrot Clean containing 2,000 Python functions.
License
No dataset files are redistributed by this site; reuse remains subject to the upstream CodeParrot dataset and source-code licenses.
Preprocessing
Python functions are tokenized and truncated or padded to 64 tokens before hierarchical encoding.
Split
The poster reports a 2,000-function evaluation set; an immutable train/validation split manifest is not included in the public paper.
Format
Python source functions, GPT-style token sequences, top-level code sequences of length 16, and lower-level sequences of length 32.
Version / checksum
A dataset checksum and immutable snapshot identifier are not reported in the two-page paper.
Acquisition
A public acquisition script is not released with the publication page.
Use limits
The sample is not representative of repository-scale software, multiple programming languages, or behaviorally verified repair tasks.

Versions

  1. Published versionACM FSE Companion, 2026
  3. Bibliographic recordDBLP

The published DOI is the primary bibliographic identifier. This page remains the single canonical project URL across versions.

Cite this paper

BibTeX is the recommended format. Every variant below is generated from the same publication record.

@inproceedings{Gavrilov2026InspectableControl,
  title      = {Inspectable Control for Structure-Preserving Software Regeneration},
  author     = {Gavrilov, Alexey and Gazzaev, Alan-Barsag and Mozikov, Mikhail and Makarov, Ilya and Muravyov, Sergey},
  booktitle  = {Proceedings of the 34th ACM International Conference on the Foundations of Software Engineering},
  publisher  = {ACM},
  year       = {2026},
  pages      = {1406--1407},
  doi        = {10.1145/3803437.3807386},
  url        = {https://doi.org/10.1145/3803437.3807386},
  isbn       = {979-8-4007-2636-1},
}
Download .bib

Citation files:CITATION.cffAPA textIEEE textRIS

DOI:10.1145/3803437.3807386

Part of the Discrete latent generation research direction.About the author.