Technical product management · model evaluation

Turning model modification into a gated product decision

A single-GPU workflow that starts with the product question, filters models through real hardware and licensing constraints, searches reversible interventions, and ends with paired findings, explicit claim maturity, and a recallable release bundle.

Context

The first version of this work behaved like a research project: pick a model, run a long evaluation, inspect the result, and decide what to do next. That works once. It does not support iterative weight changes, because every new adapter reopens the same questions—was the base identical, did both arms see the same prompts, which checkpoint was selected, did the run fail halfway through, what can be deleted, and what evidence is strong enough to publish. On one 12 GiB GPU, a thirty-six-hour test is not just slow; it removes the feedback loop the product needs.

Decision

Treat evaluation as a product operating system rather than a final QA step. Define the decision and resource envelope first; make model selection, alteration, candidate selection, paired evaluation, evidence maturity, retention, and publication separate gates; and require every gate to leave a checkable artifact behind.

Approach

  • Started with an evidence contract: the decision the run must support, the behavior to change, the capability floor to protect, the GPU/disk/time envelope, and the conditions that stop the experiment instead of extending it indefinitely.
  • Turned model selection into a feasibility funnel. Task fit, license, architecture and tokenizer support, quantization, adapter compatibility, VRAM, disk footprint, and overnight runtime all have veto power before an expensive run begins.
  • Pinned the untouched base by model revision and file hashes, then made a removable LoRA adapter the intervention unit. That keeps every experiment reversible and makes retaining a result cheaper than retaining another full model copy.
  • Journaled the full Heretic search and preserved the Pareto front rather than only the winner. A frozen policy selects the lowest-drift candidate that meets the refusal threshold, so the rule does not move after an attractive trial appears.
  • Separated the quick gate from the publication tier. A quick or code-focused suite must finish in an iteration-friendly window and decides whether more compute is warranted; it is never silently promoted into a publication claim.
  • Required OG and OB to run the same prompt ids under the same runtime, with per-sample records retained. Refusal signals and capability measures remain separate, and confidence intervals are added only where the scorer and records actually support them.
  • Made checkpoints and failure state first-class: live progress, resumable queues, a single GPU lease, time budgets, top-five Pareto retention, and explicit gates for selection, public promotion, deletion, and cleanup.
  • Packaged the adapter, optional GGUF, base identity, hashes, metrics, Pareto data, audit chain, AAR, limitations, and recall instructions together. Once that bundle re-verifies, duplicate base weights can be removed without erasing the experiment's identity.

The technical product frame

The product is the decision system—not the altered weights.

Decision contract

Can a reversible intervention reduce unwanted refusals without materially damaging useful capability, on one 12 GiB GPU, inside an overnight iteration window—and leave enough evidence to reproduce or reject the decision later?

User value

Does the change unlock the intended work?

Capability

What got better, stayed flat, or regressed?

Behavior risk

Did refusal change, and were new answers actually reviewed?

Feasibility

Will it run inside the GPU, disk, and time envelope?

Reversibility

Can the intervention be removed without rebuilding the base?

Evidence maturity

Screening signal, held-out result, or publication claim?

Model choice → final finding

Eight gates, each answering a different failure mode.

  1. 01

    Frame the decision

    What choice will this evidence authorize?

    A benchmark without a decision becomes metric tourism. The target behavior, capability floor, compute budget, and stop conditions have to exist before a model is downloaded.

    Exit gate
    Written success contract
    Evidence
    Decision brief + limits
  2. 02

    Shortlist for the real machine

    Can this model finish the job on the hardware we own?

    Task fit is only one requirement. License, architecture support, adapter compatibility, quantization path, VRAM, disk, and overnight runtime are product constraints too.

    Exit gate
    Feasibility canary
    Evidence
    Model card + pinned candidate
  3. 03

    Freeze the control

    What exactly counts as the untouched model?

    The base revision, files, runtime, sampling, and prompt IDs must be fixed before alteration. Otherwise a later difference can be blamed on anything.

    Exit gate
    Baseline identity verified
    Evidence
    Base manifest + hashes
  4. 04

    Search reversibly

    Which interventions are worth comparing?

    A LoRA adapter keeps the experiment removable. Journaling every Heretic trial preserves the misses and stops one hand-picked checkpoint becoming the story.

    Exit gate
    Search budget exhausted
    Evidence
    Trial journal + adapters
  5. 05

    Select the trade-off

    Which candidate earns expensive evaluation?

    Refusal reduction and model drift pull in opposite directions. A frozen Pareto policy makes the choice repeatable and prevents moving the threshold after seeing a favorite.

    Exit gate
    Policy-qualified candidate
    Evidence
    Pareto front + top five
  6. 06

    Run the paired gate

    Did the adapter—not the test setup—cause the change?

    OG and OB receive the same prompt IDs under the same runtime. Refusal signals and capability tasks stay separate so an attractive average cannot hide a damaging trade-off.

    Exit gate
    Quick suite passes
    Evidence
    Per-sample pairs + deltas
  7. 07

    Match evidence to the claim

    Is this a screening result or something publishable?

    A short run should decide whether to spend more compute—not quietly become the headline. Publication requires the larger tier, reviewed judgment, and explicit license check.

    Exit gate
    Evidence maturity named
    Evidence
    Quick or publication AAR
  8. 08

    Retain, decide, learn

    Can someone recall the result after the base weights are gone?

    The small adapter, GGUF, base identity, hashes, metrics, audit chain, and limitations travel together. The final choice can be promote, revise, or stop—all are valid outcomes.

    Exit gate
    Recall bundle validates
    Evidence
    Release bundle + decision record

Spend evidence deliberately

Fast enough to iterate; strict enough to publish honestly.

Minutes

Canary

Proves the model, adapter, tokenizer, and runtime can complete one bounded path.

Decision: abort broken plumbing early.
≤ 3 hours

Quick / code quick

Paired capability and refusal screen for every candidate that survives selection.

Decision: spend—or do not spend—publication compute.
≤ 12 hours · resumable

Publication tier

Larger paired samples for the chosen release candidate, followed by reviewed judgment.

Decision: whether a broader claim is supportable.

What the first full cycle taught us

The workflow produced a useful answer—and exposed its own remaining gaps.

3B

Nightly iteration is feasible

Two hundred trials fed a 17-point Pareto front; the selected adapter completed a 10-task paired screen in 75 minutes with every release check passing.

7B

Legacy evidence can be retained without overstating it

The completed comparison and artifacts were imported and verified, while the absent per-sample records remain a visible limitation rather than reconstructed certainty.

14B

Quick evidence is not publication evidence

The paired quick screen completed on the consumer GPU. The broader claim stays withheld until the larger tier and reviewed judge record clear their gates.

Recommendations going forward

What I would make non-negotiable on the next model.

  • Choose the job before the model. Start with a task and deployment envelope; do not reverse-engineer a product case from a model you already want to run.
  • Separate selection data from validation data. The prompts that pick an adapter cannot be the only prompts used to prove it.
  • Make compute a roadmap constraint. A theoretically better model that cannot finish the gate overnight is not the better iteration platform.
  • Require per-sample pairing from day one. Aggregate scores are useful for triage; paired records are what support uncertainty and root-cause analysis.
  • Publish the limitation register beside the chart. Missing judges, single seeds, unsupported executors, and provenance gaps are product facts, not footnotes.
  • Retain the smallest sufficient artifact. Keep the adapter, GGUF, base revision, hashes, and evidence bundle; release duplicate base weights when recall is proven.

Outcomes

  • The first complete code-model cycle searched 200 interventions, retained a 17-point Pareto front, selected Trial 187 under the frozen policy, and completed its 10-task paired quick suite in 75 minutes—short enough to support a nightly iteration rather than a multi-day wait.
  • The selected 3B adapter passed 13 of 13 release checks with zero blockers or warnings; its private recall bundle was uploaded, re-downloaded, and hash-verified before the local result was treated as safely retained.
  • A completed Mistral 7B run was imported without pretending it contained evidence it never recorded: its adapter and aggregate comparison remain useful, while absent per-sample pairing is carried forward as a named limitation.
  • A Qwen 14B selected adapter completed the paired quick screen on the same consumer GPU. Its larger publication claim remains deliberately withheld behind the publication-tier and reviewed-judge gates.
  • The workflow now supports an operator from SSH through a menu or scriptable CLI: create or resume a campaign, inspect the queue and GPU, freeze the Pareto shortlist, evaluate, validate, package, and export machine-readable metrics for plotting.
  • The output is a decision record rather than a model trophy: promote, revise, or stop are equally valid conclusions, and the evidence says which one is currently justified.

Control boundary

This is a public-safe operating-method case study built from work on my own hardware and models. Raw prompts, completions, private model artifacts, local paths, and access details stay private. The 3B and 14B numbers described here are quick-tier screening evidence from one seed, not universal safety or capability claims; deterministic refusal heuristics are not an official StrongREJECT judge, and code-execution benchmarks remain excluded until a validated sandbox exists. The workflow records those absences rather than filling them with proxies.

What this taught me

The technical product-management move was not choosing a better benchmark. It was deciding what each level of evidence is allowed to authorize. The model shortlist is a portfolio decision under hardware and licensing constraints. Pareto selection is a prioritization decision between competing outcomes. The quick suite is a spend gate. The publication tier is a claim gate. The recall bundle is lifecycle management. Once those decisions are named, the engineering becomes easier to operate and much harder to overstate—and a negative result still leaves the product in a better state because the next iteration starts from a trusted baseline instead of a pile of checkpoints.

Rules at work here

Each links to the rule and the other work it governs.

  • Finished means auditable and reversibleA change is not finished when it ships. It is finished when someone can audit what happened and reverse it if they were wrong.
  • Evidence before outputA claimed defect ships with a test that fails before the fix and passes after it. Without that test it is an observation, and it gets labelled as one.
  • A result needs a controlA suite that can only produce one kind of answer has not measured anything. Run the control that would catch a degenerate system passing.
  • A boundary fitted on the suite cannot be validated by the suiteA configuration tuned against a set of cases cannot then be tested by those cases. The held-out stage is a separate artifact, not a longer version of the last one — and every pre-emptive adjustment spends some of the only unfitted evidence available.
  • State limits in the product, not the disclaimerMaturity — production, pilot, prototype, research — belongs on the surface someone actually touches. What a system cannot support, it should decline to say.

Try it

The companion evidence brief shows the selected 3B adapter, Pareto frontier, paired OG-vs-OB deltas, reproduction receipts, and the exact boundary on the public claim produced by this workflow.

Review the paired model findings →

Work with me

If this is the kind of problem you are trying to get moving — AI adoption that has to survive a security review, an audit, and the people who will actually operate it — I would like to hear about it.

Start a conversationThe method →All case studies →