Not Your Machine
Part II: The Shared Machine
You are here if
It passed on your machine and failed on theirs, and you have read the diff five times without finding the bug, because the bug is not in the diff. The failure names a limit you never set and have never hit: an argument list too long, a header policy, a missing entitlement. CI failed in three seconds, before your code could possibly have run. A command that works every time at your keyboard hangs forever when a session runs it, producing nothing at all. The test sweep is a wall of failures on a build variant you never ship. The deploy passed every local gate and a platform whose rules you did not write rejected it anyway. A repo you do not own has bounced your commit twice over a convention you had never heard of. You have fixed the flake, twice, and it is still flaking in CI.
The dividing question is whether there are two environments in the story. If everything happened on one machine and the green simply did not mean success, nothing diverged; that is chapter 1. If the works-on-my-machine claim reached you secondhand, in a delegate's completion report, verify the claim before the environment; that is chapter 6. This chapter begins when the same bytes genuinely behave two ways in two places, and its first instruction is that the next thing to read is not the code.
The mechanism
A program is a finite text, and the text is the smaller half of the run. Everything the code does not say, the environment answers at run time: whether the filesystem distinguishes two casings of one name, what PATH contains, whether stdin is a terminal, how long an argument list may be, which version of the dependency is actually installed, how deep the checkout goes, which headers the edge applies, what identity signs the build, how the scheduler interleaves two threads, whether the account paying for the runner has minutes left this month. Works here is a true statement about a conjunction: this code, plus one machine's answers to every one of those questions. Move the code and every answer is renegotiated. The second machine owes the first machine nothing, and the failure in front of you is usually the second machine answering a single question differently.
The signal misleads twice. First, when behavior diverges between environments, the code is the constant and the environment is the variable, but the code is the thing on your screen: visible, greppable, yours. The environment is ambient. So the debugging reflex re-reads the constant while the variable sits unexamined, and the diff gets its fifth reading before PATH gets its first. Second, local evidence does not transfer; it accumulates. Every additional clean run at home raises your confidence, and all of it is confidence about the wrong machine.
The type specimen. A test flaked only in CI. The suite was run locally under stress, fifty times, and returned fifty greens. That looked like a wall of evidence, and it measured nothing, because the flake lived in the CI runner's timing and no local machine reproduced that interleaving. Fifty greens were fifty measurements of the machine that was never in question. The first fix made things worse in the most instructive way possible: a plausible teardown patch, written against the local mental model of the race, tightened the exact timing it was meant to relax. The incident closed only when the race mechanism was named precisely, and the word fixed waited for the only green that could carry it, a run in real CI. A local green for a CI-only failure is chapter 1's false green with a sample size attached.
Book One earns the rule this chapter spends: a finding counts when it reproduces against live state. This chapter adds one clause. Live state is somewhere, and you do not get to choose where.
The discipline
Verify in the environment that matters, and when behavior diverges, suspect the environment delta before the code.
The ritual:
- Name the environment that matters. Before the first verification run, state where this work has to succeed: which OS, which runner, which shell, whose platform, signed by what. Pass: the target is named up front, and any green from somewhere else is reported as local, never as done.
- On divergence, freeze the code and diff the environments. Write the delta list before touching the source: filesystem semantics, PATH and shell, TTY and stdin, versions there versus here, checkout layout, timing, and platform state such as headers, signing, identity, and quota. Pass: a written delta list exists before the first code edit, and each entry is checked off as same or different on evidence.
- Rule out the boring suspects first. A failure too fast to be your code, a hang with zero output, an error naming a limit you never set: these point at account state, quota, stdin, and PATH, not at logic. Pass: the platform's own state is confirmed healthy before any debugging of your artifacts begins.
- Reproduce and confirm in the target. A failure that only occurs in an environment is understood when it reproduces there and fixed when that environment goes green. Local approximations can advise the hypothesis; they cannot close the incident. Pass: the closing green came from the environment that matters.
- Strip the artifact's inherited assumptions. Absolute paths where daemons spawn; stdin instead of argv for anything large; non-interactive flags and token credentials instead of prompts; self-contained configs; the repo's true on-disk casing. Pass: the artifact either carries its environment with it or asks for it explicitly, and inherits nothing the target is known to strip.
- When the target's rules block you, satisfy them where they live. A platform's convention, identity check, or header policy is part of that environment's ground truth, and passing at home is not an appeal. Pass: work blocked by a target's rule is reworked under the rule and confirmed unblocked on the target itself, not re-attempted unchanged.
The case ledger
Eighteen entries, sorted by where the delta lived: in the shell around the process, in the runner, in the platform's own rules, and in the runtime's physics.
The shell that is not yours. Four entries where the code was fine and the process environment was not: no terminal, no PATH, no one at the keyboard.
[E008] The alias that only exists at your keyboard (2026-07-02) Receipt: an interactive directory-listing alias quote-wrapped paths containing spaces, corrupting any session command that captured its output. Rule: never parse directory-listing output in session commands; use find, shell globs, or stat instead.
[E009] The daemon inherits a stripped PATH (undated) Receipt: a daemon spawned by the scheduler inherited a stripped PATH, so spawning a non-system binary by bare name failed silently, with no error surfaced. Rule: resolve spawned binaries to absolute paths in any daemon or service context, and always surface the spawn error.
[E026] The command waiting for a keyboard that is not there (undated) Receipt: an interactive command silently blocked on stdin and stalled the whole session with no output and no progress. Rule: default to non-interactive flags up front; a hang with zero output gets killed and re-run non-interactively, not waited out.
[E027] The publish prompt no one can answer (undated) Receipt: a package-publish command failed in a non-TTY session runner because it tried to prompt interactively for credentials. Rule: pass publish credentials through environment variables or a token flag so the command never needs a prompt.
The runner that is not your laptop. Six entries where CI answered a question differently: a different OS, a different checkout, a different install, a different clock, a different bank balance.
[E013] The limit that only exists on Linux (undated) Receipt: a test passing a huge string as a shell argument passed locally and on macOS CI, then failed only on Linux CI with an argument-too-large error. Rule: pipe large payloads through stdin, never argv, and treat passes-locally-fails-on-Linux as a prompt to check OS limits first.
[E018] The three-second failure was a billing cap (undated) Receipt: CI on a private repo failed in about three seconds, before setup even ran, looking exactly like a workflow bug while the local gate passed clean. Rule: an implausibly fast CI failure on a private repo is usually a minutes or billing cap, not a workflow bug; check plan usage before debugging the YAML.
[E019] The self-audit installs the version without the fix (2026-05-31) Receipt: a self-audit CI job installed the published package version, so it failed on the very PR that fixed an unreleased bug in that package. Rule: make self-audit and dogfood CI jobs tolerant of version skew, skipping with a warning on a missing artifact instead of hard-failing on an expected mismatch.
[E021] The parent directory that is not checked out (undated) Receipt: a lint config extended a relative path into a parent directory that existed locally and did not exist in CI's checkout layout, so it passed at home and failed in CI. Rule: keep lint config self-contained per repo; never rely on relative extension paths that cross repo boundaries.
[E022] The sibling checkouts that mask the break (undated) Receipt: editable path-source dependencies broke a dependency-sync command in CI even with the group deselected, because local sibling checkouts had been masking the real failure all along. Rule: validate the exact CI install command in an isolated environment with no sibling paths present; group deselection alone proves nothing.
[E091] Fifty local greens against a CI-timing race (2026-06-13) Receipt: fifty clean local stress runs gave a false green for a timing flake that only reproduced under the real CI runner's timing, and a naive teardown fix tightened the race instead of removing it. Rule: name the exact race mechanism before patching a flaky test, and claim it fixed only when actual CI goes green, never on the strength of local stress runs.
The platform that writes its own rules. Five entries where the delta was policy: enforcement the target applies and no local gate ever will.
[E042] The repo that enforces its own conventions (2026-06-07) Receipt: two externally managed repos failed a commit twice, once over a required branch-name prefix and once over a commit-body line-length limit. Rule: adopt the target repo's branch-naming and commit-body conventions before pushing, detecting them by the presence of its guard script.
[E092] The unsigned build manufactures its own failures (2026-06-27) Receipt: a mobile test sweep run with code-signing disabled produced keychain and entitlement failures that were artifacts of the unsigned environment, not bugs in the code. Rule: before reporting any unsigned-build test failure as real, re-run the suite signed with a real development identity.
[E122] The headers only the live edge applies (undated) Receipt: a static site's live security-header policy blocked an external resource that had passed every local visual gate, because local file-serving applies none of the live edge's headers. Rule: check any new external resource against the live deployment's header policy before adding it, and confirm it actually renders under the live headers after deploy.
[E123] Embeddable locally, blocked in production (2026-06-28) Receipt: a route that worked perfectly in same-origin testing was silently unembeddable cross-origin in production, because the site-wide header policy blocks cross-origin iframes by default. Rule: a route meant to be embedded cross-origin needs an explicit per-path header exception in the deploy config; confirm embeddability by reading the live deployed headers, not the markup.
[E134] The deploy blocked on who you are (2026-06-20) Receipt: a CLI deploy was blocked because the commit-author email attached to the upload could not be matched to any team member's account on the platform. Rule: when a deploy platform blocks on commit-author identity, deploy from a copy stripped of git metadata rather than trying to repair the author record.
The runtime with different physics. Three entries where the executing context answered a capability question differently: a filesystem, a dispatch assumption, and a different shell wearing your shell's prompt.
[E012] The filesystem that cannot tell two names apart (2026-05-31) Receipt: a mismatched directory casing on a case-insensitive filesystem made a bundler load two instances of the same UI framework, crashing a server-rendered page with a null-context error. Rule: build from the true on-disk casing of the path; a casing mismatch between working directory and repo is invisible until it duplicates a module graph.
[E034] The dispatch that assumes a git root (2026-05-17) Receipt: dispatching a general coding subagent from a non-git directory failed twice, because that agent type assumes a git-backed project and tries to create an isolated worktree first. Rule: from a non-git directory, dispatch the agent type that does not force worktree isolation.
[E116] The shell mode that is not your shell (undated) Receipt: a context-processing tool's shell-execution mode ran under a different shell than expected, so familiar loop syntax silently failed or returned empty results with no visible error. Rule: route harness inspection through native read tools or plain read-only commands, and assume a sandboxed shell mode does not share your usual shell's syntax.
Adjacent doors
If there is no second environment, if the signal and the state disagreed on the very machine that produced both, then nothing diverged; you were lied to at home. That is chapter 1, and the distrust of the green it installs is the one this chapter assumed you arrived with.
If two runs on the same machine disagree, and something in the tree changed between them that you did not change, the delta is not an environment. It is another writer, live in your working directory right now, and that is chapter 5, whose first move is one no environment ever earns from you: yield.
If what blocked you is a gate rather than a fault, check whose it is. A control you installed yourself, your own hook, your own deny rule, is chapter 8, and arguing with it is that chapter's whole subject. A gate belonging to someone else's platform is this chapter's sixth check wearing a uniform: not a malfunction, and not an appeal you can win from your desk. Their machine, their rules; satisfy the rule where it lives.