mirror of
https://github.com/hanzoai/papers.git
synced 2026-10-22 17:20:17 +00:00
paper: The Trajectory of Code — survival-weighted learning basis (draft, private)
Basis for the agentic-coding dataset: version-control survival as a time-validated quality label; shapes-that-last; the 3 co-registered layers (transcripts/diffs/ outcomes) + human-vs-AI axis; construction pipeline (extract/normalize/link/redact/ format) with fleet aggregation + HF backup; SFT/preference/RL/survival-holdout. Co-authored-by: Hanzo Dev <[email protected]>
This commit is contained in:
Hanzo Dev
@@ -0,0 +1,329 @@
|
||||
\documentclass[11pt,letterpaper]{article}
|
||||
|
||||
% ============================================================================
|
||||
% The Trajectory of Code — self-contained preamble (no external .sty needed)
|
||||
% ============================================================================
|
||||
\usepackage[margin=1in]{geometry}
|
||||
\usepackage{amsmath,amssymb}
|
||||
\usepackage{booktabs}
|
||||
\usepackage{enumitem}
|
||||
\usepackage{xcolor}
|
||||
\usepackage[hidelinks]{hyperref}
|
||||
\usepackage{microtype}
|
||||
|
||||
\setlist{itemsep=2pt,topsep=3pt}
|
||||
|
||||
\newcommand{\doctitle}[1]{{\LARGE\bfseries #1\par}\vspace{0.6em}}
|
||||
\newcommand{\survival}{\ensuremath{S}}
|
||||
\newcommand{\shape}{\ensuremath{\sigma}}
|
||||
|
||||
\begin{document}
|
||||
|
||||
% ---- Cover ------------------------------------------------------------------
|
||||
\begin{titlepage}
|
||||
\vspace*{2cm}
|
||||
\begin{center}
|
||||
\doctitle{The Trajectory of Code}
|
||||
{\Large Survival-Weighted Learning from Version-Control History\\for Agentic Software Models}\par
|
||||
\vspace{2cm}
|
||||
{\large Zach Kelling}\par
|
||||
\vspace{0.3em}
|
||||
{Hanzo Industries Inc \quad(Techstars '17)}\par
|
||||
{\small [email protected] \quad ORCID: --- \quad @zeekay}\par
|
||||
\vspace{2cm}
|
||||
{\small HAI-2026-014 \quad\textbullet\quad Version 0.1 (Draft) \quad\textbullet\quad \textsc{Internal / Private}}\par
|
||||
\vspace{1cm}
|
||||
\end{center}
|
||||
\begin{abstract}
|
||||
\noindent We argue that the most valuable training signal for agentic software
|
||||
models is not the agent's transcript nor the final source tree, but the
|
||||
\emph{longitudinal history of the code itself}. A version-control graph is a
|
||||
record of natural selection: every line, hunk, and structural \emph{shape} that
|
||||
an author commits is subsequently either preserved, rewritten, or deleted by the
|
||||
future. Survival therefore constitutes a time-validated, annotation-free quality
|
||||
label at massive scale. We formalize \emph{code survival} $\survival$ (the
|
||||
duration a unit of code persists before it is changed or removed), extend it from
|
||||
lines to abstract structural shapes ($\shape$), and show that survival-weighted
|
||||
objectives let a model learn to generate code that \emph{lasts} rather than code
|
||||
that merely parses or passes a single test. We describe a decomplected extraction
|
||||
pipeline that fuses three co-registered layers---agent \emph{trajectories}
|
||||
($\sim$5{,}190 Claude Code sessions), verified \emph{diffs} (file-history and git),
|
||||
and \emph{outcomes} (survival, test status, and a per-commit \textsc{human}/\textsc{ai}
|
||||
label)---across a heterogeneous fleet of developer machines, with mandatory secret
|
||||
redaction and provenance versioning. The result is a corpus of the form
|
||||
\textit{(instruction $\to$ agent trajectory $\to$ verified diff $\to$ survival
|
||||
outcome)}, which supports supervised, preference, and outcome-verified
|
||||
reinforcement objectives, and a novel evaluation regime---\emph{survival
|
||||
holdout}---that scores a model on whether its generated changes would have endured.
|
||||
\end{abstract}
|
||||
\end{titlepage}
|
||||
|
||||
\tableofcontents
|
||||
\newpage
|
||||
|
||||
% ============================================================================
|
||||
\section{Thesis: time is the annotator}
|
||||
% ============================================================================
|
||||
|
||||
Public code datasets are overwhelmingly \emph{cross-sectional}: a snapshot of a
|
||||
repository at one instant, scraped and tokenized. Agentic benchmarks add the
|
||||
task dimension (an instruction plus a repository state), and instruction-tuned
|
||||
corpora add human preference labels. All three ask the same implicit question:
|
||||
\emph{what code was written?} None asks the question that a working engineer
|
||||
actually cares about: \emph{what code should have been written---and how do we
|
||||
know?}
|
||||
|
||||
A version-control history answers that question for free, because it contains
|
||||
the future. Every unit of code an author commits is, over the following weeks
|
||||
and years, subjected to a merciless empirical test: it is kept, edited, or
|
||||
deleted by real subsequent work. Code that survives dozens of refactors was
|
||||
\emph{validated by time}; code rewritten the next morning is a labeled negative.
|
||||
No annotator, rubric, or reward model produced these labels---the history did,
|
||||
and it did so at the scale of every commit ever made.
|
||||
|
||||
This paper develops that observation into a training methodology. Our central
|
||||
claims are:
|
||||
|
||||
\begin{enumerate}
|
||||
\item \textbf{Survival is a quality signal.} The persistence of a unit of code
|
||||
is a time-validated, annotation-free proxy for its quality, correctness, and
|
||||
architectural fit.
|
||||
\item \textbf{Shapes, not lines, are the unit of interest.} Line survival is
|
||||
noisy; the durable signal lives at the level of \emph{shapes}---function
|
||||
signatures, module boundaries, abstractions, and interfaces. Some shapes last
|
||||
far longer than others, and those are the good bones.
|
||||
\item \textbf{Trajectory beats snapshot.} A model should learn how code
|
||||
\emph{moves}---the ordered sequence of states a file passes through---not merely
|
||||
its terminal form.
|
||||
\item \textbf{The three layers must be co-registered.} Agent reasoning (the
|
||||
\textsc{how}), the verified diff (the \textsc{what}), and the survival outcome
|
||||
(the \textsc{result}) are individually useful and jointly transformative: they
|
||||
yield grounded tuples \textit{(instruction $\to$ trajectory $\to$ diff $\to$
|
||||
outcome)} that no single-layer corpus can express.
|
||||
\end{enumerate}
|
||||
|
||||
% ============================================================================
|
||||
\section{Formalism: code survival}
|
||||
% ============================================================================
|
||||
|
||||
\subsection{Line and hunk survival}
|
||||
|
||||
Let a repository's history be an ordered sequence of commits
|
||||
$c_0, c_1, \dots, c_T$. For a unit of code $u$ (a line, a hunk, or a shape)
|
||||
introduced at commit $c_b$ (\emph{birth}) and first modified or removed at
|
||||
commit $c_d$ (\emph{death}), define its survival as the wall-clock duration
|
||||
|
||||
\[
|
||||
\survival(u) \;=\; t(c_d) - t(c_b),
|
||||
\qquad
|
||||
E(u) \;=\; d - b,
|
||||
\]
|
||||
|
||||
where $E(u)$ is the number of intervening commits the unit \emph{survived
|
||||
through} (its edit-distance longevity). A unit still present at the head commit
|
||||
$c_T$ is right-censored; we treat it as alive with a lower bound
|
||||
$\survival(u) \ge t(c_T) - t(c_b)$ and handle censoring with standard
|
||||
survival-analysis estimators (Kaplan--Meier for population curves; Cox models
|
||||
when conditioning on features).
|
||||
|
||||
Line survival is recoverable from \texttt{git} via incremental blame reconstruction
|
||||
(equivalently, the machinery behind code half-life analyses): replay the diff
|
||||
stream, assign every added line a birth, and record its death when a later diff
|
||||
deletes or replaces it. The output is a per-line record
|
||||
$\langle \text{repo}, \text{path}, \text{birth}, \text{death}, \survival, E,
|
||||
\text{author\_type}\rangle$.
|
||||
|
||||
\subsection{From lines to shapes}
|
||||
|
||||
Line survival is high-variance: reformatting, renaming, and mechanical edits
|
||||
kill lines without killing \emph{ideas}. The load-bearing signal is the survival
|
||||
of \emph{shapes}---structural units recovered from the abstract syntax tree:
|
||||
function signatures, type/class definitions, module and package boundaries,
|
||||
public interfaces, and recurring design patterns. A shape $\shape$ is identified
|
||||
across commits by a stable structural key (e.g.\ a normalized signature or an
|
||||
interface hash) rather than by text, so it can survive an internal rewrite that
|
||||
replaces every one of its lines. We then measure $\survival(\shape)$ exactly as
|
||||
above.
|
||||
|
||||
The empirical claim is that the distribution of $\survival(\shape)$ is heavy-tailed
|
||||
and \emph{informative}: a small fraction of shapes---clean abstractions,
|
||||
well-chosen interfaces---persist across the entire visible history, while the
|
||||
majority churn. Training a generator to prefer the long-lived tail is training
|
||||
it toward durable architecture, which is precisely the competence that
|
||||
cross-sectional corpora fail to teach.
|
||||
|
||||
\subsection{Durability label}
|
||||
|
||||
Given a survival distribution we define a per-unit durability label by upper and
|
||||
lower quantiles $q_{\text{hi}}, q_{\text{lo}}$ of $\survival$ (computed
|
||||
within-repository and within-language to control for base rates):
|
||||
|
||||
\[
|
||||
\ell(u) =
|
||||
\begin{cases}
|
||||
\textsc{durable} & \survival(u) \ge q_{\text{hi}}\\
|
||||
\textsc{ephemeral} & \survival(u) \le q_{\text{lo}}\\
|
||||
\textsc{neutral} & \text{otherwise.}
|
||||
\end{cases}
|
||||
\]
|
||||
|
||||
\textsc{ephemeral} units are not discarded---they are the negative class, and
|
||||
they are as valuable as the positives.
|
||||
|
||||
% ============================================================================
|
||||
\section{The three co-registered layers}
|
||||
% ============================================================================
|
||||
|
||||
The corpus fuses three sources, each answering a different question, joined on a
|
||||
common \emph{(repo, commit, timestamp)} key.
|
||||
|
||||
\begin{table}[h]
|
||||
\centering
|
||||
\begin{tabular}{@{}lll@{}}
|
||||
\toprule
|
||||
\textbf{Layer} & \textbf{Source} & \textbf{Teaches} \\
|
||||
\midrule
|
||||
\textsc{How} (reasoning + tools) & Claude Code session transcripts & the agent trajectory:\\
|
||||
& ($\sim$5{,}190 sessions, $\sim$4.3\,GB) & task $\to$ think $\to$ tool call $\to$ observe \\[4pt]
|
||||
\textsc{What} (verified change) & file-history + git diffs & the actual before$\to$after code \\[4pt]
|
||||
\textsc{Result} (label + reward) & survival $+$ CI $+$ human/ai tag & did it last? did it pass? who wrote it? \\
|
||||
\bottomrule
|
||||
\end{tabular}
|
||||
\caption{The three data layers. Individually useful; jointly, they yield grounded
|
||||
\textit{(instruction $\to$ trajectory $\to$ diff $\to$ outcome)} tuples.}
|
||||
\end{table}
|
||||
|
||||
The join is the value. Public agentic datasets have the \textsc{how} or the
|
||||
\textsc{what}; almost none carry the \textsc{result} at the granularity of
|
||||
survival, and none is additionally labeled by author type. Because our
|
||||
transcripts and commits are co-located on the same machines, each agent
|
||||
trajectory can be linked to the commit(s) it produced (by timestamp proximity,
|
||||
repository, and the version-control tool calls embedded in the trajectory), and
|
||||
each resulting hunk inherits a survival outcome. We can therefore ask, and
|
||||
learn from, the question no other corpus can pose: \emph{which agent decisions
|
||||
produce code that lasts?}
|
||||
|
||||
\subsection{The human/ai axis}
|
||||
|
||||
Every commit carries an author-type label---\textsc{human} (the developer's own
|
||||
hands, including historical corporate identities) or \textsc{ai} (an autonomous
|
||||
agent account). This axis is not decoration; it lets survival be conditioned on
|
||||
authorship, quantifying (for example) whether AI-authored abstractions survive
|
||||
at human rates, and isolating the trajectory features that predict durability
|
||||
regardless of author. In the reference dataset the \textsc{ai} account first
|
||||
appears in late 2024 and, within eighteen months, produces contributions at
|
||||
several times the \textsc{human} rate---so the corpus also documents, in real
|
||||
data, the transition of authorship from human to agent.
|
||||
|
||||
% ============================================================================
|
||||
\section{Construction pipeline}
|
||||
% ============================================================================
|
||||
|
||||
The pipeline is deliberately decomplected---one directed path, one artifact per
|
||||
stage, one canonical implementation:
|
||||
|
||||
\[
|
||||
\textbf{extract} \to \textbf{normalize} \to \textbf{link} \to \textbf{redact}
|
||||
\to \textbf{format} \to \textbf{version/store}.
|
||||
\]
|
||||
|
||||
\begin{description}[leftmargin=1.2em]
|
||||
\item[Extract.] Two collectors. (i) A \emph{session} collector reads
|
||||
\texttt{\textasciitilde/.claude/projects/*.jsonl} into structured trajectories.
|
||||
(ii) A \emph{history} collector replays each repository's git graph into the
|
||||
per-line/per-shape survival records of Section~2.
|
||||
\item[Fleet aggregation.] Development is spread across a heterogeneous fleet of
|
||||
machines, each holding a partial \texttt{\textasciitilde/.claude} and partial
|
||||
working copies. The session collector runs \emph{per host} and ships its
|
||||
sanitized shard to a central store; shards are deduplicated by session id and
|
||||
content hash so re-runs are idempotent and no machine is a single point of
|
||||
truth.
|
||||
\item[Normalize.] One canonical schema:
|
||||
\texttt{trajectory\{task, turns[\{think, tool\_calls, tool\_results\}], outcome\}}
|
||||
and \texttt{unit\{repo, path, kind, birth, death, survival, edits, author\_type,
|
||||
durable\}}.
|
||||
\item[Link.] Join trajectory $\leftrightarrow$ commit $\leftrightarrow$ survival
|
||||
on \emph{(repo, commit, time)}.
|
||||
\item[Redact.] \textbf{Mandatory and non-negotiable.} Session transcripts and git
|
||||
history are known to contain live credentials (private keys, cloud and service
|
||||
tokens). Redaction runs before any artifact leaves its host: secret scanning,
|
||||
key/token/\texttt{BEGIN}-block scrubbing, PII removal, and a private/public
|
||||
license gate. Failed or aborted sessions are \emph{labeled}, not dropped.
|
||||
\item[Format.] Emit SFT, preference, trajectory, and evaluation splits
|
||||
(Section~5).
|
||||
\item[Version/store.] All artifacts and metadata land in a single versioned
|
||||
dataset (\texttt{zen-agentic-dataset}); large blobs are held out of git and
|
||||
backed up to a hub (HuggingFace), with a private repository for the full corpus
|
||||
and a public repository for the redacted, license-clean subset. The survival and
|
||||
authorship metadata form the provenance layer for every record.
|
||||
\end{description}
|
||||
|
||||
% ============================================================================
|
||||
\section{Training and evaluation formulations}
|
||||
% ============================================================================
|
||||
|
||||
Survival is not merely a filter; it is an objective.
|
||||
|
||||
\begin{description}[leftmargin=1.2em]
|
||||
\item[Supervised (durable targets).] Standard next-token / next-action loss,
|
||||
with examples weighted by $w(u) = f(\survival(u))$ so the model imitates
|
||||
long-lived code more strongly than churn.
|
||||
\item[Preference / DPO.] Pairs $(\textsc{durable}, \textsc{ephemeral})$ drawn
|
||||
from the same file and neighborhood give a natural preference signal:
|
||||
\emph{prefer the change that would have survived}.
|
||||
\item[Outcome-verified RL.] The reward is the join of \emph{did it pass}
|
||||
(CI/test status) and \emph{did it last} (survival), yielding a dense,
|
||||
non-gameable signal for policies that act over tool-use trajectories.
|
||||
\item[Trajectory modeling.] Train directly on state transitions
|
||||
$s_t \to s_{t+1}$ (how a file evolves), teaching refactoring and growth rather
|
||||
than one-shot synthesis.
|
||||
\item[Survival-holdout evaluation.] A benchmark that scores a model on whether
|
||||
its generated change matches (or would plausibly survive as well as) the change
|
||||
that historically endured at that point in the file's trajectory. Unlike
|
||||
single-test pass/fail, this rewards durable design, not merely green pipelines.
|
||||
\end{description}
|
||||
|
||||
% ============================================================================
|
||||
\section{Why survival-weighting produces better agents}
|
||||
% ============================================================================
|
||||
|
||||
Imitation learning on cross-sectional code teaches a model to reproduce the
|
||||
average of what was written---including the large fraction that was immediately
|
||||
undone. Outcome-verified benchmarks improve on this but reward only the narrow
|
||||
target of passing a fixed test, which is gameable and silent about architecture.
|
||||
Survival-weighting adds the missing axis: it rewards code that continued to be
|
||||
\emph{correct enough, clear enough, and well-factored enough that future work
|
||||
built on it rather than around it}. That is the closest available analogue to a
|
||||
natural-selection objective for software, and it is obtainable at the scale of a
|
||||
career's version-control history rather than the scale of hand-written rubrics.
|
||||
Because the same corpus carries the agent's reasoning and the author-type label,
|
||||
it uniquely supports the question that matters for building coding agents:
|
||||
\emph{which patterns of agent behavior yield durable code?}
|
||||
|
||||
% ============================================================================
|
||||
\section{Privacy, provenance, and ethics}
|
||||
% ============================================================================
|
||||
|
||||
The corpus is derived from private development history and therefore carries real
|
||||
obligations. Secret redaction is a hard gate, enforced before egress and verified
|
||||
in tests. Private-repository code is segregated under the private dataset with
|
||||
license controls; only redacted, license-clean records enter the public split.
|
||||
Every record retains provenance---source host, session id, commit, author type,
|
||||
and pipeline version---so any datum can be traced, re-derived, or withdrawn. The
|
||||
methodology stores \emph{all} exported data and metadata under one versioned home
|
||||
with fleet-wide backup, so the corpus is durable, auditable, and reproducible.
|
||||
|
||||
% ============================================================================
|
||||
\section{Conclusion}
|
||||
% ============================================================================
|
||||
|
||||
The history of code is a longitudinal experiment that has already been run, at
|
||||
enormous scale, with time as the annotator. Reading survival as a label---and
|
||||
elevating the unit of interest from lines to the shapes that last---turns a
|
||||
developer's version-control graph into a uniquely valuable training corpus for
|
||||
agentic software models: one that teaches not what code was written, but what
|
||||
code deserved to endure. Co-registered with agent trajectories and an
|
||||
author-type axis, it lets us train and measure agents against the only judge
|
||||
that ever mattered, which is the future.
|
||||
|
||||
\end{document}
|
||||
Reference in New Issue
Block a user