Software engineering rethinks code maintenance with disposable implementations

Disposable Implementations: What Is Software Engineering For?

Software Engineering

Summary

Maintaining existing software code is usually the norm, but the paper explores if it might be better to replace code entirely through a process called regeneration. The authors discuss how AI agents could create new versions of software from current requirements and tests instead of editing old code. However, this approach might miss important knowledge embedded in old code, making repeated regeneration risky or costly. The paper reviews examples and asks what parts of software engineering should be preserved if code becomes disposable.

What this means in practice

  • For software development teams: Replace or regenerate codebases from up-to-date requirements and tests to potentially reduce technical debt in evolving systems.
  • For quality assurance engineers: Use regenerated implementations passing current test suites to verify alignment with evolving requirements without traditional code maintenance.

A position paper. It proposes an approach and reports no results.

Authors

Christoph Treude

Abstract

Existing implementations are usually maintained for most of their life and replaced only as an exception. Coding agents may change that. If agents can produce new implementations from requirements, tests, architectural constraints, and operational records that survive replacement, changing a system may no longer require modifying its existing codebase. We call this process regeneration. An implementation is disposable when regeneration becomes a routine alternative to maintenance. Regenerating and verifying a clean implementation from current requirements and tests may be cheaper than having agents navigate (and potentially compound) existing technical debt, and could eliminate much of that debt. Yet existing code may contain knowledge absent from the preserved artifacts, including safeguards introduced after failures and assumptions that were never documented. A regenerated implementation may pass the available tests and still lose behavior that matters in production. This leaves open how to establish continuity across replacements and whether regeneration reduces maintenance effort or shifts it to the artifacts and processes that support it. We examine these questions through an exploratory review of practitioner literature. Published examples show that agents can replace existing implementations, but do not establish that repeated regeneration is safe or economical. If implementations become disposable, what should software engineering preserve?