Overflow the Laptop Before You Rent Compute

Remote AI is a cost, not a default. Local tools should fail before any hop. Overflow is the only honest ticket out.

Most coding prompts never need a rented box. They need grep, tests, and a tight diff. Cloud latency is a tax on small questions.

A laptop already holds the working tree. Secrets live there by design. Silence on the wire is a feature.

Teams still ship every half-formed prompt upstairs. The hop feels free because the invoice is delayed. Latency, leakage, and offline breakage still land.

This note treats that hop as a measured overflow. It does not treat remote models as craft. Craft stays on disk until the machine files a claim.

The claim that justifies a hop

Three signals can justify leaving disk. Memory pressure is the first. A secret-clean payload is the second. A live network path is the third.

Miss any one of those signals and the hop is theater. Theater looks like engineering under a chat log. It is still theater.

Latency is not a vibe. A local test loop returns in milliseconds. A remote completion adds a round trip you cannot cache.

Secrets are not a vibe either. A .env file does not become safe in a prompt wrapper. Offline work does not become optional because a server is idle.

Think of the laptop as a harbor. Cargo stays in port until the ship proves a route. A free pier still needs a bill of lading.

Where a free server actually wins

Local-first is not local-only. Burst work can exceed a fan and a stick of RAM. That is overflow, not fashion.

A free server wins when three conditions hold together. The job is bounded and reproducible. The payload has no credentials. The operator can wait on the wire.

It loses when the repo cannot leave the building. It loses when the network is a rumor. It loses when the prompt is a fishing net.

MonkeyCode enters only as an overflow lane, not a home. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The lane offers free model access and a free server option. No model names, quotas, or hardware are claimed here.

Use that lane after a local veto, not before. The veto is a script, not a mood. Moods leak keys.

Artifact: a hop veto you can run

The workflow below is a proposal. Run it on a throwaway clone first. Treat the printout as a gate, not a score.

It inspects the git worktree, not the chat. It refuses remote work when secret-like paths appear. It also refuses when the payload is empty or huge.

Save this as hop_veto.py at the repo root.

#!/usr/bin/env python3
"""Propose LOCAL_ONLY or REMOTE_ELIGIBLE. Not a security scanner."""
from __future__ import annotations

import os
import subprocess
import sys
from pathlib import Path

SECRET_HINTS = (
    ".env",
    ".pem",
    "id_rsa",
    "id_ed25519",
    "credentials",
    "kubeconfig",
    ".p12",
    ".key",
)
MAX_BYTES = 250_000
MIN_BYTES = 40
OFFLINE_FLAG = Path(".offline")


def git_out(*args: str) -> str:
    r = subprocess.run(
        ["git", *args],
        check=True,
        capture_output=True,
        text=True,
    )
    return r.stdout


def worktree_paths() -> list[Path]:
    raw = git_out("ls-files", "-co", "--exclude-standard")
    root = Path(git_out("rev-parse", "--show-toplevel").strip())
    return [root / line for line in raw.splitlines() if line]


def secret_hits(paths: list[Path]) -> list[str]:
    hits = []
    for path in paths:
        name = path.name.lower()
        blob = str(path).lower()
        if any(h in name or h in blob for h in SECRET_HINTS):
            hits.append(str(path))
    return hits


def source_bytes(paths: list[Path]) -> int:
    total = 0
    for path in paths:
        if not path.is_file():
            continue
        if path.suffix.lower() not in {".py", ".ts", ".js", ".go", ".rs", ".java", ".md"}:
            continue
        try:
            total += path.stat().st_size
        except OSError:
            continue
    return total


def mem_pressure_kb() -> int | None:
    avail = Path("/proc/meminfo")
    if not avail.exists():
        return None
    for line in avail.read_text().splitlines():
        if line.startswith("MemAvailable:"):
            return int(line.split()[1])
    return None


def main() -> int:
    if not Path(".git").exists() and subprocess.run(
        ["git", "rev-parse", "--is-inside-work-tree"],
        capture_output=True,
    ).returncode != 0:
        print("LOCAL_ONLY reason=not_a_git_worktree")
        return 2

    if OFFLINE_FLAG.exists() or os.environ.get("HOP_OFFLINE") == "1":
        print("LOCAL_ONLY reason=offline_flag")
        return 3

    paths = worktree_paths()
    hits = secret_hits(paths)
    if hits:
        print("LOCAL_ONLY reason=secret_like_path")
        for hit in hits[:12]:
            print(f"  {hit}")
        return 4

    size = source_bytes(paths)
    if size < MIN_BYTES:
        print(f"LOCAL_ONLY reason=payload_too_small bytes={size}")
        return 5
    if size > MAX_BYTES:
        print(f"LOCAL_ONLY reason=payload_too_large bytes={size}")
        return 6

    avail = mem_pressure_kb()
    # Remote is eligible only when local RAM looks tight.
    if avail is not None and avail > 1_500_000:
        print(f"LOCAL_ONLY reason=ram_still_comfortable kb={avail}")
        return 7

    print(f"REMOTE_ELIGIBLE bytes={size} mem_available_kb={avail}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

Run it from a clean clone, then from a dirty one. The exit code is the decision. Logs are for humans, not for models.

python3 hop_veto.py; echo exit:$?
touch .offline
python3 hop_veto.py; echo exit:$?
rm .offline
HOP_OFFLINE=1 python3 hop_veto.py; echo exit:$?

A passing remote print is not permission to paste the tree. It is permission to consider a redacted slice. Slice means files you already meant to publish.

A small rehearsal, not a benchmark

Label this rehearsal as unexecuted on your metal until you run it. The numbers below are fixtures for the gate. They are not product claims.

Create sample_app/ with one main.py and no env files. Copy hop_veto.py beside it. Init git, add the python file, and run the veto.

Expected path on a quiet Linux box is LOCAL_ONLY with ram comfort. That is correct. Comfort means the laptop still owns the loop.

Then fake pressure without hurting the host. Export a lie only inside the script if you must. A better drill is a tiny ram cgroup, if you have one.

# Fixture only. Do not treat as a load test.
git init sample_app
cd sample_app
printf 'print("ok")\n' > main.py
git add main.py
# Expect LOCAL_ONLY on a machine with spare RAM.
python3 ../hop_veto.py

Add a planted secret name and watch the gate slam. cp /dev/null .env is enough for the name check. The script does not open the file.

That miss is intentional. Name policy is cheap and local. Content scanning is a different program with a different risk.

Latency as a harbor fee

Clock the local loop before you admire a remote token stream. A unit test that returns in 80 ms is a fact. A chat round trip of two seconds is another fact.

Those facts do not need a leaderboard. They need a budget line in the runbook. If the loop is already honest, keep it.

Offline days make the budget brutal. Trains, planes, and locked-down build rooms still exist. A server that you cannot reach is not free. It is absent.

Absence is not a moral failing. It is topology. Topology belongs in the veto, which is why .offline exists.

Secrets stay a local object

A remote overflow path is still a transcript. Transcripts get copied. Copied text has a longer life than a shell history.

The veto uses ugly name matching on purpose. It is a speed bump, not a vault. Vaults belong in a real secret scanner you already trust.

Do not widen the script into a prompt packer. Packing is how keys hitch a ride. Hitchhiking keys are how local-first dies.

If the printout says REMOTE_ELIGIBLE, send a patch-sized question. Send a failing test and the function under fire. Do not send the house keys to pay the harbor fee.

When the free server is the wrong harbor

Skip this approach if you handle regulated patient data. Skip it for unpaid production incident keys. Skip it when legal holds freeze the working tree.

Skip it on air-gapped networks that must stay that way. A free server cannot join a room it cannot enter. Pretending otherwise is a outage with extra steps.

Skip it if your “overflow” is actually indecision. Indecision is a local refactor. Renting compute will not name the function.

Monorepos that blow MAX_BYTES should not raise the cap blindly. Split the question instead. The wire should carry a sample, not a district.

Windows hosts will miss /proc/meminfo. That miss fails closed toward local work. Closed is the point.

How this stays distinct from chat theater

Recent talk treats fluent generation as delivered engineering. Fluency is cheap. Review, tests, and a veto are not.

The veto does not grade prose. It grades whether the laptop already lost. If the laptop did not lose, the chat is optional.

Optional chat can still teach. Teaching does not require a payload dump. Dumping is how a cheap hop becomes an expensive story.

Keep the analogy small. Disk is the workshop. The wire is a courier. Couriers do not own the bench.

Limits you should keep in the file header

The script ignores binary assets and lockfile churn. It can under-count real context. It can over-count markdown novels in /docs.

It does not talk to any model. It does not start a server. It does not prove a remote job will finish.

It will not save you from a paste into a random box. Policy lives in habit plus review. Code only makes the habit louder.

Adjust MAX_BYTES only with a recorded reason. Reasons belong in commit messages. Silent cap changes are how gates rot.

A closing check, then stop

Start on disk. Fail on disk. Overflow only with a clean, small, online payload.

If the veto still prints REMOTE_ELIGIBLE, a free server path can take the burst. MonkeyCode is one such overflow lane after that print. Probe it with a redacted failing test, not with the whole house.