48-Hour Field Notes: I Would Quarantine the Suggested Repro Before a Free Server Saw It

I keep meeting the same tempting shortcut, and I still do not trust it on sight. A coding model drafts a small patch, and a hosted machine is offered as the place to prove that patch. Would I paste a failing fixture into a box that I do not administer or even fully describe? I would not, until a local oracle exists and a quarantine gate has already passed on my own machine.

These notes are a forty-eight hour protocol, not a claim that I already scored any vendor. Nobody supplied measured runs, model names, quotas, hardware specs, or a promised duration for this account. I am writing the checks I would repeat, and I am labeling every sample below as an unexecuted proposal. If a step needs a number I was never given, I leave that number blank instead of inventing a result.

What I was actually told

The only product facts I will use are two availability claims that were supplied with this assignment. MonkeyCode currently offers free model access, and it also offers a free server option for trying a run. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

I do not know which model names sit behind that access, and I will not invent a lineup to sound precise. I also will not pretend the free box matches my laptop, because nobody gave me an image bill of materials. Availability is not the same thing as fitness, so the rest of this note is about fitness checks I can actually perform.

Hour 0 to 8: build the oracle before the prompt

Why would I ask a model to explain a failure that I cannot yet reproduce on my own machine? I would start from a tiny local test that fails for one named reason and prints a short message. That test should live in the repository, use pinned dependencies, and avoid every private fixture I own. Only after that red result would I ask a free model for a draft, and I would not treat the draft as evidence.

The sample below is only a proposal, and I have not executed it for this account or any hosted box. It exists so the later decision table has a concrete file to point at when the choice gets fuzzy. You should replace the function with your own bug, and you should keep the assertion text stable on purpose. If you cannot write even this small red test, a hosted rerun will not teach you what actually failed.

# proposed/test_budget_gate.py
# Unexecuted example. Run it locally before any hosted attempt.

def remaining(limit: int, spent: int) -> int:
    if spent > limit:
        raise ValueError("spent exceeds limit")
    return limit - spent

def test_remaining_rejects_overspend():
    try:
        remaining(10, 11)
    except ValueError as exc:
        assert "spent exceeds limit" in str(exc)
        return
    raise AssertionError("overspend was accepted")

if __name__ == "__main__":
    test_remaining_rejects_overspend()
    print("local oracle: red path exercised")

I would run that file with the interpreter I actually ship, not with a version I merely hope the server has. A green local run means the oracle itself is wrong, so I would stop and rewrite the assertion before continuing. A red local run is the only ticket that lets a model draft exist, and it is still not permission to upload anything.

python3 --version
python3 -m pip freeze > proposed/local-freeze.txt
python3 proposed/test_budget_gate.py

How I would talk to the free model

I would paste only the red assertion message and the function under test, not the rest of the repository. The prompt would ask for a patch against that function, and it would forbid any edit to the test file. If the reply touches the test anyway, I would discard it before the free server ever starts. A free model is a draft source in this protocol, not a judge of whether the bug is actually gone.

Hour 8 to 18: quarantine the bundle

Would a free server be convenient for a second observation after the local red test already exists? Yes, and that convenience is exactly why the uploaded bundle needs a quarantine gate before it leaves the laptop. I would copy only the test, the draft, and a lockfile into a fresh directory that has never held secrets. I would not copy dotenv files, shell history, cloud credentials, or production logs into that directory under any excuse.

If the failure appears only when private data is present, this hosted path is the wrong tool and I would stop. A scanner cannot prove a bundle is safe, but it can catch obvious token shapes before I get careless. I would rather fail the gate on a false positive than explain how a real key crossed onto a machine I do not own. The gate is allowed to be boring, because boring is what I want when the alternative is a leaked credential.

# proposed/quarantine_scan.py
# Unexecuted proposal. It flags shapes; it does not certify safety.
import pathlib, re, sys

PATTERNS = [
    re.compile(r"AKIA[0-9A-Z]{16}"),
    re.compile(r"-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----"),
    re.compile(r"(?i)(api[_-]?key|secret|token)\s*[:=]\s*\S+"),
]

root = pathlib.Path(sys.argv[1])
hits = []
for path in root.rglob("*"):
    if not path.is_file() or path.stat().st_size > 200_000:
        continue
    text = path.read_text(errors="ignore")
    for pattern in PATTERNS:
        if pattern.search(text):
            hits.append(f"{path}: matched a blocked pattern")
if hits:
    print("quarantine failed")
    print("\n".join(hits))
    sys.exit(2)
print("quarantine passed: no blocked patterns in bundle")

mkdir -p proposed/bundle
cp proposed/test_budget_gate.py proposed/bundle/
cp proposed/local-freeze.txt proposed/bundle/
python3 proposed/quarantine_scan.py proposed/bundle

What the scanner will not catch

A pattern list misses secrets that do not look like the samples I typed, including short passwords and private URLs. I would still review the bundle by eye, because automation is only the first gate and not the last one. Would I upload a binary, a database dump, or a notebook that still holds cached outputs? I would not, since those files hide strings that a simple line scanner can easily skip.

A decision table I would keep beside the keyboard

I would keep a small decision table beside the keyboard so I do not negotiate with myself at the moment of upload. Each row asks for a fact I can check locally, and each row refuses a hosted run when that fact is missing. Would I skip a row because the free server is already waiting and the draft looks pleasantly short? I would not, because a short draft can still weaken a test or smuggle a credential-shaped string into the bundle.

Question I can answer locally	If the answer is yes	If the answer is no
Do I have a red test without private data?	A free model may draft a patch.	Stop. Do not outsource the fixture.
Did the quarantine scan exit clean?	A free server may run that bundle only.	Delete the bundle and stay local.
Can I name the interpreter and lockfile?	Record both in the run note.	The hosted result cannot be compared.
Does the draft leave the assertion untouched?	It may be tried on the free server.	Reject it before any remote run.
Do I need a quota, SLA, or named model?	This protocol is insufficient.	The two availability claims are enough to try.

Hour 18 to 36: what I expect to break

I would assume the first hosted run disagrees with my laptop, and I would write the disagreement down before I theorize. A different patch level, a missing system library, or an unexpected working directory can all flip a tiny assertion. Would I then blame the model because the free server printed red while my laptop had failed for another reason? I would not, until I had compared the package set, the working directory, and the exact command line.

I would also watch for a quieter failure, which is a draft that passes only by editing the assertion text. If the hosted log is green and the local oracle file is no longer the same file, that green log is noise. I would diff the test before I diff the implementation, because that order stops me from celebrating a weakened check. A second environment is useful only when both sides ran the same question, not a quietly rewritten question.

python3 --version | tee proposed/host-version.txt
diff -u proposed/local-freeze.txt proposed/host-freeze.txt || true
diff -u proposed/test_budget_gate.py proposed/bundle/test_budget_gate.py

# proposed/run-note.md
# Template only. Fill it after a real run. Do not invent the blanks.
local_interpreter:
local_exit:
bundle_scan_exit:
host_interpreter:
host_exit:
test_file_diff: unchanged | changed
decision: repeat | stop

Hour 36 to 48: what I would repeat

The last twelve hours are for deciding what I would repeat, not for polishing a story about a tool. I would keep the local red test in version control before I asked any model for a suggested patch. I would send the smallest bundle that still fails, and I would scan that bundle once more before upload. I would record interpreter, lockfile hash, command, and exit code for the laptop and for the hosted run.

1. I would keep the failing test in version control before any model is allowed to suggest a patch.
2. I would scan the upload bundle after the copy step, not before, so the scan sees the real files.
3. I would compare package freeze files before I interpret a green or red result from the hosted run.
4. I would stop the protocol when the fixture needs private data, even if the free server is idle.

I would reject any draft that changes the assertion text unless a separate review explains why the question changed. I would treat a free server result as a second observation, never as the only oracle I am willing to trust. The repeatable part of this protocol is the split between drafting and running, not a particular vendor screen. Free model access is useful when I want a draft without opening a paid console or inventing a lineup of names.

A free server is useful when I want a second environment and I can afford to throw the whole bundle away. Neither option replaces the local test that told me the bug was real before any hosted machine was involved. Would I repeat the hosted run if the test file diff was not empty and the assertion had moved? I would not, because that rerun would be answering a different question than the one I started with.

Limits, and who should skip this

This protocol does not measure latency, answer quality, uptime, or how long either free option remains available. I was not given quotas, regions, image digests, or a support commitment, so I will not imply any of those facts. Please re-check the vendor's current documentation before you rely on availability, because a free tier can change. If your fixture contains customer data, keys, or regulated records, do not use the hosted path in any form.

You should also skip this approach when you need an attested build, a signed SBOM, or a formal benchmark against another assistant. A forty-eight hour field note cannot give you that evidence, and I will not dress a checklist up as a study. Teams that already have a sealed CI runner should keep using that runner for anything they might ship. I would rather lose one convenient rerun than explain how a production token left a laptop in a hurry.

If you already hold a local red test and a bundle that passed the quarantine scan, a bounded trial is reasonable. I would use the free model only to draft, and I would use the free server only as that second observation. That is the whole invitation I am willing to make, and it is still your call whether the paste is worth it. If either gate is missing, I would close the tab and stay on the machine I already know how to wipe.