# To Boldly Go Beyond High-Level Code

**Rethinking High-Level Code as the Primary Software Artifact: A Technical Note**

A Technical Note by Eduardo Di Santi  
*College of Engineering and Applied Science, University of Colorado Boulder* (April 2026)

## Abstract

High-level programming languages have historically served as a practical compromise between human cognitive limits and executable performance. They improved readability, maintainability, and portability because humans were expected to remain the primary long-term authors and maintainers of software artifacts[cite: 1].

This technical note argues that reliable agentic generation and regeneration may change that optimum. If executable artifacts can be generated, repaired, translated, and re-optimized by agents, then the long-lived persistent representation of software need not remain identical to the human-facing representation[cite: 1]. Humans may primarily control a **semantic layer** consisting of requirements, invariants, tests, interfaces, and optimization objectives, while agents maintain a **lower-level persistent layer** closer to compiler backends or hardware[cite: 1].

The note makes three limited contributions[cite: 1]:
1. Proposes a two-layer view of future software systems: a human semantic layer and an agent-generated persistent layer.
2. States a minimal formal observation clarifying that conventional mediated execution cannot outperform the cost-optimal native realization on fixed hardware.
3. Offers an empirical illustration showing a ~74x speedup (Python vs. Agent-generated LLVM IR) to suggest why bypassing high-level source frontends matters in agentic maintenance loops.

## Repository Content

- **Paper**: [`go_boldly___Technical_Note.pdf`](go_boldly___Technical_Note.pdf)[cite: 1]
- **Code**: Empirical illustration of Python vs. LLVM IR performance[cite: 1].

## Core Thesis

High-level languages were optimal when humans were the primary authors and maintainers. In an agentic regime, these roles can be separated[cite: 1]. The durable executable artifact can shift downward toward machine-near forms (LLVM IR, bytecode, etc.) optimized for efficiency and transformability, while humans maintain semantic control at a higher level[cite: 1].

## Why This Matters

- **Economic Efficiency**: Reduces execution cost, latency, and energy in infrastructure software[cite: 1].
- **Architectural Shift**: Eliminates the recurring overhead of high-level source frontends in agentic maintenance cycles[cite: 1].
- **Native-Tight Objective**: Targets a reduction in the gap between realized execution cost and the native cost floor[cite: 1].

## Citation
```bibtex
@techreport{disanti2026boldly,
  author       = {Eduardo Di Santi},
  title        = {Rethinking High-Level Code as the Primary Software Artifact: A Technical Note},
  institution  = {University of Colorado Boulder, College of Engineering and Applied Science},
  year         = {2026},
  month        = {April},
  url          = {[https://github.com/eduardodisanti/to-boldly-go-beyond](https://github.com/eduardodisanti/to-boldly-go-beyond)},
  type         = {Technical Note}
}