The AI model development lifecycle

The Model Lifecycle

It's the SDLC — same nine-phase loop, same reason it's drawn as a circle and not a line. The labels change (Data instead of Analysis, Train instead of Implementation), but the shape is identical: plan, build, ship, watch, and feed what you learn back into the next pass.

Every stage below links to where this project actually did it — and names honestly the two stages it didn't.

feeds back in Plan Requirements Data Analysis Design Design Train Implementation Evaluate Testing Package Build Deploy Release Monitor Operate Iterate Maintain
Nine stages, same loop the SDLC draws — only the far-left node (Monitor) is where almost this entire project actually lives. The two dashed nodes are named honestly below as gaps, not covered by a dedicated page.
covered by real work in this project where most of this project's work happened honest gap — not covered
1

Plan SDLC: Requirements

Decide what to build and why — in our case, a model from scratch, on one machine, specifically so every later stage would be inspectable rather than a black box.

Honest gap: this stage has no dedicated page. It's the conversation that started everything else, not an artifact.
2

Data SDLC: Analysis

Gather and understand what the model will actually learn from — 40,000 lines of real Shakespeare, and the 65-symbol dictionary built directly from it.

Byte-Level Bard →Getting Less Wrong →
3

Design SDLC: Design

Choose the architecture: token + position embeddings, six attention blocks, a final projection to logits — the actual equations behind every layer.

Byte-Level Bard →Look at the Maths →
4

Train SDLC: Implementation

Run the actual training loop: 5,000 real steps, loss falling from 4.2886 to 0.9795, on one GPU.

Getting Less Wrong →
5

Evaluate SDLC: Testing

Sample real output, check it against held-out text. Testing caught a real defect here: validation loss stopped improving around step 3,750 while training loss kept falling — the model had started memorizing, not generalizing.

The Journey →The Whole Story →
6

Package SDLC: Build

Convert the trained checkpoint into a format something else can run — GGUF, hand-mapped tensor by tensor. Two real bugs surfaced and got fixed here.

Byte-Level Bard →
7

Deploy SDLC: Release

Ship it somewhere it can actually be run — a three-line Modelfile, ollama create, and it behaves like any other local model.

Byte-Level Bard →
8

Monitor SDLC: Operate

Watch what the running model is actually doing — and this is where almost this entire project lives. Real computation graphs, real GPU kernels, real sampling probabilities, real gaps named honestly where nothing readable exists.

Live Computation Graph → tiny-shakespeare Graph → GPU Kernel Trace → Sampling Tree → The Missing Index → The Unlabeled Dials →
9

Iterate SDLC: Maintain

Take what monitoring revealed and feed it back into the next pass — here, that would mean retraining with early stopping around step 3,750, or fixing the dropped lm_head bias from the GGUF conversion.

Honest gap: we found real, fixable issues at the Evaluate and Package stages and never closed the loop by retraining. That's the natural next step, not yet taken.

Why draw it as a loop, not a line

The SDLC stopped being drawn as a straight line decades ago for the same reason this diagram is a circle: Monitor isn't the end. What it reveals — a real overfitting point, a real dropped bias term — is supposed to feed back into Data and Train for the next pass. This project walked eight of the nine stages for real. The ninth, Iterate, is exactly the honest, named gap that's left.