Build1 distinct publisher3 min readUpdated
A four-core box nearly went down at a load average of 38.7. The ordering of the three load figures, plus two lines from /proc/pressure, dated the incident twenty hours before anyone opened a log.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
A four-core Linux box came close to falling over under a load average of 38.7, and by the time that number was read the worst of it was already over [1][2]. The ordering of the three load figures and two counters from /proc/pressure established that before any application log was opened, which is the transferable part of the story [3][4]. The reading was 11.08, 38.69, 23.59: one minute, five minutes, fifteen minutes [2]. A crisis still climbing puts its largest figure in the one-minute slot; this set was descending from a peak that sat in the five-minute window, so the event had already happened and was decaying while the operator was still reading it [3]. Then /proc/pressure, the kernel's stall accounting for CPU, memory and IO: memory full at 10 percent, meaning processes genuinely stopped waiting on page reclaim, and IO some at 45 percent [4]. According to the author's writeup, that pairing is memory pressure that has turned into an IO storm [5]. The link back to 38.7 is D state. Processes parked in uninterruptible IO waits count into the load average exactly as if they were running, and a runc process and a node healthcheck were caught in that state [6]. On four cores, 38.69 works out to 9.7 tasks per core [1], but the composition was modest real work plus a crowd of processes waiting in the kernel rather than thirty-eight cores' worth of computation [7]. Elimination was quick. No OOM kills in the kernel log [8]; docker stats showed every container under 500 MB with single-digit CPU [9]; disk at 65 percent [10]. A process list sorted by memory and grouped gave llama.cpp at 3.9 GB, seven Java services at 2.3 GB and k3s at 1.1 GB, all steady state [11]. That is 7.3 GB combined, the same figure that 59 vscode-server processes were holding on their own [12][2]. Fifty-nine is a count, not a structure, and the decisive hour went into the process tree, PPID by PPID [13]. Remote-SSH runs one server per client version, parented to init rather than to an SSH session, so no session teardown kills it, and that server hosts every window the client opens with one extension host per window [14]. A server started on August 9th was hosting two: the live window, and an old window from August 14th whose extension host had grown to seventeen processes and 3.2 GB, containing the Claude session that hung the night before plus four more claude processes born of retries between 2:04 and 2:11 a.m., with the old ones never exiting [15]. A second server tree of thirteen processes, another device's window from 8:26 that morning, completed the census [16]. Because the live window shared the August 9th server, the kill list could only be the old window's extension-host tree and the other device's entire tree [17], roughly thirty of the fifty-nine processes [3]. Accumulation ran from 15:17 on the 14th, when the old window connected and the stalled session began its hour-long hang, to 8:26 the next morning [18]. There was no swap, memory crept past 85 percent, and alerts set at 80 and 90 percent are spike detectors that arrive with hours of momentum behind them on growth that gradual [19]. Six versions of the server binary had also piled up in ~/.vscode-server, one per client upgrade, at 3.8 GB [20]. Ignition was 10:59 to 11:09: a new connection and a reconnect brought up two fresh extension hosts and their language servers, CPU- and IO-heavy, on a box whose page cache was already being squeezed [21]. The five-minute peak of 38.7 covers exactly those eleven minutes [22]. From the 15:17 connection to 11:09 is 19 hours and 52 minutes [4]. The author frames the postmortem around four layers that each had a job and each failed for a specific reason [23].
Follow any of these and your For You feed starts watching them — no settings page required.
Ranked by verification strength, evidence, and original report placement.
On the morning after August 14th, a four-core box nearly went down under a load average of 38.7, and the cause turned out to be the same incident twenty hours downstream; a Claude Code session had hung for an hour inside the VS Code extension the night of August 14th, traced to a per-token streaming stall.
The load figures read 11.08, 38.69, 23.59 for one-minute, five-minute and fifteen-minute averages.
A crisis still climbing shows the opposite ordering, with the disaster appearing in the one-minute figure first; these figures were falling, so the peak had already passed while the author was still reading them.
/proc/pressure (PSI) is the kernel's stall accounting for CPU, memory and IO; it showed memory full at 10 percent, meaning processes genuinely stopped waiting on page reclaim, and IO some at 45 percent.
The author's reading of those PSI figures: memory pressure had turned into an IO storm.
Processes parked in uninterruptible IO waits (D state) count into the load average exactly as if they were running; a runc process and a node healthcheck were caught in that state.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Detailed first-hand telemetry, no independent corroboration
The account is unusually specific and internally consistent: three load figures, two PSI lines, named D-state processes, container and disk stats, a grouped memory listing, process counts per tree, and timestamps that line up (15:17 accumulation start, 2:04-2:11 retries, 8:26 second window, 10:59-11:09 ignition matching the five-minute peak). But every figure is self-reported by one author, no artefacts (kernel log, ps output, PSI captures, scripts) are published, and the cluster's two items are the same post duplicated rather than two independent observations.
One self-reported host
Adoption evidence is confined to a single operator's own machine: a middleware fix deployed the previous night, a scoped process-tree cleanup executed during the incident, and disclosure of that one box's workload mix. There is no fleet, organisational, or third-party usage signal, and no indication that others have applied the diagnostic or remediation pattern.
Claims stay inside the evidence
The framing is proportionate to what is shown. The author says the box 'nearly went down' rather than that it failed, attributes load inflation to blocked processes instead of computation, names his own retry behaviour as part of the cause, and confines conclusions to four failure layers on his own machine. No product, benchmark, or generalisation claims are made that the narrative does not support, and no capability or performance superiority is asserted.
Self-published series with cross-promotion
This is an author's own post on a developer publishing platform, part of an explicitly referenced series (the piece points to two earlier instalments on the streaming stall and the middleware that fixed it), and the same article appears twice under different URLs — mild self-promotional and reach-seeking incentives. No vendor sponsorship, commercial product pitch, funding interest, or disclosed relationship with the tools discussed appears in the supplied sources.
Plausible and coherent, single-source
Mechanisms invoked — D-state accounting in load average, PSI stall metrics, page-cache reclaim under swapless memory pressure, detached Remote-SSH servers hosting multiple windows — are standard and mutually consistent, and the timeline hangs together. Confidence is capped in the middle because there is exactly one author, one host, duplicated publication instead of corroboration, no raw artefacts, and no follow-up verification that the remediation resolved the condition.
build
Thirteen tasks green, then "give up (Recommended)" on the one that needed understanding1 distinct publisher
build
A 27B Apache-2.0 model in 17GB makes local inference a wiring decision, not a demo1 distinct publisher
build
One alert, two causes, four green dashboards: the day the stack agreed and was wrong1 distinct publisher
build
AI-written code fails the same four ways, and every gate you own reports green1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
2 articles · August 15, 2026