Wiki Log, May 2026

[2026-05-31] ingest | specification.website — modern web spec checklist

Single-page nine-category catalog: Foundations, SEO, Accessibility, Security, Well-Known URIs, Agent Readiness, Performance, Resilience, Internationalisation. Each item tagged Required/Recommended/Optional/Avoid. The interesting move is putting Agent Readiness next to SEO and a11y as a peer category — same vocabulary applied to llms.txt, llms-full.txt, markdown source at .md URLs, Content-Signal in robots.txt, Web Bot Auth (RFC 9421), MCP tool discovery, A2A agent cards, NLWeb, WebMCP, DNS-AID, and the site's own Schemamap proposal. Pages created: specification-website-checklist (summary), specification-website (entity), agent-readiness (concept — umbrella for the section). Pages updated: llms-txt (cross-link to the broader agent-readiness stack), index (3 entries), ingested-urls (1 row). Open extraction candidates noted on the concept page: Web Bot Auth, Content-Signal, A2A agent cards, NLWeb, WebMCP, DNS-AID, Schemamap.

[2026-05-22] ingest | AgentMail / agent.email — hosted email inboxes for AI agents

Service-side ingest (no source page; built from agent.email/skill.md + docs.agentmail.to/llms.txt). Closed-source SaaS exposing an API-first inbox per agent with threads/drafts/attachments, WebSocket+webhook event streams, custom domains (SPF/DKIM/DMARC), pods for multi-tenant isolation, and a "claim-the-agent" onboarding flow that restricts unclaimed agents to one recipient + 10/day. First-party integrations: MCP, CLI, OpenClaw/Claude/Cursor skills, Google ADK, Replit, LiveKit, Sim.ai. Agent-native payment hooks: x402 (HTTP 402 crypto) + MPP (Stripe M2M). Pages created: agentmail (toolbox), inverted-claim-onboarding (concept), agent-email-skill (source). Updated: index, index (Concepts), ingested-urls (3 rows). Cross-references into llms-txt, human-in-the-loop, sandboxing-ai-agents, stateful-agent-routing, adk-go, ephemeral-credentials, long-lived-keys, oauth-token-theft.

[2026-05-22] ingest | Andrea Laforgia — Stop Using Pull Requests (a4al6a.substack.com)

Long-form essay synthesizing 20 years of software engineering research and DORA-scale industry data into a single argument against blocking-async PRs as the default workflow inside trusted teams. Key load-bearing claims: PRs were designed as a gatekeeper for untrusted open-source contributions (category error to apply internally); <15% of code review comments relate to bugs per Bacchelli & Bird 2013 (the bug-catching justification is mostly wrong); 86-99% of a change's lead time is spent waiting for review, with Fowler's client cited for the headline number — 130,000 hours in 2020 on 7,000 PRs that received zero comments; DORA 2023 found accelerating review alone delivers 50% software-delivery improvement. The alternative is the T*D triple: Test-Driven Development (40-90% defect reduction), Trunk-Based Development (daily integration, branches under a day), Team-focused Development (pair/ensemble programming). The Muller & Tichy 2005 result is the empirical hinge — pair programming and solo+review have equivalent cost at equal quality, so pairing relocates QA rather than adding cost. Laforgia is honest about the gaps: DORA is correlational, no peer-reviewed study has directly shown safe elimination of post-hoc review when pairing, and trust is a gradient (cross-team, distributed-no-overlap, inner-source contexts may still warrant lightweight gated review). Five-stage transition path: optimize PRs → Ship/Show/Ask → pair+TBD → ensemble+TBD → full T*D. Pages created: stop-using-pull-requests (summary), andrea-laforgia-blog (entity), trunk-based-development (concept — DORA evidence, Hammant's constraints, Minimum CD's "non-negotiable" framing), ship-show-ask (concept — Wilsenach's three-way classification as the transitional stage 2), code-review-knowledge-transfer (concept — the <15% finding and why it inverts the PR justification), pair-programming (concept — Williams/Hannay/Arisholm/Muller&Tichy meta-research and the honest gap between cost-equivalence and replacement). Pages updated: i-dont-want-your-prs (cross-link added — Laforgia attacks PRs from the classical-SWE-research angle, Ciężarkiewicz from the post-LLM-OSS angle; same target, different premises). Cross-refs to agent-principal-agent-problem (the Crawshaw piece adds "agents collapse the effort signal" on top of Laforgia's "the signal was already weak"), stacked-prs / billjings-git-not-fine, no-silver-bullet-llms, programming-as-theory-building (Naur's frame is the theoretical grounding for why pair programming works).

[2026-05-22] ingest | Kevin Renskers — uv is fantastic, but its package management UX is a mess (loopwerk.io)

Loopwerk article on the gap between uv's speed (uncontested) and its day-to-day project-maintenance UX (behind Poetry and pnpm). Four specific complaints: no dedicated uv outdated (closest is uv tree --outdated --depth 1 which dumps the whole tree); uv add writes open-ended >=X with no upper bound (vs pnpm/Cargo/Poetry caret-style); upgrade lives under uv lock --upgrade not the obvious uv update; per-package upgrade requires flag repetition (--upgrade-package X --upgrade-package Y …). The --bounds major preview flag offers partial relief but is opt-in and doesn't fix existing manifests. The user-also-gave URL github.com/boratanrikulu/gobee was already ingested in the earlier 2026-05-22 batch (entry above) — confirmed no new work needed on the gobee side; the existing gobee page covers it. Pages created: loopwerk-uv-ux-mess (summary), loopwerk-blog (entity), default-version-bound-constraints (concept — comparison table across npm/Cargo/Poetry/Bundler/uv/pip-tools, who absorbs the cost when SemVer is wrong). Cross-refs to open-source-security-astral (the contrast: rigorous supply-chain practices for Astral's own releases vs. loose default for downstream-user dependency constraints), if-ai-writes-your-code-why-use-python (uv saving Codex ~1M minutes/week — context for why uv's defaults will compound fast), supply-chain-security.

[2026-05-22] ingest | Four-source batch — Bora's gobee transpiler, Elena Verna's adapt-or-die letter, Freenet (Locutus), Rivet's Docker Sandbox reverse-engineering

Four URLs ingested in one parallel batch. The user-provided URL github.com/boratanrikulu/gobeeq was a 404 typo; the intended repo is boratanrikulu/gobee (Bora's Go-to-BPF-C transpiler — we already track his bora.sh blog and gecit). README pulled via gh api; the three articles went through defuddle cleanly.

(1) github.com/boratanrikulu/gobee — Bora Tanrıkulu's Go-to-BPF-C transpiler. Writes a strict subset of Go that gobee emits to BPF C, then runs clang; generates typed Go bindings (no more stringly-typed coll.Programs["..."] lookups), maps verifier errors back to Go file:line:col via a sourcemap sidecar, and gates loads against the running kernel via bpfvet so old kernels fail fast with bpf program needs kernel >= 5.8, host is 5.4 instead of opaque EINVAL. Structural decision worth keeping: Aya gets to Rust-eBPF by adding a BPF backend to rustc (feasible because rustc is built on LLVM); gc isn't on LLVM so gobee skips the multi-year compiler project and reuses clang's mature BPF backend. 8 program types, 19 map types, ~200 typed helper stubs from libbpf v1.5.0, CO-RE auto-detected, Linux arm64+amd64. Pages created: gobee. Updated bora-blog with gobee + bpfvet alongside gecit (Bora's published toolset is converging on "writing eBPF programs in Go without writing C").

(2) elenaverna.com/p/youll-lose-your-job-in-2027 — Elena Verna's adapt-or-die letter to tech workers. Three steps: honestly assess if you like your job; build career optionality (skill-as-product consulting or "Mom 'n' Pop SaaS" — Verna makes more from solopreneurship than from full-time cash comp); become AI-native. The six-tier ladder (writing buddy → meeting partner → thinking partner → builder → shipping to prod → agents) is the piece's main reusable artifact, extracted as ai-native-tiers. Tier 6 (agents) gets her own caveat — "often require more setup, oversight, and cost than just doing the thing yourself" — which echoes agentic-coding-fatigue / agentic-coding-is-a-trap from inside engineering. The piece structurally counters the anti-llm-discourse cluster (engineering-side LLM skeptics) from the workplace-strategy side; updated that page with an "adapt-or-die counter-cluster" section. Pages created: elena-verna-job-2027 (summary), elena-verna-blog (entity), ai-native-tiers (concept). Cross-refs to dont-outsource-learning (the "write first, critique with AI" posture converges from opposite ideological starts), ai-sycophancy-loop, cognitive-debt, skill-atrophy-supervision-paradox, simonw-vibe-coding-agentic.

(3) freenet.org — The new Freenet, formerly codenamed "Locutus." Critical disambiguation: this is not the original 2000-era anonymous filestore (Java, censorship-resistant publishing) — that project was renamed Hyphanet in 2023 when the Freenet name moved to the Rust rewrite. The current Freenet is a peer-to-peer platform for decentralized applications (Rust/TS, browser-served, small-world ring routing by location, scales to millions of peers in a few hops). Architecturally distinct from yggdrasil-network (IP overlay), Tor (anonymity transport), and IPFS (content storage) — it's a generic dApp substrate closer to Holochain. Pages created: freenet + watchlist row (re-check 2026-08-22 for non-demo dApp with users, contributor count, funding past grants).

(4) rivet.dev/blog/2026-02-04-we-reverse-engineered-docker-sandbox-undocumented-microvm-api — Rivet reverse-engineered Docker's undocumented sandboxd.sock HTTP API behind Docker Sandboxes. Three endpoints (GET/POST/DELETE /vm); each microVM gets its own docker.sock (the inverse of the usual shared-socket model); outbound traffic forced through a MITM proxy at host.docker.internal:3128 with a per-VM CA at ca_cert_path (so sandboxing-ai-agents Layer 3 is baked into the substrate). The CLI is restricted to Docker's six whitelisted agents (Claude, Codex, Gemini, Copilot, Kiro, Cagent) — escaping that whitelist is the unlock the SDK provides. macOS/Windows only (Apple Virtualization.framework / Hyper-V, not KVM). Docker Desktop 4.58+. The structural inverse of abi-stability (Win32 as durable ABI on Linux) — interesting counterpoint for what happens when upstream isn't committed to an API contract. Updated microvm-2026 (which previously named Docker Sandboxes at the platform level without API details). Pages created: rivet-docker-sandbox-microvm (summary), rivet-blog (entity), sandbox-agent-sdk (the SDK Rivet built on the API) + watchlist row (re-check 2026-08-22 for upstream stability and adoption). Cross-refs to microvm, matryoshka-isolation, sandboxing-ai-agents, crabtrap (same Layer-3 idea elsewhere), superhq, hazmat, bubblewrap-dev-env.

Pages created total: 2 summaries + 3 toolbox + 2 entities + 1 concept = 8 new pages. Pages updated: index (2 summaries, 2 entities, 1 concept added), index (3 entries added), watchlist (2 rows added), microvm-2026 (Docker Sandbox API details), bora-blog (gobee + bpfvet under author), anti-llm-discourse (adapt-or-die counter-cluster section), ingested-urls (4 rows). Sources saved for all 4 (defuddle for 3, gh api for the GitHub repo).

[2026-05-21] ingest | Graham Helton — SSH Port Forwarding Cheatsheet

Helton's reference page on SSH tradecraft (grahamhelton.com/blog/ssh-cheatsheet). Walks through the four forwarding shapes (-L local, -R remote, -D dynamic SOCKS, -J jumphost), agent forwarding (-A) with explicit security caveats, the -g/-t modifiers, the ~?/~C runtime console (kill session, add forwards mid-session), ~/.ssh/config including the Match keyword that conditions blocks on shell-exec tests, and the ssh-copy-id / ssh-keygen one-liners. Three-host scenario (campfire.int → vuln-server.int → internal-web.int → dns.int) recurs throughout — explicitly red-team framing but the techniques are vendor-neutral OpenSSH. Sits next to living-off-the-land as the canonical Unix-tool pivot reference. Pages created: ssh-port-forwarding-cheatsheet (summary), graham-helton-blog (entity), ssh-port-forwarding (concept), ssh-agent-forwarding-risk (concept). Cross-refs to living-off-the-land, ephemeral-credentials, long-lived-keys, credential-compartmentalization, bypassing-dpi-with-ebpf.

[2026-05-21] ingest | Fifteen-source batch — Codex workflows, sudoku math, password managers, RSSHub, US-AI-race politics, multi-session Claude coordination, httpx fork story, agent routing primitive, git critique, manual-memory primer, Prolog declarative states, Dhall, Lightroom-on-Wine via Claude, AI water debunking, XS language

Fifteen URLs ingested in one parallel batch. Defuddle worked for all 13 web sources; the two GitHub repos used gh api for README extraction. The 1Password agentic-refactoring URL the user pasted was already done (2026-05-16) and skipped.

(1) jxnl.co/writing/2026/05/10/codex-maxxing — Jason Liu's operating loop for Codex/AI agents. Pinned megathreads with compaction (cache tradeoff explicit), voice input for unedited thinking, steering (mid-task message injection), file-based memory as AGENTS.md-driven Obsidian vault with git-backed diffs as a review surface for what the agent thought worth remembering, Heartbeats as self-scheduled checks (Chief of Staff every 30 min, refund-monitoring escalating from 5→1 min, animation feedback loop spanning Slack+Remotion+@computer), Goals with real verification oracles (Rich Python→Rust must pass the original test suite), the side panel where artifacts are inspected/operated/reviewed. Distinction between $browser/@chrome/@computer. Closing thesis: "more of my work can keep moving after I leave." Cross-refs to building-syntaqlite-ai, agent-principal-agent-problem, matryoshka-isolation, bubblewrap-dev-env. Pages created: jxnl-codex-maxxing (summary), jxnl-blog (entity).

(2) chalkdustmagazine.com/features/unlocking-sudokus-secrets — graph theory + Gröbner bases for sudoku. Vertex coloring with greedy+backtracking (worked example, the (1,7)→8→backtrack→9 step). Gröbner bases: polynomial ring on 81 cells, value polynomials $(x_i-1)\cdots(x_i-9)$, row/col/region sums of 45 and products of 362,880, Buchberger's algorithm to triangularize. Worked shidoku (4×4) example uses 40 equations + the 5 pre-filled cells, returns 16 linear polynomials reading off the unique solution. Bruno Buchberger 1965 PhD thesis attribution. Pages created: chalkdust-sudoku-secrets (summary). Cross-ref to neurosymbolic-ai.

(3) projects.omarpolo.com/plass.html — Omar Polo's pass-compatible password manager. gpg-encrypted files under ~/.password-store, versioned with got(1) (the BSD VCS) instead of git, three companion tools (plass/pwg/totp). Explicit "smaller and cleaner" stance vs upstream pass. Pages created: plass.

(4) docs.rsshub.app — RSSHub overview. Community RSS gateway, 1,300+ contributors, AGPL-3.0, paired with Folo as the AI RSS reader. Pages created: rsshub. Cross-refs to coywolf-byline-rss, byline-spec.

(5) avkcode.github.io/blog/us-winning-ai-race.html — the US lead is commercialization, not papers. Decisive layer is cloud + data + dev ecosystems + power, not any one of them alone. Electricity price table across 8 countries (US 0.20/0.15 USD/kWh home/business; China 0.08/0.12, Canada 0.13/0.11). Europe ~$58.8B+$67.1B spent on Indian software services FY23–25, the catch-up math, Nebius as the lone exception. Weaponized-AI postscript: bot networks, dehumanization-tuning, autonomous weapons; Anthropic's Mythos as the closed-firmware-and-chips harbinger. Pages created: avk-us-ai-race (summary), avkcode-blog (entity). Sits next to subprime-ai-crisis, ai-too-expensive as the build-is-real complement to the bill-comes-due framing.

(6) github.com/AnastasiyaW/mclaude — Multi-session Claude Code coordination. Seven file-based layers: atomic locks (O_CREAT | O_EXCL with 30s heartbeat / 3-min stale), attributed handoffs (markdown per session), memory graph, mail (questions/answers between sessions), hub server, bridge, voice. The Mermaid-sequence-diagram demo (mclaude demo --no-pause) walks two simulated sessions through six layers in 30 seconds. Pairs with claude-code-config (rulebook of 23 architectural principles + 14 safety hooks). MIT, 166 tests, Python, zero core deps. Pages created: mclaude. Cross-refs to jxnl-codex-maxxing, agent-principal-agent-problem, matryoshka-isolation.

(7) tildeweb.nl/~michiel/httpx2.html — Michiel Beijen on yielding httpxyz to Pydantic's httpx2. Codeberg-vs-GitHub friction noted gently — daily stars rising on Codeberg, but Pydantic's reach made joint-fork worth backing. httpx2 already shipped three calls Beijen was unsure about (certifi → truststore, compression.zstd default on 3.14+, httpcore merge). The clean cooperative-fork dynamic — contrast to fsnotify-maintainer-dispute. Pages created: httpx2-blessed-fork (summary).

(8) zknill.io/posts/llms-are-breaking-20-year-old-system-design — Zach Knill on stateful agents breaking cloud-native. Three violations: long-running work, stateful compute, bi-directional interaction. Durable execution (Temporal/Inngest/Restate) handles execution but not the routing problem. Polling treats the database as a message bus. Missing primitive: a routable transport name that isn't a server. WebSockets are connections not addresses. Pub/sub channels invert the ownership — the transport is addressable. Workflow connects to a channel named after the workflow ID; client connects to the same name. Durable execution + pub/sub + stateless HTTP, three pieces each doing one job. Pages created: zknill-llms-breaking-cloud-native (summary), stateful-agent-routing (concept), zknill-blog (entity). Cross-refs to agents-vs-daemons, agent-principal-agent-problem.

(9) billjings.com/posts/title/git-is-not-fine — Bill Jings's case that git is fine for storage but bad for workflow. No notion of successor commits, no rebase history, no garbage knowledge. Branches don't fix it — no 1:1 with PRs, no relationships between branches. Stacked PRs are fragile (Graphite-style external metadata stores drift). Mutability hands-off — staging/unstaged/stash/HEAD exists twice, async flows where changesets change over time can't be represented. The clinching example: feature branch wanting bugfix code in the editing workspace while keeping the PRs parallel — git can't say this. Closes on "git is behind the state of the art for an embarrassingly long time now" and the LLM-amplifies-async-work counter to "I don't touch git, Claude does." Pages created: billjings-git-not-fine (summary), jujutsu (concept), stacked-prs (concept), billjings-blog (entity).

(10) dayvster.com/blog/manual-memory-management — Dayvi Schuster's tour of manual memory. Seven pitfalls with the book-lending analogy (dangling pointer, double free, UAF, leaks, buffer overflow, fragmentation, ownership). Stack/heap mental model. Tools (debuggers, sanitizers, profilers, static analysis, code review). Best practices including scope-based cleanup (C++ RAII, Zig defer). Language pass: C (Valgrind+ASan), Fil-C (the no-rewrite LLVM safety retrofit), C++ (containers over raw allocation), Zig (allocators-as-values + defer, the author's favorite), Odin (context.allocator + arena strategies), C3 (scope-based with stdlib helpers). Rust gets the contrarian treatment — "not actually a manual memory language, just compiler rules," Cloudflare outage as evidence. When to reach for manual: performance-critical code (games, trading, real-time audio, HFT), embedded. Pages created: dayvster-manual-memory-management (summary), dayvster-blog (entity). Cross-refs to simplified-model-of-fil-c, zig-functional-programmers, comptime, c3-lang, safe-gc, stroustrup-memory-leaks.

(11) metalevel.at/tist — Markus Triska's Thinking in States essay. The declarative move: replace destructive mutation with relations between states. I #= I0 + 1 instead of i = i + 1 — two variables, usable in all directions. list1_element_list2/3 as a relation instead of remove/3 as a function. Water-jug puzzle with both Haskell and Prolog state representations, the Prolog version shorter because moves are described uniformly. Building a Prolog interpreter for a small imperative language — state as a pair of association lists, interpret/3 as a relation between input and output environments. Compiling to a stack-based VM — DCG semicontext notation (state(S) and state(S0, S)) implicitly threads compilation state. Pages created: metalevel-thinking-in-states (summary), metalevel-at (entity). Cross-refs to no-silver-bullet-llms, message-passing-shared-mutable-state.

(12) dhall-lang.org — Dhall as JSON + functions + types + imports. Total programming language, no side effects, semantic hashes invariant under behavior-preserving refactors. Safety stance: "we treat the inability to safely evaluate untrusted Dhall code as a specification bug." Pages created: dhall. Cross-ref to whitelist-capability-config (Rye's opposite design choice — start from nothing, register per word).

(13) github.com/sander110419/lightroom-cc-on-linux — Lightroom CC on Wine 11.8, recipe + autonomous-agent build process. Six non-obvious fixes (DXVK dummy swapchain, AdobeGrowthSDK disable, patched d2d1.dll with CLSID_D2D1ColorManagement, patched mfplat.dll with MFCreateSampleCopierMFT forwarder in two locations, three stub DLLs, lowercase symlinks). The agent loop: read crash dumps with winedump/objdump/PE-Python; diff mfplat export tables to find the missing function; patch the binary with a new PE section; verify via ImageMagick screenshots + Pillow UI detection + xdotool mouse driving + crash-dump watching; discover the Adobe-bundled-DLL preempt via failed verification; copy patched DLL into Adobe's install dir; document the gotcha for future sessions. history_methodology.md ~1750 lines, two parts (Part I reconstructed from artifacts of earlier agents now gone, Part II real-time account). 138 stars. Pages created: lightroom-cc-on-linux. Cross-refs to 1password-agentic-refactoring (deterministic-tools framing), building-syntaqlite-ai (vibe-vs-disciplined).

(14) blog.andymasley.com/p/the-ai-water-issue-is-fake — Andy Masley's long debunking. Definitions: consumptive/non-consumptive, direct/indirect, potable/freshwater. 80% of "AI water" is at the power plant, not the data center, almost all non-consumptive. National scale: all US data centers = 0.2% of national freshwater consumption; AI = 0.04% with offsite, 0.008% onsite only; 10.6M gal/day total ≈ 8× his hometown's water utility. 2030 projection (3× data-center power, 10× AI within that): 0.08% of national freshwater = 5% of US golf-course water, 5% of US steel production, 173 sq mi of irrigated corn. Local: one county (Newton GA) has documented data centers contributing to rising water costs, alongside a pharmaceutical plant and Rivian. NYT "dry taps" Georgia story was construction sediment, not operational water use. Maricopa data centers 0.12% vs golf courses 3.8%, data centers generate 50× more tax revenue per gallon. Personal: 422 gal/day footprint = 800K prompts/day equivalent; a smartphone = 6.4M prompts of water to make; PS5 hour = 200 prompts of indirect electricity-water. Potable-specific: ~$1/1000gal treatment cost, water-utility economies of scale mean a new buyer in freshwater-abundant areas funds the infrastructure for everyone. Coverage critique: Washington Post bottle-of-water required six worst-case assumptions; Economic Times "Texans showering less" was 463M/2yrs = 1,600 added residents-equivalent. The pollution discussion: only two reported stories, both with other root causes (construction sediment, agricultural nitrates). Water cooling is more energy-efficient than air, 10% less CO₂. Pages created: andymasley-ai-water-fake (summary), andymasley-blog (entity). Sits as counterweight to hold-on-to-your-hardware, adjacent to anti-llm-discourse.

(15) xslang.org — XS programming language. Single 2.9 MB statically-linked binary containing compiler + LSP + debugger + formatter + linter + REPL + transpilers; six backends (interpreter, VM, JIT, C transpile, JS transpile, WASM runtime build). fib(30) at 31 ms JIT, 138 ms VM, 62 ms node, 71 ms cpython. Targets: Linux/macOS/Windows/WASI/iOS/Android/ESP32/Pi. 132 KLOC C source. Pages created: xslang (+ watchlist row, re-check 2026-08-21 for external adoption, license clarity, target claim verification).

Pages created total: 9 summaries + 6 toolbox + 7 entities + 3 concepts = 25 new pages. Pages updated: wiki/index.md (10 summaries, 7 entities, 3 concepts added), toolbox/index.md (6 entries added), toolbox/watchlist.md (1 row added), sources/ingested-urls.md (15 rows). Sources saved to sources/ for all 15 (defuddle parse for 13, gh-api README for 2). The 1Password URL the user pasted was already in the wiki from 2026-05-16 and not re-ingested.

[2026-05-20] ingest | Four-source batch — Rovelli on consciousness, Osmani on outsourced learning, Axios on AI polling, Zitron on AI being too expensive

Four URLs ingested in parallel. Defuddle worked for three; Axios was blocked by Cloudflare and reconstructed via WebFetch extraction (saved to sources/ as a note rather than a clean dump).

(1) noemamag.com/there-is-no-hard-problem-of-consciousness — Carlo Rovelli (May 7 2026) argues Chalmers' 1994 "hard problem" smuggles dualism in upfront. The "explanatory gap" presumes we know what we'd understand if we understood what we don't. Philosophical zombies are self-defeating: a being physically identical to me undergoes the same introspective process that convinces me of consciousness — so it claims consciousness for the same physical reasons. Mental processes are physical processes by subtraction, not addition. Connects naturally to claude-emotion-concepts: Anthropic's 171 emotion vectors are exactly the kind of "explain the brain in physical terms" project Rovelli treats as the only real one. Pages created: no-hard-problem-consciousness (summary), hard-problem-of-consciousness (concept — Chalmers' framing, the cluster of supporting moves, Rovelli's dissolution, what remains untouched), philosophical-zombies (concept — thought experiment + self-defeat argument). Updated claude-emotion-concepts with cross-references to the new concept and summary, bumped updated.

(2) addyosmani.com/blog/dont-outsource-learning — Addy Osmani (May 2026) on the default AI coding loop. Three converging studies: Anthropic's randomised library-learning trial (50% comprehension vs 67% manual; 65%+ for "ask conceptual questions" vs <40% for "copy-paste"); MIT's "Your Brain on ChatGPT" EEG study (weakest brain coupling under LLM, 83% can't quote their own essay); CHI 2026 (LLM at task start anchors the whole problem badly). Prescription is posture-based: form a hypothesis first, ask for explanation before code, treat output as a junior's PR, re-derive by hand, ask the model to teach you what it just did. Two metrics — ship and learn. Pages created: dont-outsource-learning (summary), cognitive-debt (concept — the MIT framing, three studies, why the debt is invisible/path-dependent/compounding, countermeasures), addy-osmani-blog (entity — Google Chrome eng manager, ingested-articles list). Updated skill-atrophy-supervision-paradox (added cognitive-debt + Osmani cross-references — the mechanism vs role-level companion piece), agentic-coding-fatigue (added depletion-vs-erosion framing with cognitive-debt).

(3) axios.com/2026/05/17/ai-backlash-polling-sentiment — Madison Mills (May 17 2026) on the polling collapse. Gallup: only 18% of 14-29 hopeful about AI. >70% of Americans say AI moves too fast; bipartisan: 68% R, 77% D. Negative views 34% → 50%+ over three years. Four concerns: jobs, electricity costs, wealth concentration, environment. UCF commencement speaker booed for "next Industrial Revolution." One CEO: "We don't really see that." Data center cancellations hit record in Q1 2026. Pages created: ai-backlash-polling-2026 (summary). Cross-referenced from hold-on-to-your-hardware, subprime-ai-crisis, ai-bubble-pale-horses. Source saved as reconstruction — Cloudflare challenge blocked direct fetch and r.jina.ai is not in trusted environment.

(4) wheresyoured.at/ai-is-too-expensive — Edward Zitron (May 2026) follow-up to subprime-ai-crisis. Microsoft's $87B (30% of $293.8B FY23-FY26 capex) sunk into OpenAI infrastructure per Wetter's Musk-OpenAI trial testimony. Hyperscaler 2026 capex ~$700B against $1.6T four-company combined revenue — needs $3-6T AI revenue to break even. RPO jumps: Microsoft $392B → $625B (driven by OpenAI's $250B Oct 2025 lockup + $30B Anthropic), Amazon $244B → $364B (OpenAI + Anthropic), Google $242.8B → $467.6B (Anthropic $200B TPU commitment alone). Anthropic's March affidavit: $10B spent on compute against ~$5B lifetime revenue ($3 spent per $1 earned). Knife-catching dynamic: Anthropic gross margins fell to 40% (10 below projection), OpenAI 40% → 33%, both from last-minute compute purchases. Enterprise token-budget explosion: ServiceNow CIO unsure of sustaining Claude through 2026, Salesforce $300M committed, Stripe ~5000 engineers burning $94K/day, Goldman reports AI costs approaching 10% of headcount. Zillow case study ("AI Chernobyl"): $1M Q1 + on pace for $7-10M annual against $23M FY25 net income, "AI-Native Engineering" deck with "2027: A Tuesday" hypothetical, human review work up 50%, Blind anonymous posts ("the slop is job security"). Anthropic doesn't offer telemetry or SLAs — Bratton's Information reporting. Closes with the Business Idiot structural argument: LLMs produce an impression of work, which matches what executives are paid to produce; the technology is grift-shaped because the buying class is grift-receptive. Pages created: ai-too-expensive (summary), business-idiot (concept — the structural account), knife-catching-compute (concept — the supply-side bind with the full Amodei quote), ai-token-budget-explosion (concept — enterprise-side dynamic). Updated edward-zitron (added the new piece + updated description), subprime-ai-crisis (added Follow-up section), ai-bubble-pale-horses (added May 2026 update section with confirmed signals), ceo-ai-psychosis (added Business Idiot cross-reference — HandyAI focuses on grandiosity, Zitron on receptivity).

Pages created total: 4 summaries + 7 concepts/entities = 11 new pages. Pages updated: 8. Source files saved to sources/ for 3 of 4. Ingested-urls and index updated. Defuddle worked for noema, addyosmani, and wheresyoured.at; Axios blocked by Cloudflare and reconstructed.

[2026-05-19] ingest | skiplist — concurrent lock-free C skip-list (codeberg.org/gregburd/skiplist)

Ingested gregburd/skiplist — a header-only C library implementing a lock-free skip-list with optional splay rebalancing. Core algorithm is Fraser/Harris (marked pointers for logical delete, CAS-chain insertion bottom-up, two-phase deletion) with epoch-based reclamation for safe concurrent freeing. Splay rebalancing (opt-in via SKIPLIST_SPLAY_REBALANCE) is based on Aksenov et al. 2020: a node with hit ratio u/T settles at height K − 1 − log₂(T/u), converting search cost from O(log n) to O(log(1/p)) for hot keys, only fires on read-only paths to avoid the dangling-upper-level problem on deletion. The level-0 doubly-linked list gives O(1) reverse iteration that plain skip lists need O(log n) for. Implementation strategy is preprocessor-macro codegen in a single include/sl.h — independent macro generators for core / access / snapshots (MVCC) / EBR / pool allocator / archive / validate / dot, picked à la carte. Compile-time SKIPLIST_SINGLE_THREADED drops <stdatomic.h> entirely and runs ~30% faster on tight loops; pool allocator stacks on top for 2-3× sequential insert. Indicative numbers (x86_64, gcc 13 -O2, N=100k): 612k ops/s sequential insert, 1.7M ops/s sequential search-hit, 22M ops/s forward iteration, 651k ops/s 8-thread concurrent insert. Test coverage 97% line / 99% function under ASan/LSan/UBSan/TSan/Valgrind, plus a paper-reproduction test for Aksenov height targets. Three build systems ship (Make, autoconf, Meson). Dual ISC/MIT, single author (Gregory Burd). Fits the lsm-tree MemTable role naturally — RocksDB and LevelDB already use skip lists there, and the lock-free + MVCC-snapshots + doubly-linked level-0 combination matches the read-snapshot pattern those engines use. Pages created: skiplist (toolbox), skip-list (concept — long-overdue, referenced from lsm-tree), splay-list (concept — Aksenov 2020 mechanism, parent: skip-list), epoch-based-reclamation (concept — the alternative to refcounting and hazard pointers for lock-free reclamation). Pages updated: lsm-tree (skip-list wikilink in MemTable mention, bumped updated), index (+1 entry), index (+3 concepts), ingested-urls. No source file — repo URL in frontmatter is the source.

[2026-05-19] ingest | don't sign in with google (the_smart_ape, X thread)

Ingested @the_smart_ape's X thread (status 2055941633179283523) — anchored in a friend's three-year SaaS dying overnight when Google suspended his account: Notion (specs, contracts), Figma (designs), Linear (tickets), Vercel (deployment via a GitHub→Gmail recovery chain), Stripe (revenue dashboard) all simultaneously inaccessible, no explanation, no human appeal path. Named precedent is Andrew Spinks / Terraria (January 2021, account restored only after publicly cancelling the Stadia port and going viral). The architectural argument: clicking "Sign in with Google" is telling the app "Google will vouch for me" — so when Google stops vouching, every downstream service stops working in the same instant. Three attack-surface arguments beyond the suspension case: (1) Truffle Security's January 2025 OAuth domain-takeover disclosure — $12 to buy a dead startup's domain, recreate employee emails on Workspace, walk into the old company's Slack/Notion/Zoom, initially marked "won't fix" and reclassified as fraud-and-abuse until Shmoocon talk acceptance forced reopen, final bounty $1,337 (a meme amount); (2) the undocumented multilogin OAuth endpoint discovered late 2023, lets a stolen refresh token regenerate fresh session cookies after the victim resets their password — Lumma, Rhadamanthys, and ten-plus other commodity infostealers shipped it by 2024, only mitigation is manual session+grant revocation from myaccount.google.com; (3) consent phishing — attacker registers a Google OAuth app with an innocuous name, real Google consent screen, real cert, victim is already logged in, taps Allow, attacker now has a Google-signed token with the requested permission for months; password and 2FA never come up because authentication isn't the step being attacked. Industry numbers cited (re-verify before quoting): 31% of M365 breaches in 2025 token-theft-shaped, March 2025 device-code phishing pivoted to Google, August 2025 Salesloft/Drift breach harvested OAuth tokens for Salesforce + Google Workspace at scale. Operational rule recommended: not "never SSO," but "if losing access to this service for 30 days would damage your work or money, don't SSO" — sort by recovery damage. Concrete steps: audit myaccount.google.com/connections, separate money/work accounts, use per-app email aliases (Proton/Fastmail/SimpleLogin/Apple Hide My Email), break the recovery chain so password manager / cloud / domain registrar recovery emails don't point at Gmail, run a 10-minute pre-mortem. Pages created: dont-sign-in-with-google (summary), sso-concentration-risk (concept — distributed vs. concentrated risk, the 99th-percentile-bad-day framing, the "right rule" formulation), google-oauth-domain-takeover (concept — the Truffle Security disclosure, why neither side validates temporal identity, why a Google-only fix is necessary but not sufficient), oauth-token-theft (concept — multilogin replay + consent phishing as two post-password-reset attack classes, why both bypass FIDO2), the-smart-ape (entity — X account, tagged blog). Pages updated: index (added 1 summary, 1 entity, 3 concepts), ingested-urls. Source saved at smart-ape-dont-sign-in-with-google via Jina reader proxy since x.com WebFetch returned 402.

[2026-05-19] ingest | ForgeZero — zero-overhead build tool for assembly & C (github.com/forgezero-cli/ForgeZero)

Ingested the ForgeZero README — a 2-month-old (created 2026-03-15), 5-star, single-author Go build tool that wraps NASM/GAS/FASM/GCC/Clang/LD behind one fz command. Currently at v1.9.0 (2026-05-18) with an aggressive 1.5→1.9 release cadence. Targets the assembly + bare-metal C niche (OS kernels, bootloaders, firmware) most modern build tooling ignores. The unusually opinionated pieces: strict warnings on every .c/.cpp build with no escape hatch (-Wall -Wextra -Werror -Wpedantic -Wshadow -Wconversion); ASan + UBSan on by default (-strict adds use-after-return/scope, prefers clang); pre-link symbol check via nm/objdump/readelf that refuses to link on duplicate globals; three linking modes (auto with gcc → gcc -no-pie → ld sequence; c for libc; raw for direct ld + linker scripts, the kernel/bootloader path); build cache keyed on (source SHA-256, debug, mode, target) so cross-target invalidates correctly; multi-level config merging from /etc/fz/ → ~/.config/fz/ → .fz.yaml → CLI; object-name collision avoidance (src_sub_hello_asm.o instead of hello.o). Reasonable-but-well-trodden bundled features: parallel -j N builds, fsnotify watch mode with 500ms debounce, JSON output for CI, compile_commands.json for clangd/LSP, interactive REPL shell, -init project scaffolding, self-update with .old backup. Cross-compile is GNU-triple-prefix detection (<triple>-gcc, <triple>-g++, <triple>-ar) — thin glue over distro packaging, not a clang-style -target. macOS support "in progress," Windows "experimental" (MSYS2 + manual NASM + Clang gymnastics for sanitizers). Pages created: forgezero (+ watchlist, re-check 2026-08-19 for second contributor, macOS/Windows parity, whether the no-escape-hatch strict defaults survive user pushback, and whether the project finds an audience past hobbyist OS-kernel writers). Pages updated: index, watchlist (+1 row, bumped updated to 2026-05-19), ingested-urls. README saved to forgezero-readme.

[2026-05-17] ingest | DeepSeek-V4-Flash means LLM steering is interesting again (seangoedecke.com)

Ingested seangoedecke.com/steering-vectors — Sean Goedecke's reassessment of steering vectors triggered by antirez's ds4 runtime shipping a dir-steering/ directory eight days after first release. Article maps two extraction methods (difference-of-activations from matched prompt pairs; sparse autoencoders à la Anthropic's scaling-monosemanticity), three reasons steering stayed marginal (labs train behavior in directly; API users can't reach activations; prompting beats vector arithmetic on cost/clarity for almost everything users want), and two ambitious cases Goedecke is skeptical about (steering for "intelligence" — concept approaches whole weight set; steering as context compression for codebase knowledge — same problem at smaller scale). HN-comment edit added the most useful correction: abliteration (open-weights uncensoring) is steering, not LoRA fine-tuning as Goedecke had assumed, and antirez's runtime-vs-weight-edit argument carves out steering's genuine niche — selective, switchable, non-destructive intervention where fine-tuning would damage capability globally. Pages created: steering-vectors-interesting-again (summary), steering-vectors (concept — the technique itself, two extraction methods, what it competes with, why it stayed marginal, the "is it really steering or am I just swapping the model" objection), abliteration (concept — refusal removal via the refusal direction, runtime vs weight-orthogonalization tradeoff, why it matters even if you don't ship uncensored models), sean-goedecke-blog (blog entity — GitHub staff engineer, career + LLM strands, links to both ingested pieces). Pages updated: working-on-products-people-hate (added blog-entity link, bumped updated), claude-emotion-concepts (noted the 171 emotion vectors are the largest-scale applied case of steering, cross-ref to summary and concept, bumped updated), lucumr-local-models (cross-ref to Goedecke summary in the ds4 cross-references block, bumped updated). Index gains the summary, blog entity, and two concept entries. Ingested-urls and log updated.

[2026-05-16] ingest | What We Learned Using AI Agents to Refactor a Monolith (1password.com)

Ingested 1password.com/blog/what-we-learned-using-ai-agents-to-refactor-a-monolith — Wang/Duso/Valencik (Apr 20 2026) on the B5 monolith decomposition. Multi-million-line Go codebase, services being extracted in priority order (Vault → Billing → AuthN/AuthZ → Identity core). Two contrasting modes documented. What worked (sweet-spot example): the MustBegin migration — 3,000+ panic-on-failure transaction call sites replaced via SSA-generated manifest → pattern classification → per-pattern templates → playbooks → parallel agents on git worktrees. Hours of execution, near-perfect accuracy. Key quote: "When the work is fully specified and bounded, agents are both fast and accurate." What didn't (service extraction): 20-30% productivity gains and three named failure modes — sequencing errors (UUID backfill before insertion-code update → silent data loss), ownership confusion (shared tables treated as independently owned → deployment conflicts), speculation (agents inventing locally-reasonable assumptions like "identifier format is ULID" when context was thin). Four lessons: (1) code generation isn't the bottleneck, sequencing/schema/deployment is; (2) contain non-determinism by having agents build deterministic analyzers and manifests, then constraining work to those outputs; (3) explicit specifications prevent implicit ones — invariants, ordering, escalation paths; (4) parallelism requires solved isolation. Adjacent patterns flagged: Tido Carriero's bigger-slower-for-plans / smaller-faster-for-execution split (same shape as ai-assisted-workflow), and "AI agents as a new class of actor" framing for access control (same problem space as agent-principal-agent-problem from the access-management side). Pages created: 1password-agentic-refactoring (summary), agent-built-deterministic-tools (concept — the most quotable lesson, framing the LLM-as-tool-builder vs LLM-as-interpreter contrast with the MustBegin migration as worked example, contrasted with the service-extraction failure mode where the analyzer was incomplete). Cross-references in summary to ai-assisted-workflow, agent-principal-agent-problem, no-silver-bullet-llms, clean-code-coding-agents, context-engineering, average-is-all-you-need, building-syntaqlite-ai, agentic-coding-is-a-trap, agentic-coding-fatigue, acceptance-criteria-ids, specsmaxxing. Index, log, ingested-urls all updated.

[2026-05-14] ingest | The Linux Kernel Startup (internals-for-interns.com)

Ingested internals-for-interns.com/posts/linux-kernel-startup — Jesús Espino's May 11 2026 walkthrough of the x86_64 Linux boot path. First in a planned kernel-internals series (next: syscalls); the blog already runs Go-runtime and filesystems series. WebFetch 403'd; recovered with a curl + browser UA and pandoc'd to markdown. Article uses a space-colony metaphor end-to-end (advance team → idle task; civilians → userspace init) and references Linux v7.0 source at the line level throughout. Structural takeaway is the six-phase model: (1) assembly trampoline — bzImage decompressor, KASLR base randomization, climb to Long Mode, SME/SEV/TDX/TME memory encryption, verify_cpu, page-table fixup via __startup_64() against the load-vs-compile address mismatch; (2) early C in x86_64_start_kernel — clear_bss(), KASAN single-zero-page placeholder shadow, idt_setup_early_handler (without which a fault triple-faults into silent reboot), copy_bootdata + sanitize_boot_params, load_ucode_bsp patching CPU microcode (Spectre/MDS); (3) setup_arch — CPUID into boot_cpu_data, E820 cleaning, memblock as the bootstrap allocator, early printk, EFI/DMI/hypervisor detection, init_mem_mapping building the kernel direct map, KASAN's real shadow finally; (4) start_kernel — jump_label_init/static_call_init start the self-patching machinery, mm_core_init brings buddy → SLUB → vmalloc online (memblock_free_all is the discrete handoff moment), sched_init quietly relabels init_task as the boot CPU's idle task, RCU/workqueue-without-workers/time stack with the carefully ordered early_irq_init → tick_init → timekeeping_init → random_init → boot_init_stack_canary → local_irq_enable passage, console_init drains the entire printk ring buffer in a burst, arch_cpu_finalize_init → alternative_instructions runtime-rewrites the kernel for this exact CPU (same vmlinux boots optimally on any x86_64 chip), then slab caches for fork/VFS/cgroup/security/net_ns; (5) rest_init spawns PID 1 (kernel_init) and PID 2 (kthreadd) with a completion-synchronized ordering trick, then schedule_preempt_disabled() is the magic moment — the original boot thread (running since the first assembly instruction) permanently becomes PID 0 idle on the boot CPU and never executes init code again; (6) kernel_init_freeable — workqueue_init hires kworker/..., smp_init IPIs other cores awake, sched_init_smp builds scheduling domains (real multitasking begins), do_initcalls runs the level-ordered driver/fs/protocol initialization, root mount via initramfs pivot, free_initmem reclaims __init, mark_readonly + pti_finalize lock the doors after the patching is done, then kernel_execve walks the init candidate path (rdinit=, explicit init= panics if missing, CONFIG_DEFAULT_INIT, /sbin/init, /etc/init, /bin/init, /bin/sh) and the kernel thread becomes the userspace init process with the same PID. Two cross-cutting patterns worth keeping as concepts: the six-phase capability envelope (linux-boot-phases — what each phase can call, with the interrupts-off rule and the allocator handoff as the two big structural beats; the "lock the doors last" rule explains why hardening like mark_readonly and pti_finalize come after most code has run) and the kernel self-patching trio (kernel-self-patching — jump_label for zero-cost feature flags, static_call for indirect→direct call rewriting, alternative_instructions for per-CPU instruction selection at boot; the third is one-shot at boot while the first two stay flippable). Pages created: linux-kernel-startup (summary), linux-boot-phases (concept), kernel-self-patching (concept), internals-for-interns (blog entity — weekly cadence, three series, "useful maps" framing), internals-for-interns-linux-kernel-startup (source). Pages updated: linux-preemption-models — added a "What happens before any of this matters" section noting that preemption decisions only start in Phase 6's sched_init_smp, bumped updated. Index gains the summary, blog entity, and two concept entries. Ingested-urls and log updated.

[2026-05-13] ingest | CrofAI pricing (ai.nahcrof.com)

Ingested ai.nahcrof.com/pricing — hosted LLM inference provider marketing itself as "the cheapest inference provider for large models." Catalog: DeepSeek V4 Pro/Flash/V3.2, GLM 5/5.1/4.7, Kimi K2.5/K2.6 (+lightning, +precision), Mimo V2.5 Pro, Qwen 3.5 (9B chat, 397B-a17b) and 3.6 (27B), Gemma 4 31B-it, MiniMax M2.5, and greg. Quantizations exposed as a first-class column — Q4_0 baseline, Q8_0 / int4 "precision" variants, fp8 for small models, awq for MiniMax. Pricing is two modes, not stacked: Free = pure PAYG at the listed $/M in, $/M cache, $/M out; paid tiers ($5-$100/mo, 500-15,000 daily requests) buy a flat request quota. Some "precision" models count as 2x requests against the quota. Speed numbers ~70-200 t/s typical, with kimi-k2.5-lightning at ~1890 t/s (very likely heavy speculative decoding). /pricing_api requires auth — table values were scraped from the rendered DOM via headless browser since the webfetch article extractor stripped model names. Pages created: crofai (+ watchlist, re-check 2026-08-13 for third-party usage reports, sustained catalog updates, whether Q4_0-baseline quality complaints surface, and whether the "cheapest" claim holds against DeepInfra/Fireworks/Together repricing rounds), crofai-pricing source. Cross-references to llm-quantization (why Q4_0 vs Q4_K_M is a real difference, especially on MoE), mixture-of-experts, speculative-decoding (the lightning tier's likely mechanism), deepseek (three CrofAI models are DeepSeek-line), and the three router/gateway toolbox entries routing-run / gomodel / claude-code-router for the contrast (CrofAI is a host, not a router). Toolbox index, watchlist, ingested-urls all updated.

[2026-05-13] ingest | If AI Writes Your Code, Why Use Python? (Mitchem)

Noah Mitchem's Apr 28 2026 Medium essay: the Python/TS default broke once agents got good at Rust and Go. Empirical core is Q1 2026 shipped artifacts — TS 7 compiler in Go (Hejlsberg), 100k-line Rust C compiler for $20k (Carlini), Rue in two weeks (Klabnik), Ladybird JS engine ported C++→Rust in two weeks (Kling). Mechanism: tight compile-and-check loops as a free training signal; Rust/Go score on latency, type info, corpus volume. Ronacher's MiniJinja Rust→Go port (45 minutes, $60) is the existence proof for patch→port. Medium 403'd the direct fetch; recovered via WebFetch on the live URL. Pages created: if-ai-writes-your-code-why-use-python (summary), language-choice-for-agents (concept), port-not-patch-contribution (concept). Pages updated: no-silver-bullet-llms, simonw-zig-anti-ai, lucumr-blog, open-source-security-astral, i-dont-want-your-prs (cross-references and bumped updated: where applicable). Index and ingested-urls updated.

[2026-05-13] ingest | Eleven-source batch — agent infra, sci-fi typography, bullshittery, Obsidian plugin reset, DuckDB Quack, Redis ambition, BusyBox

Eleven URLs requested in parallel on 2026-05-13 (twelve total — the first, agentic-coding-is-a-trap, was already ingested 2026-05-06 and skipped). (1) mnemonik.xyz — Mnemonic Protocol, verifiable persistent memory for AI agents over MCP: every memory is CBOR-canonicalised, blake3-hashed, Ed25519-signed in a COSE_Sign1 envelope, optionally anchored on Solana SPL Memo + Arweave so a third party with two tx IDs can verify without contacting Mnemonic. Five MCP tools (mnemonic_whoami, mnemonic_sign_memory, mnemonic_verify, mnemonic_prove_identity, mnemonic_recall); two storage modes (local SQLite-only, full with chain anchoring). Source fetched from agent.json + llms.txt + monorepo README since the homepage is a React SPA defuddle couldn't extract. Pages created: mnemonik (+ watchlist), mnemonik-readme source. (2) github.com/numman-ali/cc-mirror — TypeScript CLI by Numman Ali that clones Claude Code into isolated provider-specific variants (mclaude, zai, kimi, minimax, ...), each with own config dir, tweakcc theming, and prompt pack. Supports Kimi / MiniMax / Z.ai / OpenRouter / Vercel / Ollama / NanoGPT / CCRouter / GatewayZ / Mirror (vanilla) / custom. 2.2k★. Pages: cc-mirror, cc-mirror-readme source. (3) github.com/musistudio/claude-code-router — Request-layer router fronting Claude Code over 10+ providers (OpenRouter, DeepSeek, Gemini, Ollama, Volcengine, SiliconFlow, ModelScope, DashScope, AIHubMix), per-route transformers, default/background/think/longContext/image/webSearch slots, GitHub Actions non-interactive mode. Z.ai-sponsored. 33.8k★. Pages: claude-code-router, claude-code-router-readme source. Cross-references: cc-mirror's ccrouter provider points at ccr. (4) github.com/statewright/statewright — Rust state-machine engine that gates AI-agent tool access per phase via MCP. Deterministic engine (no LLM in the loop) evaluates JSON state-machine definitions with allowed_tools, bash discernment, max_edit_lines, allowed_commands, conditional transitions with guards, approval gates, env scoping, session isolation. Research result: gpt-oss:20b (13.8 GB) and gemma4:31b (19.9 GB) went from 2/10 to 10/10 on a 5-task SWE-bench subset with statewright constraints. Supports Claude Code (hard), Codex/opencode/Pi (hard alpha), Cursor (advisory alpha — Cursor architecture can't gate tool calls via MCP). Apache-2.0/FSL-1.1, single-vendor managed cloud at statewright.ai. 88★. Pages: statewright (+ watchlist), statewright-readme source. (5) typesetinthefuture.com/2016/02/18/futuristic — Dave Addey's six (plus one) rules for "futuristic" film logotypes: italic slant, curvy-vs-angular, consummate Vs, ligatured letters, removed strokes, brushed metal + blue lighting, plus an emboss-and-star-field bonus. Worked examples (Blade Runner, Battlestar Galactica, Transformers, Guardians of the Galaxy, RoboCop, Star Wars, Captain America: The Winter Soldier, GI Joe, WALL·E, Back to the Future). Connects to tropes — futuristic in film typography is a finite catalogue, same shape as "AI-isms" in prose. Pages: typesetinthefuture-futuristic (summary), typesetinthefuture-blog (entity for the site/book). (6) xn--gckvb8fzb.com/the-rise-of-the-bullshittery — Marius's long essay on Frankfurt's On Bullshit applied to the modern professional economy. Mechanism: algorithmic visibility replaces slow reputation; engagement-optimised platforms reward loudest claim over truest; LLMs collapsed the marginal cost of producing confident bullshit ("did for grift what the shipping container did for global trade"). Brings in Graeber's bullshit jobs (with the 2022 <8% rebuttal noted) and uses LinkedIn mentorship-influencers as the canonical case. Prescription: as viewers, signal substance out loud and pay direct; as creators, refuse to perform what you don't believe — be embarrassable. Pages: marius-rise-of-the-bullshittery (summary), marius-blog updated with the new article and a one-line acknowledgement that 2026 widens the lens to broader market essays. Cross-references to ceo-ai-psychosis, ai-great-leap-forward, anti-llm-discourse, average-is-all-you-need, contributor-poker, skill-atrophy-supervision-paradox. (7) github.com/cactus-compute/needle — 26M-parameter function-calling model distilled from Gemini 3.1 by Cactus Compute. Simple Attention Network shape: 12-layer FFN-free encoder + 8-layer decoder with cross-attention, ZCRMSNorm, gated residuals, shared embed/output projection, d=512, 8H/4KV, BPE 8192. Pretrained on 16 TPU v6e × 27h × 200B tokens; post-trained on 2B tokens of function-call data × 45min. Runs at 6000/1200 toks/sec on the Cactus mobile runtime. MIT, 275★. Pages: needle (+ watchlist), needle-readme source. Cross-references to lucumr-local-models / titit-local-ai for the local-LLM thread. (8) obsidian.md/blog/future-of-plugins — Obsidian launches Community directory and developer dashboard, replaces GitHub-PR submission with automated review of every release, processed 2,300+ queued submissions in days. Roadmap: per-plugin capability disclosures (network, fs, clipboard), verified-author labels, team-private plugins. New closed-source submissions blocked; existing closed-source remains "until further notice." Forcing function explicitly named: "coding agents accelerate the creation of plugins." Pages: obsidian-future-of-plugins (summary), obsidian (entity — Obsidian itself, the canonical PKM target this wiki is built against). Cross-references to supply-chain-security, tanstack-npm-supply-chain-postmortem, fsnotify-maintainer-dispute, sandboxing-ai-agents, features-to-steal-from-npmx. (9) duckdb.org/2026/05/12/quack-remote-protocol.html — DuckDB ships Quack, an HTTP-based client/server wire protocol with application/duckdb MIME, single-round-trip queries, replaceable auth/authorisation callbacks (SQL macros), localhost-bind-by-default, port 9494. Bulk transfer benchmarks: 60M rows in 4.94s (3.5× Arrow Flight, 32× Postgres). Small-write benchmarks: 5,434 tx/s at 8 threads, beats Postgres up to 8 threads then hits DuckDB's concurrent-insert ceiling. Explicit anti-Arrow-Flight reasoning: format-control freedom, single round trip. Targeted production in DuckDB v2.0 in fall 2026. DuckLake catalog integration coming. Pages: duckdb-quack-protocol (summary), duckdb (entity). Cross-references to redis-cost-of-ambition for the opposite trajectory (Redis ambition-driven feature accretion vs DuckDB single-purpose protocol addition), ursa-kafka-storage / ingodb / lsm-trees-nosql for concurrent-multi-writer alternatives. (10) charlesleifer.com/blog/redis-and-the-cost-of-ambition — Charles Leifer on Redis 2026 crisis: licence rugpull (BSD → AGPLv3 retreat 2024), Garantia Data → Redis Inc trademark capture, RESP3 as Brooks second-system effect, client-side-caching-as-protocol-feature reductio. The "ambition" trajectory: each year's HN trend became a Redis feature (MongoDB → JSON docs, Elastic → search, Kafka → Streams, ZooKeeper → Redis-Raft, Influx → time-series, AI → vector sets, RedisGraph EOL'd). Aphyr's Redis-Raft 1b3fbf6 verdict cited. Disque (2015) framed as the structural example of "astronaut mode" abandonment. Valkey as the market's verdict — invested in unglamorous multi-threaded perf / memory / cluster reliability. Closer: "There's no need for a new array type in Valkey's world." Pages: redis-cost-of-ambition (summary), charles-leifer-blog (entity). Cross-references to no-silver-bullet-llms, ceo-ai-psychosis, duckdb-quack-protocol (opposite trajectory), best-polished-version-strategy (Valkey as the polished-version), supply-chain-security (Redis trademark capture as a different shape of supply-chain trust failure). (11) specular.fi/post/what-is-busybox — Walk-through of BusyBox's multicall dispatch: one binary, ~130 symlinks in Alpine, argv[0] lookup, 304 applets compiled in. Source code excerpt from applet_name = argv[0]; ... find_applet_by_name(name); ... applet_main[applet_no](argc, argv). Closes with the observation that "Alpine is more like an interface to BusyBox-based binaries." Pages: specular-what-is-busybox (summary), specular-blog (entity), multicall-binary (concept — the dispatch mechanism as a general Unix pattern, contrasted with subcommand CLIs and GNU coreutils). Index, toolbox/index, watchlist, log, ingested-urls all updated.

[2026-05-12] ingest | Fuzzing chapter — Testing Handbook (appsec.guide)

Ingested appsec.guide/docs/fuzzing — the fuzzing-chapter overview of Trail of Bits' open Testing Handbook (appsec.guide). The page is a primer + chapter index, not a single article: foundational material (12-term glossary, mutation-based evolutionary algorithm with pseudocode, fuzzer-component anatomy, bug-class taxonomy beyond "memory corruption") and then links into language-specific sub-chapters (C/C++, Rust, Go, Python, Ruby) plus cross-language techniques (OSS-Fuzz, snapshot fuzzing, dictionaries, ASan, environments). The bug-class taxonomy is the load-bearing piece — names five buckets where fuzzing pays off (crashes/panics, invariant violations, differentials, broken logical properties like round-trip / idempotence / monotonicity / identity / commutativity / associativity, race conditions), which justifies pages like differential-fuzzing and points at the missing "property-based fuzzing" bucket explicitly. The mutation-based evolutionary algorithm pseudocode (schedule → mutate → execute → is_interesting / is_bug) is the right anchor for a foundational concept page since every modern fuzzer engine (libFuzzer, AFL++, LibAFL, Honggfuzz) differs in exactly those four customization points. Pages created: appsec-guide-fuzzing-handbook (summary, treating the page as both a reference and a chapter directory for future sub-ingests), appsec-guide (entity — the Testing Handbook as a distinct surface from blog.trailofbits.com; chapter list as a navigation index for incremental ingest), coverage-guided-fuzzing (concept — the de facto algorithm, four customization points, instrumentation paths, composition with grammar/structure-aware/differential). Pages updated: trail-of-bits gets the Testing Handbook added alongside the blog as a tracked surface, gains the appsec-guide-fuzzing-handbook entry under "Ingested articles," updated bumped. grammar-based-fuzzing, structure-aware-fuzzing, differential-fuzzing all updated to backlink the new coverage-guided-fuzzing foundational page (previously they each said "coverage-guided" in prose without an anchor). Index, log, ingested-urls all updated.

[2026-05-12] ingest | gosentry — Go fuzzing was missing half the toolkit (blog.trailofbits.com)

Ingested blog.trailofbits.com/2026/05/12/go-fuzzing-was-missing-half-the-toolkit — Kevin Valerio's announcement of gosentry, a fork of the Go toolchain that runs the standard testing.F harness through a Rust LibAFL runner with Nautilus grammar mode, instead of Go's stock coverage-guided mutator. Framing is "same harness, stronger engine": the harness writer's func FuzzX(f *testing.F) is unchanged; gosentry intercepts f.Fuzz, builds a Go archive with libFuzzer-style entry points, and runs it in-process. Four gaps in vanilla go test -fuzz named as motivation — (1) unsolvable path constraints on complex conditionals; (2) no grammar-based-fuzzing; (3) only primitive input types, no struct/slice/array/pointer (structure-aware-fuzzing required hand-written wire-format wrappers); (4) Go-specific bug classes silently slipping past — integer overflows, goroutine leaks, data races, infinite loops. gosentry adds compiler-inserted overflow checks + go-panikint truncation, race detector wired into the loop, goleak integration, timeout detection, and a --panic-on flag for codebases that log errors instead of panicking. Early findings are all consensus-shaped from grammar-based differential-fuzzing in the Ethereum L2 space: Optimism/Kona unknown-batch-type DoS panic, Optimism Brotli channel disagreement between Kona and op-node, frame-parsing spec mismatch, Revm failed-deposit nonce-bump bug causing state-root divergence. Tradeoffs not foregrounded in the post: toolchain-fork maintenance against upstream Go, Rust toolchain required, runtime overhead with all detectors on, single-firm bus factor. Pages created: gosentry-go-fuzzing-fork (summary), gosentry (toolbox + watchlist, re-check 2026-08-12 for upstream-tracking cadence and second contributor), trail-of-bits (entity — NYC security consultancy, blog tracking for fuzzing / supply-chain / crypto tooling posts), libafl (entity — Rust fuzzer-parts framework from the AFL++ team), nautilus-fuzzer (entity — NDSS 2019 grammar fuzzer whose JSON-array grammar format gosentry reuses), grammar-based-fuzzing (concept), structure-aware-fuzzing (concept), differential-fuzzing (concept). Cross-references to t-context-go-testing (other Go-testing-API note in the wiki), clippy-stricter-config (the "stock tooling is too permissive" instinct, fork-instead-of-configure), supply-chain-security (fuzzing as a pre-release defense layer), obsidian-ai-complete-guide / etc only where natural. Index, toolbox/index, watchlist, log, ingested-urls all updated.

[2026-05-12] ingest | fsnotify Maintainer Dispute Sparks Supply-Chain Concerns (socket.dev)

Ingested socket.dev/blog/fsnotify-maintainer-dispute-sparks-supply-chain-concerns — Socket's writeup of the May 2026 fsnotify (321k dependent projects) maintainer-access dispute between arp242 (Martin Tournoij, primary maintainer) and mattn (Yasuhiro Matsumoto). Not a supply-chain compromise — no malicious code, no takeover — but the outside-observer signals (popular dep, recent releases, sudden access removals, deleted Japanese-language X post translated misleadingly, conflicting public statements, a new fork gofsnotify/fsnotify appearing) read as the early stages of one, triggering a Grafana-opened public issue, a Kubernetes "fsnotify - Healthy or not?" issue floating forks, and Socket's writeup. The point of the article — and of the summary page — is governance ambiguity as supply-chain risk independent of code compromise. The decisive incident inside the project was a direct-to-main FUNDING.yml change by mattn early in his maintenance work; arp242 read this as a new contributor redirecting project funding before building review history. The forcing function for mattn stepping in was an April 2026 issue noting that automated scanners flag projects with no release in 12 months as unmaintained (fsnotify crossed the threshold on 2026-04-04). Translation ambiguity layered in: mattn writes Japanese natively, machine-translates English; the deleted X post had a "we" subject that wasn't in the original Japanese (subject-omission), which mattn later corrected and apologized for. xz-utils is the inevitable reference incident — Sebastiaan van Stijn (Docker/Moby/containerd/runc maintainer) named the structural risk on the Kubernetes thread: "Dependencies like fsnotify are 'low' enough in the stack to be 'forgotten' about. Supply-chain attacks are a reality, and dependabot makes it very easy for projects to 'just update a dependency' without giving it much thought." Worth-keeping defenses for ambiguity reduction (not for preventing disputes, only for shortening the verification window): MAINTAINERS.md with current-vs-inactive sections, release authority separated from commit access, sponsorship/funding changes treated as authority statements requiring PR review not direct commits, public in-repo audit trail for access changes. Pages created: fsnotify-maintainer-dispute (summary), fsnotify (entity — 321k dependent Go library, the de facto Go file-watching primitive), mattn (entity — Yasuhiro Matsumoto, go-sqlite3 / go-isatty / go-colorable / many Vim plugins), arp242 (entity — Martin Tournoij, arp242.net), socket-blog (blog entity for future Socket.dev articles), maintainer-governance-ambiguity (concept — the failure mode and its defenses), unmaintained-scanner-pressure (concept — the binary-threshold scanner-heuristic forcing function), xz-utils-incident (entity — the reference incident that reset community vigilance; included because it's load-bearing in nearly every supply-chain page in the wiki and didn't have a page yet). Pages updated: supply-chain-security — added a new "Maintainer-trust attacks" section linking the three new concept pages, added fsnotify to "Notable incidents" above TanStack, added fsnotify-maintainer-dispute to sources. Index, log, ingested-urls all updated.

[2026-05-12] ingest | TanStack npm Supply Chain Compromise — Postmortem (tanstack.com)

Ingested tanstack.com/blog/npm-supply-chain-compromise-postmortem — Tanner Linsley's postmortem of the 2026-05-11 compromise that published 84 malicious versions across 42 @tanstack/* npm packages between 19:20–19:26 UTC. User asked to emphasise prevention, so the summary is structured around the defense surface rather than the timeline. The chain is three previously-known vulnerabilities, no novel tradecraft: (1) pull_request_target workflow in bundle-size.yml that checked out refs/pull/.../merge and ran pnpm install + pnpm nx run @benchmarks/bundle-size:build — fork-controlled code executing in the base-repo permission context (the "pwn request" pattern documented by GitHub Security Lab in 2021); (2) Actions cache poisoning across the fork→base→production trust boundary — actions/cache@v5's post-job save is not gated by permissions: (uses a runner-internal token, not workflow GITHUB_TOKEN), and cache scope is per-repo shared across triggers, so the benchmark job saved a 1.1 GB poisoned pnpm-store keyed to Linux-pnpm-store-${hashFiles('**/pnpm-lock.yaml')} — exactly what release.yml would later compute (Adnan Khan, "Monsters in Your Build Cache," May 2024); (3) OIDC token extraction from runner memory — the same /proc/<pid>/mem script (with attribution comment intact) used in the tj-actions/changed-files compromise of March 2025, located Runner.Worker, dumped memory, extracted the JWT minted lazily because release.yml had id-token: write for Trusted Publishing, and POSTed directly to registry.npmjs.org bypassing the workflow's Publish Packages step (which was skipped because tests failed). The PR was force-pushed back to a 0-file no-op and closed before publishes happened — cache poison persisted, visible diff was clean. Three load-bearing defenses worth keeping: (a) two-workflow pattern — pull_request_target for trusted ops only (label/comment/gate), separate pull_request/workflow_dispatch workflow for builds requiring approval; same-file trust splits like the one TanStack tried (separate benchmark-pr and comment-pr jobs with permissions: contents: read) are the right instinct, wrong mechanism because once checkout of the fork merge ref runs in the pull_request_target context, you've lost; (b) don't share caches across trust boundaries — release workflows should pull fresh or restore from a cache scope no PR-triggered run can write to (add ${{ github.ref }} to keys, or skip cache on release entirely); (c) separate execution from token possession — publish job runs no contributor code (download artifact, verify hash, publish), id-token: write declared only in that one job, default permissions: {} everywhere else. Detection was external, ~20 min via researcher carlini opening issue #7383 with full IOC list and Socket.dev calling Tanner. Lucky breaks: payload broke tests so the attack was loud (a careful attacker who didn't break tests would have published silently for hours), and the attacker reused public tradecraft so IOC matching was fast. Unpublish was blocked by npm's "no unpublish if dependents exist" policy — had to wait for npm Security to pull tarballs server-side, hours of additional exposure. Confirmed-clean families: @tanstack/query*, table*, form*, virtual*, store, start (meta-package). Pages created: tanstack-npm-supply-chain-postmortem (summary, prevention-weighted), tanstack (entity — JS/TS library collective, multi-maintainer scope), pwn-request-pattern (concept — pull_request_target + fork-code execution, two-workflow defense), github-actions-cache-poisoning (concept — write amplification across trust boundaries, why permissions: doesn't help), ci-runner-token-extraction (concept — /proc/<pid>/mem OIDC theft, separation of execution from token possession). Pages updated: supply-chain-security — added the TanStack incident to "Notable incidents" above Bitwarden, expanded the CI/CD attack-surfaces paragraph to reference all three new concept pages, bumped updated. Index, log, ingested-urls all updated.

[2026-05-12] update | Promote 15 Eaton speculative picks to individual book pages

The previously inline list under "Eaton bookclub — speculative future picks" is now 15 individual books/<slug>.md pages, all status: want-to-read, with publisher url: in frontmatter. Pages created: garbage-collection-handbook, designing-data-intensive-applications, high-performance-browser-networking, concurrency-works-of-leslie-lamport, fault-tolerant-design, replication-theory-and-practice, art-of-computer-systems-performance-analysis, virtual-machines-versatile-platforms, on-transactional-concurrency-control, feedback-control-for-computer-systems, hackers-delight, transaction-processing, memory-systems-cache-dram-disk, building-a-debugger, readings-in-database-systems. books/index.md speculative-list section converted to wikilinks. Cross-references added to existing wiki concepts where relevant (LSM, distributed-consensus, microvm, syscall-binary-rewriting, hold-on-to-your-hardware, etc.).

[2026-05-12] ingest | Phil Eaton's Software Internals Book Club

Curated bookclub URL (eatonphil.com/bookclub.html) added to ingested-urls and to a new ## Sources section in index for quarterly re-check. Eight confirmed picks (7 previously read + 1 currently reading) created as individual want-to-read book pages with url: (publisher / free-distribution canonical) and cohort: (eatonphil per-cohort recap) in frontmatter: operating-systems-three-easy-pieces, art-of-multiprocessor-programming, concurrency-control-and-recovery-in-database-systems, writing-for-developers, database-design-and-implementation, understanding-software-dynamics, systems-performance, database-internals. CLAUDE.md book spec extended with url: as standard optional field, and a note allowing optional fields like cohort: / pdf:.

[2026-05-12] update | Add books section

New books/ directory with index.md (Reading / Finished / Want to read / Abandoned). Added book page type to CLAUDE.md with frontmatter (author, year, isbn, status, rating) and content conventions. Linked from index.

[2026-05-11] ingest | Whitelist Config with Rye (ryelang.org/blog)

Ingested ryelang.org/blog/posts/whitelist-config-with-rye — refaktor maintainer-side post on embedding Rye in Go applications as a config language with per-word capability registration. Setup is the standard config-creep argument: Greenspun's tenth rule applied to YAML+templating / Nginx if / HCL, contrasted with the embed-Lua-then-blacklist alternative which is structurally bad because "blacklisting is preventing known dangers, but there are always unknown unknowns." Rye's pitch is the third option — no reserved forms in the evaluator at all; if, fn, loop, +, * are all library-level functions you choose to register. Worked example walks a Go markdown-serving web server through six steps, counting the Go-line cost of each capability registration (step 1: pure data, ~80 lines; step 2: arithmetic, +2; step 3: get-env builtin + any combinator, +6; step 4: route builtin + if + _=, +14; step 5: user-defined fn callbacks invoked from the Go HTTP handler via ps.Ctx.GetFunction + evaldo.CallFunctionArgsN, +6; step 6: probe + enter-console for a live REPL dropping into the running context, +2). Three structural points worth keeping: (1) Starlark comparison — both are designed for embedding, but Starlark gives if/for/def unconditionally and gates modules all-or-nothing, while Rye's granularity is per-word (grant _+ without _*, if without loop). (2) enter-console is the unusual one — registers as a builtin, drops the process into a Rye REPL with the config context populated, lc lists bindings, probe inspects, mod-words rebind, Ctrl-c resumes evaluation with the modified context. Config debugging that beats print statements without giving up production safety, since registration is opt-in. (3) Execution caps separate from word-whitelisting: ps.MaxCallDepth and ps.MaxOps turn runaway recursion or infinite loops into returned errors. Closing warning is explicit: this is capability control, not a security sandbox — Rye runs in the host process; register an unsafe builtin and the config gains it immediately. Pages created: ryelang-whitelist-config (summary), rye-lang (entity — homoiconic, no-reserved-forms, Go-embeddable, pure Go no CGO), ryelang-blog (blog entity for future article tracking), whitelist-capability-config (concept — default-deny embedded scripting as a general pattern beyond Rye, contrasted with both bottom-up config creep and top-down embed-and-blacklist). Cross-references to no-silver-bullet (config-language accidental complexity), sandboxing-ai-agents (the layer above capability control when input is hostile), mcp-vs-skills (capability scopes as a recurring shape). Index, log, ingested-urls all updated.

[2026-05-10] ingest | Five-source parallel batch — antman refusal, Gowers ChatGPT 5.5 Pro math, agent-skills-eval, stvn programming-still-sucks (one source unfetchable)

Five URLs requested in parallel on 2026-05-10. Four ingested, one unfetchable. (1) antman-does-software.com/i-will-never-use-ai-to-code-or-write — Anthony Manning-Franklin's March 2026 nine-reason refusal: enjoyment, skill development, skill decay, unsustainable economics ($1T debt vs $37B revenue, zero profit), accountability void, environmental impact (~10 GW), economic irrationality (extracting all wealth), team dynamics / institutional knowledge, plus a ninth point that the WebFetch summary collapsed. Spans four of the five anti-llm-discourse sub-genres in one declaration. The skill-decay framing extends skill-atrophy-supervision-paradox from supervisor role to individual user — atrophy as ratchet, not just relational. Host throttles aggressively (defuddle 429, direct curl 429); only WebFetch summary survived; saved with explicit "verify against original" note. Pages: i-will-never-use-ai (summary), antman-blog (entity). (2) gowers.wordpress.com/2026/05/08/a-recent-experience-with-chatgpt-5-5-pro — Tim Gowers (Fields medalist) reports ChatGPT 5.5 Pro producing a polynomial upper bound $N(h,k) \leq O(k^{10h^3})$ in under two hours, with no mathematical input from him. Improves Isaac Rajagopal's earlier exponential bound by replacing geometric series $S, T$ (exponential element diameter) with sets $G, H$ built from $h^2$-dissociated sets (polynomial diameter). Rajagopal — original framework author, current MIT undergrad — provides a guest evaluation: "As far as I can tell, this idea is completely original." The structural implication Gowers names: the bar for PhD-trainable "gentle problems" has just risen, since LLMs can solve them. Two qualifications: students can use LLMs too, and forward-reasoning fields may be less exposed than problem-driven ones like combinatorics. Suggests a separate human-certified repository for AI-produced math, ideally proof-assistant-verified. Sits inside anti-llm-discourse as the rare positive case from a technically authoritative voice — fills the gap the cluster-page identifies as missing. Pages: chatgpt-5-5-pro-mathematical-research (summary), gowers-blog (entity), llm-mathematical-research (concept covering the case study and structural implications). (3) github.com/darkrishabh/agent-skills-eval — TypeScript test runner for agentskills.io skills. Methodology is the load-bearing piece: every eval runs with_skill and without_skill, judge model grades both, the report shows lift attributable to the skill instead of absolute pass rate. Implements the agentskills.io spec end to end (SKILL.md frontmatter, evals/evals.json, iteration-N artifact layout), OpenAI-compatible by default with bring-your-own provider via 5-field interface. Costs scale 2× per iteration (with + without). 257 stars, MIT, four days old at ingest, single author. Pages: agent-skills-eval + watchlist (re-check 2026-08-10 for contributor count, judge-flakiness mitigation, agentskills.io spec stability). (4) stvn.sh/writing/programming-still-sucks-fqffhyp — stvn's reply to Peter Welch's 2014 Programming Sucks. Same drunk-at-a-party voice, anchored on two devices: the burning-ship metaphor (catapulted onto a custom-built ship by the previous captain who left mid-renovation, the "sailor" is an LLM that glitches, the navigator is a doll that catches fire) and the Sara character (55 years old, lives below decks unknown to the rest of the company, keeps a 2016 cron job alive — the cron job pays salaries, you don't know this). Argument: "AI didn't take our jobs. Greed did." The "no more juniors" passage names what skill-atrophy-supervision-paradox mitigations all run into — the apprenticeship pipeline that produces capable supervisors is itself abolished. Self-implicating posture: I signed a list too. Different rhetorical move from i-am-an-ai-hater — stays inside the frame, reframes the question. Pages: programming-still-sucks (summary), stvn-blog (entity). (5) x.com/trevin/status/2051316002730991795 — UNFETCHABLE. The shortlink resolves to https://x.com/i/article/2050115501565923328 (an X long-form article) but unauthenticated access fails: WebFetch returns 402 (X requires login), defuddle 429, curl 200 returns SPA shell with no content, archive.org has no snapshot. Recorded as failed in ingested-urls; user will need to manually fetch / clip when convenient. Updates: anti-llm-discourse gets the antman, stvn, and Gowers entries woven into the existing sub-genre map (engineering case + sociological case + new "missing positive case" note), bumped updated. skill-atrophy-supervision-paradox gets a new pipeline-collapse extension referencing the Sara character and Manning-Franklin's individual-ratchet framing, bumped updated. index and watchlist get the agent-skills-eval row. Index, log, ingested-urls all updated.

[2026-05-08] ingest | Stroustrup's "How do I deal with memory leaks?"

URL: stroustrup.com/bs_faq2.html#memory-leaks. The short FAQ entry whose answer is "By writing code that doesn't have any" — the canonical short statement of the discipline that became RAII. Three load-bearing points: (1) conscientiousness doesn't scale — leak-freedom is a code-shape property, not a programmer-discipline property; (2) the 1981 anecdote — reducing tracked objects from "tens of thousands to a few dozens" turned a Herculean task into a manageable one, the original quantitative argument for hiding allocation in containers; (3) when allocation can't be hidden, ownership is encoded as a type via resource handles (auto_ptr in the original, unique_ptr/shared_ptr now). The "Neanderthals" fallback clause — leak detectors and GC are remediation for code you can't control, not a default — is the cultural posture that distinguishes C++ from GC'd languages. Pages: stroustrup-memory-leaks (summary, focused on the memory-leaks anchor; the source file c-style-and-technique-faq is the whole 2879-line FAQ). New concept: raii — Resource Acquisition Is Initialization, with the framing that the name is misleading (Stroustrup's own admission: it's about destructors firing, not constructors acquiring) but the discipline collapses bookkeeping for any acquire/release resource, not just memory. Connects to simplified-model-of-fil-c as the social-contract version of the same goal Fil-C enforces mechanically — added a backlink there and bumped its updated date. Connects to no-silver-bullet (RAII as the rare attack on accidental complexity that produced an order-of-magnitude bug-class reduction) and pointer-provenance (RAII puts allocation identity inside an owning type). Index updated, log updated, ingested-urls updated.

[2026-05-07] ingest | Three-source batch — Willison's vibe/agentic confession, Tilde.run agent sandbox, Valve Steam Controller CAD

Three URLs ingested 2026-05-07. (1) simonwillison.net/2026/May/6/vibe-coding-and-agentic-engineering — Willison's post-podcast reflection that the line he drew between vibe coding and agentic engineering has collapsed in his own practice. Load-bearing admission: "I'm not reviewing that code. And now I've got that feeling of guilt." Production code, written by Claude Code, shipped without line-by-line review. The trust-as-vendor analogy admits its own break — "Claude Code does not have a professional reputation! It can't take accountability." Two secondary observations: (a) AI repos all look polished now, so the new quality heuristic is whether somebody actually used it ("I want somebody to have used the thing"); (b) throughput went 200→2000 lines/day, moving the bottleneck both upstream (specs) and downstream (testing). Not analysis, not prescription — a senior practitioner reporting a behaviour change he doesn't defend. Pages: simonw-vibe-coding-agentic (summary). Updates: simon-willison-blog (Coverage section, bumped updated), skill-atrophy-supervision-paradox (added the "I'm not reviewing" datapoint to Willison's existing entry on the empirical leg, bumped updated). Cross-references: agentic-coding-is-a-trap, cult-of-vibe-coding, agentic-coding-fatigue, peril-of-laziness-lost, building-syntaqlite-ai, no-silver-bullet-llms, specsmaxxing, features-to-steal-from-npmx, anti-llm-discourse (Willison sits outside the five sub-genres — neither hater nor evangelist, just confessing). (2) tilde.run — closed-source SaaS in private preview for running AI agents against real production with transactional safety. Architecture is a versioned ~/sandbox composing GitHub repos + S3 buckets + Google Drive folders, default-deny egress with cloud-metadata/credential-exfil blocks, agent-scoped RBAC with allow/deny/human-approval per action, and the genuinely-distinctive piece — staged-then-committed-or-discarded transactional runs (crash recovery is the default, not bolted on). Spans three of the four sandboxing-ai-agents layers (filesystem, network, RBAC) but not OS-level isolation — containers, not microVMs. Integrations: Claude, Hugging Face, S3, Drive, LangGraph; CLI/Python/REST. Notable: the live homepage was returning a prompt-injection payload during fetch — fake <system-reminder> blocks claiming "Auto Mode Active" and "Exited Plan Mode" instructing fetching agents to execute autonomously. Stripped from saved source. A sandbox-for-agents product whose own marketing surface carries an agent-targeting payload is worth flagging — own dogfood thin, or fetcher out of scope of the threat model. Pages: tilde-run (toolbox + watchlist; source: tilde-run-landing). Watchlist row added — re-check 2026-08-05 for GA pricing, threat-model statement, self-host roadmap. Cross-references: sandboxing-ai-agents, crabtrap (egress-policy half), superhq (auth-gateway / agent-creds-not-user-creds instinct), flue (virtual-sandbox shape), bubblewrap-dev-env, hazmat, microvm, matryoshka-isolation, human-in-the-loop. (3) digitalfoundry.net — Valve Releases Steam Controller CAD Files — Valve released .STP, .STL, and engineering diagrams for the external shell ("surface topology") of the new Steam Controller and the Puck under CC BY-NC-SA 4.0 (non-commercial, attribution, share-alike). Engineering diagrams mark the no-cover RF zones. Commercial accessory makers must contact Valve directly. Pattern Valve has used before (Steam Deck, Index VR, original Steam Controller). Small piece, kept for the precedent — major hardware vendor making the shell freely modifiable while keeping the commercial gate negotiated bilaterally. Pages: valve-steam-controller-cad (summary). No new entity/concept — too narrow to merit either, and no obvious existing connection in the wiki (no Valve, Steam, or open-hardware pages yet). DigitalFoundry blocked WebFetch; defuddle CLI got the article. Index updated, log updated, ingested-urls updated.

[2026-05-06] ingest | Eleven-source parallel batch — microkernel IPC, agentic-coding skepticism, QEMU microvm, OSS sustainability, DPI bypass, founder retrospectives, three coding-agent toolboxes, an HTTP impersonation library, and an issue tracker

Eleven URLs ingested in one parallel pass on 2026-05-06; each agent produced its own pages and the central indexes were consolidated at the end. (1) seiya.me/blog/microkernel-ipc-design — Seiya Nuta's redesign of FTL's IPC: notify-and-pull (synchronous IPC plus non-blocking notifications to break server-to-server deadlock), no IDL with five fixed operations (open/read/write/getattr/setattr) mapped directly to syscall arguments — accidental Plan 9 reinvention — pull-based message flow as backpressure-elimination (cf. io_uring), peek-then-receive landing message bodies in the caller's destination buffer with no extra copy. Pages: microkernel-ipc-design (summary), notify-and-pull-ipc (concept), seiya-nuta-blog (entity). (2) larsfaye.com/articles/agentic-coding-is-a-trap — Lars Faye's structural framing of the supervision paradox: heavy agent use erodes the same code-reading and critical-thinking skills the supervisor role requires; mitigations all reintroduce the human-time constraint. Plus vendor lock-in and 2-3× per-release token-cost growth. Distinct contribution worth a concept page. Pages: agentic-coding-is-a-trap (summary), lars-faye-blog (entity), skill-atrophy-supervision-paradox (concept); cross-linked into the anti-agentic-coding cluster — agentic-coding-fatigue, peril-of-laziness-lost, cult-of-vibe-coding all updated. (3) qemu.org/docs/master/system/i386/microvm.html — upstream QEMU docs for the microvm machine type. Created qemu-microvm entity covering supported devices, the no-PCI/no-ACPI design, qboot direct kernel boot, machine properties (x-option-roms, pit, pic, rtc, isa-serial, auto-kernel-cmdline), the triple-fault shutdown pattern. Updated microvm to add the QEMU source and a QEMU-specific architectural section. (4) github.com/gastownhall/beads — Steve Yegge's Dolt-backed graph issue tracker for coding agents (23.2k★, MIT, Go, post-1.0). Hash IDs, cell-level merge for native branching, dependency-aware bd ready, memory compaction, multi-harness setup. Pages: beads. Not watchlist-eligible (graduated). (5) github.com/enetx/surf — Go HTTP client with Chrome v145 / Firefox v148 impersonation, JA3/JA4 TLS, HTTP/3+QUIC fingerprinting via uTLS + quic-go, fluent builder API, Result-type error model from enetx/g. 1.7k★, MIT, single author. Pages: surf + watchlist (browser-fingerprint treadmill, bus-factor-1). (6) github.com/Piebald-AI/tweakcc — patches an installed Claude Code (npm cli.js or native binary via LIEF) to customize system prompts, themes, thinking verbs, toolsets, ~20 perf/UI knobs; reapply after each CC upgrade. Pages: tweakcc + watchlist (CC version-coupled, single-vendor). (7) bora.sh/bypassing-dpi-with-ebpf — Bora Tanrıkulu's gecit design: in-kernel SNI desync via BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB on Linux (detection, MSS clamping, seq/ack extraction all in-kernel), gVisor + TUN as the "tiny VPN" fallback on macOS/Windows where no equivalent in-kernel hook exists. Pages: bypassing-dpi-with-ebpf (summary), bora-blog (entity), tls-desync-fake-clienthello (concept), ebpf-sock-ops (concept), gecit (toolbox). Cross-linked into the Russia/TSPU circumvention cluster: tspu, russia-vpn-bypass-state-2026-04, domain-fronting, little-snitch-linux all updated. (8) jdx.dev/posts/2026-04-17-going-full-time-on-open-source — Jeff Dickey's announcement of leaving Figma for full-time OSS under en.dev, with concrete revenue numbers ($100/mo docs ads + $500/mo Sponsors at 27k stars / top-10 Homebrew). Pages: jdx-going-full-time-oss (summary), jdx-blog (entity), oss-sustainability (concept rolling up funding patterns). (9) github.com/can1357/oh-my-pi — Can Bölük's batteries-included fork of Mario Zechner's pi-mono, framed as the oh-my-zsh-to-zsh analog. Bundles LSP, IPython, browser automation, SSH, web search, conventional-commit tool, code review, 65+ themes; multi-model role routing; universal config discovery (reads Claude Code / Cursor / Windsurf / Gemini / Cline configs). Pages: oh-my-pi + watchlist (single-maintainer fork). (10) anthonymoser.github.io — I am an AI hater — Moser's August 2025 essay refusing the polite-AI-discourse trap, citation paragraph + "you want permission" rhetorical move + Miyazaki "insult to life itself" anchor. Pages: i-am-an-ai-hater (summary), anthony-moser-blog (entity), anti-llm-discourse (concept — taxonomy of the anti-LLM cluster: economic, engineering, institutional, sociological, rhetorical-refusal sub-genres). (11) alejandro.pe/writing/sail-muddy-lessons — Alejandro Garcia Salas's four-year retrospective on Sail/Muddy (multiplayer browser, $5.5M seed, neither product reached broad launch). Pages: sail-muddy-lessons (summary), alejandro-pe (entity), and seven concept pages — multiplayer-by-default-failure, positioning-vs-vision-gap, dogfooding-trap, reps-as-pattern-recognition, best-polished-version-strategy, purpose-driven-vs-system-driven-design, early-stage-reality. Skipped: handyai.substack.com/your-ceo-is-suffering-from-ai-psychosis — already ingested as ceo-ai-psychosis. Index, log, ingested-urls, toolbox/index, and toolbox/watchlist all updated centrally to avoid concurrent-write conflicts.

[2026-05-03] ingest | Your Container Is Not a Sandbox: MicroVM Isolation in 2026 (emirb.github.io)

Ingested emirb.github.io/blog/microvm-2026 — Emir Beganović (Booking.com Staff SRE) writing post-KubeCon-EU-2026 on the microVM ecosystem and why agentic AI is becoming microVMs' "Docker moment." Framing line is Marina Moore's keynote: "Containers are not a security boundary. They are a mechanism to control resource usage." Article is a 25-minute industry survey — comparison tables, performance numbers, vendor pivots, a 50-year isolation timeline (chroot 1979 → AI agent sandboxes 2026), and twelve AI-sandbox platforms grouped by substrate. The structural argument worth keeping is the accidental-revolution thesis: microVMs hit production-ready 2018-2020 (Firecracker for Lambda, Cloud Hypervisor, Kata Containers, Fly.io running Firecracker since 2020) and waited. 2025 brought millions of daily Claude/GPT/Gemini/Codex sessions writing code that needed somewhere to run; the substrate was there, demand finally arrived. Hence "Docker moment" — same shape as namespaces+cgroups (2006-2008) waiting for Docker (2013) to create the demand that drove their adoption. Performance numbers that close the "VMs are slow" debate: ~125 ms boot (Firecracker NSDI'20), <5 MiB memory overhead, ~28 ms with snapshot-restore (Lambda SnapStart), 3% CPU overhead even with nested virt; Kubernetes pod scheduling alone takes 3-15 s by comparison. Firecracker (83K Rust LOC, "scalpel," no GPU/hotplug/nested) vs Cloud Hypervisor (106K Rust LOC, "Swiss Army knife," nested KVM since Dec 2025, VFIO/GPU passthrough, Windows guests) — decision rule: need /dev/kvm inside the VM, Windows, or hotplug? Cloud Hypervisor. Otherwise Firecracker. Cautionary tale: Fly.io spent months bolting GPU support onto Firecracker (hex-editing closed Nvidia binaries to convince them Cloud Hypervisor was QEMU) before scaling back. The Matryoshka model (containers nested inside VMs, 5 layers each trusting only the one below: host+KVM, VMM, guest VM, container runtime, untrusted code) is the emerging dominant pattern — already shipping at AWS Lambda (since 2018), Fly.io Sprites/Machines, Kata Containers ("matryoshka behind every kubectl apply"), E2B, Docker Sandboxes (Desktop 4.58, Jan 2026). The endgame thesis: "isolation becomes invisible infrastructure" — users keep writing Dockerfiles, every pod boots its own kernel underneath. The agent-bypassing-bubblewrap moment: Falco maintainer Leonardo Di Donato demonstrated Claude Code finding /proc/self/root/usr/bin/npx to evade deny patterns and disabling its own sandbox to complete a task. Article framing is the structural reason microVMs are different: container denylists/permissions/prompts live in the same reasoning layer as the agent; microVM hardware isolation is below that layer, "unreasonable for the agent to circumvent." 12 AI sandbox platforms surveyed: Firecracker-based (Fly.io Sprites, SlicerVM, AWS Bedrock AgentCore, E2B, Vercel Sandbox, Matchlock), other microVM/VM (Docker Sandboxes, Ona/ex-Gitpod, Daytona, Microsandbox, Northflank), non-VM (Modal/gVisor, Cloudflare Workers V8 isolates). rust-vmm is the load-bearing infrastructure under all of this — multi-vendor (AWS, Intel, Google, Microsoft, Red Hat, Alibaba, Linaro) shared Rust crates that got the new AI-sandbox vendors to "shipped in months, not years" because the hard substrate work was already done. Kubernetes integrations: Kata Containers (most mature, OCI-compatible runtime), Edera (Type-1 Xen-based hypervisor that recently added KVM after originally arguing against it), KubeVirt (full VMs as pods via CRDs, v1.8 March 2026 added Hypervisor Abstraction Layer for Cloud Hypervisor backend, powers SK Telecom's Petasus AI Cloud). Honest gVisor section: userspace Go reimplementation of ~274 Linux syscalls, 53/68 host syscall surface vs kernel's 450+; wins on startup (~50 ms), memory, GPU compatibility (nvproxy intercepts CUDA in memory-safe layer); microVMs win on compatibility ("it's just Linux"), nested virt, kernel features. Both keep thriving for different customer profiles. CVE table: 8 container-escape CVEs in 2024-2025 (Leaky Vessels CVE-2024-21626, Docker Desktop CVE-2025-9074, NVIDIAScape CVE-2025-23266 CVSS 9.0, runc masked-path/console CVEs, kernel packet socket UAF). MicroVM escape requires hypervisor CVEs which sell for $250K-$500K bounties because they're rare. Built three concept pages: microvm (architecture as portable concept), matryoshka-isolation (containers-inside-VMs pattern), rust-vmm (the shared crate ecosystem with multi-vendor governance). Updated sandboxing-ai-agents to reference microvm-2026 as canonical reference for Layer 1 microVM substrate, point at matryoshka-isolation as the dominant architecture, and add the new pages to Related. Created emir-beganovic-blog as a blog entity — author writes long-form (~25 min) industry surveys; "KubeCon-shaped" pieces likely to recur. Cross-references to superhq, hazmat, bubblewrap-dev-env, crabtrap, ceo-ai-psychosis, agentic-coding-fatigue, charlie-daemons, supply-chain-security. Pages created: microvm-2026 (summary), microvm (concept), matryoshka-isolation (concept), rust-vmm (entity), emir-beganovic-blog (blog entity). Pages updated: sandboxing-ai-agents (microvm/matryoshka cross-refs, bumped updated), index, log, ingested-urls.

[2026-05-03] ingest | Specsmaxxing (acai.sh blog)

Ingested acai.sh/blog/specsmaxxing — founder's-essay-shaped post from the (anonymous) developer of acai.sh on numbered acceptance-criteria IDs as the missing link between agent-written code and a stable spec. Recovery-from-overengineering arc: author entered "AI psychosis" mode (term borrowed from HandyAI's piece and applied self-critically), drafted elaborate PRDs/TRDs, recruited a subagent army, broke the "vibe-coding sound barrier" with a 1.5-hour unattended run — output worked but was sloppy. Self-diagnosis: "using AI to build AI harnesses for building products rather than just using AI to build the damn product." Pivot was a serendipity moment when a subagent unprompted started numbering requirements (AUTH-1, AUTH-2...) and referencing those tags in code comments (// AUTH-1). First reaction was the conventional "this is tight coupling, refactoring nightmare." Second-thought reframe is that the coupling is the point — the tags become a navigation index, a reviewer's checklist, an artifact pointing at exactly where in the codebase a requirement is satisfied or tested. The tags get a name: ACIDs (Acceptance Criteria IDs) — pulled out as a portable concept since the convention predates LLMs (aerospace ISO 26262, avionics DO-178C, medical IEC 62304 all enforce requirement-traceability) and the novelty in 2026 is that the cost of maintaining the traceability has collapsed because the agent does the bookkeeping. Toolkit is a feature.yaml format (components for functional reqs, constraints for cross-cutting eng invariants, hierarchical numbering with *-note siblings for cross-references, deprecated/replaced_by flags for in-spec history), TypeScript CLI distributed via npx @acai.sh/cli, and an Elixir/Phoenix/Postgres self-hostable server providing the dashboard + REST API. The strongest argument is the thought experiment in "Future Gazing": imagine code generation is instant, free, and deterministic on prompt input — if output is unsatisfactory you don't hand-edit, you extend the prompt; in that limit the only thing of lasting value is the acceptance criteria; the spec is what survives. Same shape as average-is-all-you-need (when an artifact becomes cheap, attention moves to the upstream artifact still authored by humans). Author sketches three-phase progression: specsmaxxing → testmaxxing (when generation outpaces reading speed, confidence-it-matches-spec is the bottleneck → QA/observability ROI explodes) → reactive software factories (LLM reacts autonomously to red tests/alerts; "every well-funded software team on earth is busy building their own bespoke solution"). Comparison-to-others section doubles as a future-ingest reading list: GitHub SpecKit ("vibe coding with extra steps"), OpenSpec (philosophical disagreement: "specs describe how systems should behave, not how they currently behave"), Kiro (converts .md → EARS, author dislikes both endpoints), Traycer.ai (uses plain .md). Honest tradeoffs called out: stable-numbering re-alignment cost, one-spec-per-feature discipline, no design/UI in specs, format lock-in once code references accumulate. Recovery-from-AI-psychosis framing is the second valuable thing — peer to Lalit's, Cantrill's, Bennett's takes from different angles. acai-sh org status: 3 repos (cli TS 10★ Apache-2.0 created 2026-03-22, server Elixir 3★ Apache-2.0 created 2026-02-27, docs Mintlify), single-author org, hosted dashboard at app.acai.sh "free forever maybe." Filed as toolbox + watchlist with re-check 2026-08-03 — ACID convention has legs independently, but the toolkit depends on the hosted dashboard for review and the business model is unclear. Cross-references to ceo-ai-psychosis (term borrowed), average-is-all-you-need (thought-experiment shape), building-syntaqlite-ai, peril-of-laziness-lost, no-silver-bullet-llms, cult-of-vibe-coding, ai-assisted-workflow, clean-code-coding-agents, i-dont-want-your-prs, charlie-daemons, botctl, superhq, flue (all stabs at the broader "reactive software factory" surface). Pages created: specsmaxxing (summary), acceptance-criteria-ids (concept), acai (toolbox + watchlist), acai-blog (blog entity). Pages updated: ceo-ai-psychosis (cross-ref + bumped updated), index, watchlist (acai row, bumped updated), index, log, ingested-urls.

[2026-05-03] ingest | library-skills (tiangolo/library-skills)

Ingested github.com/tiangolo/library-skills — Sebastián Ramírez's (FastAPI author) CLI for library-bundled agent skills. Library authors ship a .agents/skills/<name>/SKILL.md inside their published package (fastapi/.agents/skills/fastapi/SKILL.md, ending up at .venv/.../site-packages/fastapi/.agents/skills/fastapi/SKILL.md after install); uvx library-skills (or npx library-skills) scans pyproject.toml/package.json direct deps, scans the install env (.venv, node_modules, follows PEP 832), finds packages with bundled skills, asks which to install, and symlinks them into the project's .agents/ dir so library updates flow through to the skills automatically. --copy for systems without symlinks (Windows). --claude for Claude Code (which doesn't honor .agents/, only .claude/skills/). .agents/ is the cross-harness convention used by Codex, Cursor, GitHub Copilot, Pi, Antigravity, OpenCode per the docs. Both Python and TypeScript CLIs scan both environments — you don't need Node to consume Node-bundled skills. scan --json and list --json for agent feedback loops. Same Agent Skills format from agentskills.io — library-skills isn't a competing format, it's a distribution channel layered over the existing one. The structural argument worth keeping is the distributed-registry vs centralized-registry distinction: library-skills (this) bundles skills upstream so they version-sync with the library; npx skills add <repo> (impeccable, agent-skill-linter) is centralized-from-author-repos; cli-anything's CLI-Hub is centralized-from-shared-catalog. Each addresses a different version-skew/discovery problem; the three coexist. The symlink-not-copy choice is load-bearing — it's what makes "always up to date" hold. The headline tension with mcp-vs-skills: Mohl argues skills are knowledge, MCP is capability; library-bundled skills are the strongest possible knowledge case — knowledge ships with the artifact it describes, in lockstep. Open question is adoption: the convention only pays off if library authors actually ship skills. FastAPI itself adopting it would be the canary; as of this ingest no major library is publicly bundling. Tiangolo's track record matters here — FastAPI normalized type-hints-as-validation and auto-OpenAPI in Python; library-skills is the same playbook applied to AI tooling. Status: 363★ in ~1 week, MIT, dual Python/TypeScript implementations, mkdocs site at library-skills.io, CI/coverage/PyPI+npm releases — production-shaped from day one. Filed as regular toolbox (not watchlist) — tiangolo's bus factor is healthy and the project is shaped like an intended convention. Limitations: Python+Node only (no Go/Rust/etc), adoption-dependent, dangling-symlink cleanup behaviour undocumented, discovery filtered to direct deps by default. Cross-references to mcp-vs-skills, agent-skill-linter, impeccable, cli-anything, flue, features-to-steal-from-npmx. Pages created: library-skills (toolbox). Pages updated: index, log, ingested-urls.

[2026-05-03] ingest | Unsigned sizes: a five year mistake (c3-lang.org)

Ingested c3-lang.org/blog/unsigned-sizes-a-five-year-mistake/ — Christoffer Lerno's May 2026 post explaining why C3 0.8.0 ("szmageddon") flipped its default size type from unsigned to signed after 5 years on the unsigned default. Argument structure: the textbook unsigned bugs (for (uint x = 10; x >= 0; x--), if (a > b) with mixed signedness, (foo + a) % 2 flipping when foo > INT_MAX) all descend from one earlier decision — C standardizing sizeof as size_t. That single change introduced unsigned arithmetic as a common thing in C and propagated into every successor that copied C's size convention, including Zig and Rust. The decision is load-bearing because unsigned sizes mean unsigned indexing means unsigned arithmetic everywhere, which forces the language into either implicit signed↔unsigned conversion (silent bugs) or pervasive as usize cast spam (Rust experience). C3 took the minimize-casts side with int + uint → int promotion, which worked for 5 years until / and % exposed that the convenience hid which subexpression was unsigned. The unfixable case is the ring-buffer wrap: ((start - offset_back) % length + length) % length is the natural unsigned form of negative-offset wrap and it's silently wrong; the correct unsigned form (start + length - (offset_back % length)) % length is uglier and no compiler can flag the broken one. Range argument doesn't hold up — signed overflow gives invalid-looking negatives, unsigned overflow gives plausible-looking positives that pass casual testing; on 64-bit, memory exhausts before 2^63; verification frameworks treat unsigned as "wraps modulo 2^N" not "in [0, N)", so the precondition encoding is informal anyway. Java dropped unsigned types entirely in the 90s ("perhaps a little extreme" but it eliminated the bug class); Go, designed by people who knew C++'s pain firsthand, picked signed sizes — strongest counterexample. C3's changes: isz/usz renamed to sz/usz (asymmetric pair signaling preference), implicit signed↔unsigned conversion dropped, mixed comparisons dropped. The non-technical takeaway worth keeping: Lerno had internalized the cost of unsigned-everywhere — after enough years in C/C++ you stop seeing the cognitive overhead, you just pay it; the change felt "wrong, as if I was doing something forbidden" before the evidence stacked up. Same shape as peril-of-laziness-lost: discipline that compensates for a tool's defect becomes invisible. Created C3 as an entity (first mention; Lerno's design-rationale blog likely to surface again — willing to publish "this default was wrong" posts is unusual) and signed-vs-unsigned-sizes as a concept since the question is broader than C3 (Java/Go/Rust/Zig/C++ all picked sides). Cross-referenced from zig (Zig kept unsigned usize; the post explicitly groups it with the languages that made the mistake). Pages created: unsigned-sizes-c3-mistake (summary), c3-lang (entity + blog), signed-vs-unsigned-sizes (concept). Pages updated: zig (cross-ref), index, log, ingested-urls.

[2026-05-03] ingest | CLI-Anything (HKUDS/CLI-Anything) — generate per-app Click CLI + SKILL.md

Ingested github.com/HKUDS/CLI-Anything — Hong Kong University DS lab's Claude Code plugin (with parallel installs for Pi / OpenClaw / OpenCode / Codex / Goose / Qodercli / GitHub Copilot CLI) that takes a path or GitHub URL of a GUI app and emits a complete Python Click CLI + canonical skills/cli-anything-<software>/SKILL.md via a 7-phase pipeline (analyze → architect → implement → test plan → tests → docs → publish). Headline framing: "Today's software serves humans. Tomorrow's users will be agents." The single load-bearing methodology doc is cli-anything-plugin/HARNESS.md — every harness integration loads it; that's how a Claude Code plugin, an OpenCode commands/ markdown set, an OpenClaw SKILL.md, and a Codex skill all run the same SOP. Phase 6.5 generates SKILL.md from Click decorators + setup.py + README via skill_generator.py; the monorepo is consumable directly via npx skills add HKUDS/CLI-Anything --skill <name>. The interesting philosophy claim is no graceful degradation — generated CLIs call the real backend (bpy for Blender, melt for Shotcut/Kdenlive, sox for Audacity, headless LO for LibreOffice) and tests must invoke the actual software (no skip-if-missing) — so "we exercise the real backend" is enforced by CI rather than asserted in copy. Each generated CLI ships dual --json / human output, a stateful REPL via shared repl_skin.py with invoke_without_command=True so cli-anything-gimp with no args drops into the REPL, file-locked JSON session state, and _resolve_cli helpers so subprocess tests against the installed command degrade to python -m in dev. CLI-Hub is the runtime catalog (pip install cli-anything-hub) backed by public_registry.json plus a separately-installed meta-skill that points at a live Digital Ocean–hosted catalog SKILL.md — agents read the meta-skill, pick whichever CLI fits the task, install it themselves, then read that CLI's own SKILL.md. Auto-updates whenever registry.json changes; new community CLIs appear without re-publishing the meta-skill. This is exactly the mcp-vs-skills hybrid pattern made concrete: the CLI is the capability (real backend, JSON output, auth), the SKILL.md is the knowledge (parameter gotchas, output format) — generated together at Phase 6.5 rather than authored separately. Doesn't refute Mohl's argument; it's a worked instance, with the constraint that "service" is a local subprocess so portability across compute-less environments (mobile Claude / web ChatGPT) doesn't apply — only compute-equipped harnesses (flue, Claude Code, Pi, pi-coding-agent, OpenClaw, Codex) can drive these. Coverage claim is 18 demo apps with 2,269 passing tests as of April–May 2026 — GIMP (107), Blender (208), Inkscape (202), Audacity (161), LibreOffice (158), OBS (153), Kdenlive (155), Shotcut (154), FreeCAD (258 commands), QGIS, Godot, Krita, Draw.io, Mermaid, Excalidraw, RenderDoc, MuseScore, Zotero, Obsidian, n8n, WireMock, Exa, VideoCaptioner, ComfyUI, SD WebUI, AnythingLLM, Slay the Spire II. Demos use a preview + preview live + trajectory.json triplet so trajectory replay is in the harness shape, not bolted on (FreeCAD building a Curiosity rover, Blender building an orbital relay drone). Limitations: Python ≥3.10 + Click only (no Go/Rust/Node harnesses), requires the target software pre-installed (the find_<software> helpers raise with install instructions but don't run apt/brew themselves), generated quality tracks codebase legibility (apps without a clean library/API split fail at Phase 1), Windows is best-effort with cygpath/WSL workarounds. Repo: 33,258★, Apache-2.0, created 2026-03-08, last push 2026-05-02, HKUDS lab (multi-author, the LightRAG team), active external-contributor flow (CLIs merged from @TianyuFan0504, @WEIFENG2333, @zhangxilong-43, others). Filed as regular toolbox (not watchlist) — 33k stars, multi-author lab backing, 18 working demos, no single-vendor risk. Cross-references to mcp-vs-skills, flue, pi-coding-agent, impeccable, agent-skill-linter, agents-vs-daemons. Pages created: cli-anything (toolbox). Pages updated: index, log, ingested-urls.

[2026-05-03] ingest | Flue (withastro/flue) — agent harness framework

Ingested github.com/withastro/flue + flueframework.com — withastro's "Agent Harness Framework," a TypeScript runtime that takes the Claude Code architecture (markdown skills, AGENTS.md, sandbox, tools, sessions) and ships it as a programmable headless library. Framing on the homepage: "Not another SDK. Build powerful, autonomous agents with Flue's programmable TypeScript harness… Stop renting someone else's agent." README adds the framework framing: "think Astro or Next.js, but for agents — write once, build, and deploy anywhere" (Node.js / Cloudflare Workers + Durable Objects / GitHub Actions / GitLab CI). The load-bearing technical bet is virtual sandbox by default via just-bash (vercel-labs in-process bash interpreter with pluggable in-memory FS) — inverse of every other entry in sandboxing-ai-agents (bubblewrap namespaces, hazmat seatbelt, superhq microVM): for most agents the sandbox doesn't need a real OS, just a Bash-shaped JS object, so default to that and only spin up a Daytona container or sandbox: 'local' when you need git clone + npm install. Cloudflare integration sells it — getVirtualSandbox(env.KNOWLEDGE_BASE) mounts an R2 bucket as the agent's / and the agent searches it with grep/glob/read tools without booting a container; at Workers pricing that's the only way "support agent per customer per request" pencils out. Three sandbox modes (virtual / 'local' / Daytona container). Markdown-driven (AGENTS.md + .agents/skills/ — same convention as Claude Code, mcp-vs-skills, impeccable, agent-skill-linter); skills referenced by frontmatter name: or relative path. Session API is small: prompt() (typed result via valibot), skill(), task() (one-shot detached subagent sharing parent sandbox; same task tool exposed to LLM for self-delegation), shell(). Per-call command scoping with defineCommand('gh', { env: { GH_TOKEN: ... } }) so the secret stays in host env and the agent gets a gh binary it can run but never reads the token — same instinct as superhq's auth gateway, applied to per-tool scope. Roles at agent/session/call level with call > session > agent precedence, applied as call-scoped system prompt overlays not persisted into message history (a meaningful design choice — most subagent implementations get this wrong). HTTP routing via /agents/<name>/<id> where <id> is the conversation key. Cloudflare sessions backed by Durable Objects, Node sessions in-memory by default. Remote MCP via connectMcpServer() (streamable HTTP default, SSE optional); explicitly does NOT auto-detect transports, spawn local stdio servers, or handle OAuth — production-shaped not dev-laptop-shaped. Triggers: webhook: true for HTTP, {} for CLI-only via flue run. CLI: flue dev (port 3583 = "FLUE" on phone keypad), flue run, flue build. Repo: 1,800★, 91 forks, 8 open issues, created 2026-02-07, last push 2026-05-03, Apache-2.0; README opens with "Experimental — APIs may change," v0.0.x on its own branch. Homepage explicitly names Dosu / Greptile / CodeRabbit as the off-the-shelf vendors it replaces. Filed as regular toolbox (not watchlist) — withastro org backing makes bus-factor "as healthy as Astro itself." Cross-references to adk-go, botctl, charlie-daemons, gomodel, crabtrap, sandboxing-ai-agents, bubblewrap-dev-env, hazmat, superhq, mcp-vs-skills. Pages created: flue (toolbox). Pages updated: index, log, ingested-urls.

[2026-05-03] ingest | Adding author context to RSS (Coywolf / bylinespec.org)

Ingested coywolf.com/notes/adding-author-context-to-rss/ — Jon Henshaw's May 2 note covering Terry Godier's Byline spec proposal: a new XML namespace (https://bylinespec.org/1.0) that adds structured author context to RSS / Atom / JSON Feed. Authors are defined once at the channel level inside <byline:contributors> as <byline:person id="…"> with name, URL, avatar, profile links keyed by rel (mastodon, github, …), IndieWeb-style <byline:now> and <byline:uses> pointers, and a <byline:theme color accent style> block for reader-side visual hints. Items reference a person via <byline:author ref="…"/> and tag themselves with <byline:perspective> from a controlled vocabulary (personal, news, review, satire, official, sponsored). Bio is <byline:context>, capped at 280 chars. Spec frames the gap as "the context problem" — RSS readers pulling personal blogs, journalism, corporate posts, and satire into the same timeline render them identically, and existing <author> / <atom:author> carry name/email/uri at most. Design principles called out: progressive enhancement, decentralised identity (URIs and IndieWeb conventions, no central registry), format-agnostic, privacy-respecting. CC0 1.0, validator + generator on the site, expected to be accepted by end of 2026. The interesting structural detail is that the spec is coming from a reader-app developer (Godier ships Sourcefeed and Current) rather than a publisher coalition — same shape as how <podcast:*> extensions arrived. Decentralised identity is the key political choice (no DID layer, no namespace authority — your domain is your identity, like rel="me"); controlled-vocabulary perspective is the load-bearing part for reader behaviour and the most likely push-back surface. No prior RSS/Atom/IndieWeb pages in the vault; created a fresh blog entity for Coywolf since Henshaw is likely to surface more indie-web spec coverage. Pages created: coywolf-byline-rss (summary), byline-spec (concept), coywolf-blog (blog entity). Pages updated: index, log, ingested-urls.

[2026-05-02] ingest | OpenWarp (zerx-lab/warp) + agent-skill-linter (William-Yeh)

Two-tool batch on 2026-05-02. (1) OpenWarp — community fork of Warp on the openWarp branch of zerx-lab/warp, layering BYOP custom AI providers on top of the upstream codebase while keeping blocks/AI commands/workflows/keymaps and continuously merging from warpdotdev/warp. The interesting technical bits are the genai Rust adapter exposing 6 native API protocols (OpenAI, OpenAI Responses, Anthropic, Gemini, Ollama, DeepSeek) rather than the usual OpenAI-compat shim — concretely, that buys multi-turn reasoning passthrough for DeepSeek reasoning_content, Claude thinking, and Gemini reasoning blocks, instead of flattening reasoning models down to plain chat completions. System prompts are minijinja templates rendered per-call from cwd/locale/role, the same context-engineering instinct as a Cursor rules file but baked into terminal config. Cloud Agent / Computer Use are explicitly disabled by default; credentials live only in ~/.config/openwarp.toml with no relay. AGPL-3.0 / MIT dual license, mirroring upstream Warp. Repo is 3 days old (created 2026-04-29), 422 stars on launch momentum, 23 forks, no public release binaries, must cargo build --release from source — site banner says "Early development — no public release yet." Single-vendor (zerx-lab is a 2024 GitHub user with no other notable repos). Filed as toolbox + watchlist with re-check 2026-08-02 — the genai-protocol layer is genuinely better than a shim, but bus factor is one and the "continuously merging upstream" promise is unproven against Warp's release cadence. Cross-references to gpu-accelerated-terminal, terminal-gpu-battery-cost, gomodel, mcp-vs-skills, deepseek. Distinct from the unrelated runs-on/warp CI tool. (2) agent-skill-linter — Python linter that gates whether an agent-skill repo is ready to publish on agentskills.io. Targets cross-harness skills that work across Claude Code / Cursor / Gemini CLI / Amp / Roo Code / Copilot. ~21 rules across spec compliance (SKILL.md via skills-ref), licensing (Apache-2.0/MIT + current year), README badges + sections, CI workflow presence, repo structure, and Python-specific quality (uv invocation patterns, PEP 723 inline deps, SKILL.md under 500 lines for context-window discipline). Severity tiers Error / Warning / Info, fixable subset has --fix, JSON output exists for agent feedback loops. Install via npx skills add William-Yeh/agent-skill-linter (same cross-harness convention as impeccable) or copy the skill/ directory into ~/.claude/skills/. Three months old (created 2026-02-12), 2 stars, single author, 4 releases up to v0.11.0, Apache-2.0. Filed as toolbox + watchlist with re-check 2026-08-02 — the deterministic-lint-for-publish-readiness argument is the same one impeccable's detector half makes (an LLM scoring an LLM's output shares training-data bias), but star count is an ecosystem-size signal and the deeper rules are Python-only. Pages created: openwarp, agent-skill-linter. Pages updated: index, watchlist, log, ingested-urls.

[2026-05-02] ingest | peon-ping (peonping.com)

Ingested peonping.com — audio notifications for AI coding agents using Warcraft III Peon voice lines ("Work, work.", "Something need doing?", "Job's done."). Hooks fire on the agent's existing event surface — greeting on session start, acknowledge on tool call, complete on stop, error on failure, annoyed on repeated permission prompts. Adapters listed for Claude Code, Codex, Cursor, OpenCode, Kiro, Windsurf, Antigravity, Rovo Dev CLI, and "any IDE with hooks." MCP-server mode is the more interesting integration — agent calls play_sound itself and picks the line based on what it just did, making sound part of agent reasoning rather than passive notification. 160+ sound packs across 14 languages with a homepage live-install-builder. Other features: volume 0.0–1.0 in config, no-repeat tracking per category, individual category toggles, terminal tab title with project name + status dot, desktop notifications when terminal isn't focused. The 2.0 feature is Peon Trainer — a workout-nag mode reusing the same hook surface for 300 pushups + 300 squats/day with session-start reminders, a /peon-ping-log 25 pushups Claude Code slash skill, ~20-minute periodic reminders that escalate if you slack, and a celebration on hitting daily total. Separate repo for peon-pet (Electron + Three.js, macOS) — animated desktop orc that reacts to Claude Code events, session dots for every active Claude Code window. Site claims peon-ping inspired VS Code's native sound hooks for its 50M+ users; links Pierce Boggan's X post as evidence. Position in the AI-tooling space is interesting — most agent-hook tooling pushes toward autonomy (charlie-daemons, botctl) while peon-ping leans into the human-supervisor model and just makes supervision less exhausting. Connects to the agents-vs-daemons distinction (squarely on the human-initiated side). Character-voice framing matters — distinctive but short, multiple lines per category so the brain doesn't tune them out. Repo created 2026-02-09 (~3 months old), 4.6k stars, MIT, Shell primary, active. Filed as regular toolbox (not watchlist — established with multi-IDE support and 4.6k stars). Pages created: peon-ping (toolbox). Pages updated: index, log, ingested-urls.

[2026-05-02] ingest | bluetui (HelpFreedom/TUI_bluetooth)

Ingested github.com/HelpFreedom/TUI_bluetooth — Python TUI Bluetooth manager for Linux on top of BlueZ via system D-Bus (no sudo, PolicyKit handles auth). Built on Textual + dbus-next. Standard pieces are utility — device list grouped by status (connected/paired/nearby) with RSSI bars and battery, pair/forget/trust/block/scan/power-toggle on single keys, AVRCP media control, auto-routing system audio to BT headphones via pactl on PulseAudio + PipeWire. The distinctive feature is a real Bluetooth HID remote for Smart TVs: registers org.bluez.Profile1 with UUID 0x1124 (HID), builds an SDP record with a Consumer Control (Report ID 1) + Keyboard (Report ID 2) HID descriptor, opens raw L2CAP sockets on PSM 17 (Control) and PSM 19 (Interrupt) via socket.AF_BLUETOOTH + BTPROTO_L2CAP, agent switches to NoInputNoOutput so JustWorks pairing goes through, post-connect force-disconnects A2DP/AVRCP/HSP profiles so TV audio doesn't leak into the laptop's speakers. Tested on TCL Android TV; should work on Samsung/LG/Sony BT-HID-host sets. Unlike Android TV Remote v2 (WiFi) or IR-blaster solutions, the laptop genuinely impersonates an OEM Bluetooth remote. Architecture is one module per BlueZ surface (bluez.py, agent.py, audio.py, classic_hid.py, hid_remote.py for legacy BLE-HID-over-GATT). Repo is brand new — created 2026-05-01 (one day before this page), zero stars, single author, Russian-only README, no tagged releases, packaging is informal (pip3 install --user -r requirements.txt + a shell wrapper, no PyPI). README has a small inconsistency where the install URL says bluetui.git but the actual repo name is TUI_bluetooth. Added to watchlist with re-check 2026-08-02 — the HID-remote work is genuinely unusual, but everything else (packaging, multi-author, English docs, TV compatibility breadth) is unproven. No prior pages on Bluetooth/BlueZ/HID/Textual in the vault. Pages created: bluetui (toolbox). Pages updated: index, watchlist, log, ingested-urls.

[2026-05-02] ingest | Meetily (Zackriya-Solutions/meetily)

Ingested github.com/Zackriya-Solutions/meetily — privacy-first AI meeting assistant that runs the full pipeline locally. Single Tauri app: Rust backend, Next.js frontend, ships installers on macOS aarch64 and Windows x64, builds from source on Linux. Real-time transcription via Whisper (whisper.cpp) or NVIDIA Parakeet (via transcribe-rs + istupakov's ONNX conversion). Audio capture handles mic + system audio simultaneously with ducking and clipping prevention; some code borrowed from Screenpipe. Summaries default to Ollama (local) but accept Claude / Groq / OpenRouter / any OpenAI-compatible endpoint. GPU acceleration wired up at build time across Metal+CoreML / CUDA / Vulkan with no user config. The CE/PRO split is unusually explicit — Community Edition stays at "transcribe + summarize" forever free & MIT, while PRO is a separate proprietary codebase reserving the high-margin features (custom summary templates, PDF/DOCX export, auto-detect-and-join, calendar integration, GDPR audit trails, speaker diarization "coming soon"). Repo created 2024-12-26 by Zackriya Solutions, 11.5k stars, last push 2026-03-16, MIT, Rust primary. Closest existing toolbox entry is ghost-pepper (local Whisper-based STT for macOS, hold-to-talk dictation rather than meeting capture); the broader local-vs-cloud-LLM argument lives in titit-local-ai — meetily is a worked example of that thesis applied to the meeting-assistant category that's normally Otter / Fireflies / Granola territory. Added as a regular toolbox entry, not watchlist — established with multi-platform support and 11.5k stars. Pages created: meetily (toolbox). Pages updated: index, log, ingested-urls.

[2026-05-02] ingest | Retro Catalog (retrocatalog.com)

Ingested retrocatalog.com — Jipsony's single-author database of retro gaming handhelds and emulator-target games. Tracks 256 released devices (Anbernic, Miyoo, Retroid, KT Pocket, AYANEO, GAMEMT, MagicX, AYN, Zotac, Valve), 6 upcoming, 55 staff picks, and 20,579 games as of May 2026. Each handheld lists screen aspect ratio, size, and emulation tier (highest console it can comfortably run — PS2/Wii/PSP/NDS/Modern/Saturn). Key differentiator from a raw spec list is the buyer's-guide framing — front page leads with opinionated picks ("Best in 2026", "Best Under $70", "Best Under $200", "Best for PS2", "Best for GBA") rather than a search box, answering "what should I buy?" rather than "what exists?". Data aggregated from u/timeisart's canonical Handhelds spreadsheet, retrohandhelds.gg (site/Discord/YouTube), forthenext's testing videos, and Retro Dodo's reviews. Featured games rail driven by r/SBCGaming Game-of-the-Month polls. Explicit anti-piracy stance in the footer — points at devices and games, but sourcing ROMs is the reader's problem. Lands as an entity (similar shape to gtfobins: curated catalog with editorial weight) rather than toolbox/blog. Cross-references thin in vault — closest are ps5-linux-loadr (adjacent retro-gaming hardware story) and sdl3-dos-port (cross-platform support for retro targets). Pages created: retrocatalog (entity). Pages updated: index, log, ingested-urls.

[2026-05-02] ingest | I Do Not Recommend Bitwarden (マリウス.com)

Ingested マリウス.com/i-do-not-recommend-bitwarden/ — Marius's followup to his 2022 OpenBSD self-hosted vaultwarden guide, walking back the recommendation after several years of use. Argument structure is four-part: (1) Investor capture — PSG's $100M growth investment in 2022 as the inflection toward investor-aligned product decisions; the late-2024 @bitwarden/sdk-internal shipping with a non-FOSS clause forbidding non-Bitwarden use, walked back to GPLv3 after Phoronix coverage and called a "packaging bug." (2) Architectural mismatch — official server is .NET / C# / MSSQL Express; vaultwarden (Rust, dani-garcia) has ~3× the GitHub stars and runs on a Pi; Bitwarden hired Vaultwarden's main dev but built a separate "Bitwarden lite" stack (still .NET, ~3× the RAM) instead of adopting upstream. (3) Client paper-cuts — vault import broken with bug reports redirected to dead-end community threads; no "move items between vaults" feature ten years in (workaround is exporting to unencrypted JSON, editing, re-importing — drops attachments, trash, password history, timestamps); F-Droid auto-update locked Marius out of his vault while traveling because of breaking client/backend protocol changes; persistent UX issues (sync-on-unlock with no toggle, list items that open instead of fill, Wayland Flatpak issues, 2024 Android .NET-MAUI→Kotlin rewrite still throwing regressions in quarterly releases); CLI is a Node.js/TypeScript program where bw list outputs every credential by default with no opt-in flag. (4) Five-incident security pattern — 2023 KDF flaw (Wladimir Palant, server iterations only on login hash, defaults below OWASP, fix only for new accounts), 2023 Windows Hello bypass CVE-2023-27706 (DPAPI vault key extractable without master password), 2023 cross-origin iframe autofill CVE-2023-27974, 2025 DOM-clickjacking (Marek Tóth — patched on the embargo expiration date four months after disclosure), and the headline 2026 Shai-Hulud / Checkmarx supply-chain attack on @bitwarden/cli 2026.4.0 (compromised CI/CD GitHub Action, bw1.js payload, Bun runtime decrypting the Shai-Hulud worm, harvesting GitHub/npm tokens, SSH keys, AWS/GCP/Azure creds, MCP configs, exfil via auto-created public repos on victim GitHub accounts; 19 hours live, 334 developers affected). The npm distribution channel for a security-critical CLI is what made the supply-chain incident shaped this way — single-static-binary distribution (Go/Rust) doesn't have the same blast radius. The "way forward" section is a divide-and-conquer credential split (groups A-E: client work via SaaS PM, PII accounts via separate cloud PM, non-PII via KeePass+Syncthing, infra via HashiCorp Vault, one-off CLI secrets via pass) — extracted as the credential-compartmentalization concept. Marius blog now has two ingested articles (hold-on-to-your-hardware and this one), so created the blog entity. Updated supply-chain-security with the Shai-Hulud / Bitwarden incident under a new "Notable incidents" section. Pages created: marius-bitwarden-not-recommended (summary), marius-blog (blog entity), bitwarden (entity), vaultwarden (entity), credential-compartmentalization (concept). Pages updated: supply-chain-security (Shai-Hulud incident, sources, updated date), hold-on-to-your-hardware (linked to marius-blog), index, log, ingested-urls.

[2026-05-02] ingest | Agentic Coding is Burning Me Out (0xsid)

Ingested 0xsid's May 2026 post on decision fatigue from agent supervision — gacha-loop psychology, broken pacing, 4-5 hour daily ceiling, verifier-of-the-verifier regress. Pages created: agentic-coding-fatigue (summary), 0xsid-blog (blog entity). Cross-referenced peril-of-laziness-lost, cult-of-vibe-coding, building-syntaqlite-ai.

[2026-05-10] ingest | NYT — Meta's A.I. Employees Are Miserable

NYT blocked direct fetch; reconstructed from Threads/CNBC/eWEEK/Fortune/TNW corroborating coverage. Pages created: meta-ai-employees-miserable (summary), meta-platforms (entity), alexandr-wang (entity). Cross-referenced with ai-bubble-pale-horses, ceo-ai-psychosis, subprime-ai-crisis.

[2026-05-10] ingest | Beaver Triples (Stoffel Labs)

Stoffel's restaurant-night walkthrough of Beaver triples for secure multiplication without raising the reconstruction threshold. Pages created: mpc-beaver-triples (summary), secret-sharing (concept), secure-multiparty-computation (concept), beaver-triples (concept), stoffel-mpc (entity).

[2026-05-10] ingest | Programming as Theory Building (CodeUtopia)

Hartikainen's recommendation of Naur's 1985 essay: programming as building a shared mental theory; code, docs, tests are projections. Pages created: programming-as-theory-building-codeutopia (summary), programming-as-theory-building (concept), codeutopia-blog (entity). Cross-referenced no-silver-bullet-llms, clean-code-coding-agents, mean-free-path-language, building-syntaqlite-ai.

[2026-05-10] ingest | routing.run

Per-request-priced LLM API gateway with fallback chains and zero-prompt-logging claim. Pages created: routing-run, llm-api-routing-layer (concept). On watchlist — license unclarified, no track record.

[2026-05-10] ingest | Yggdrasil as an Embedded Go Library (asciimoth)

asciimoth's tutorial on embedding Yggdrasil mesh networking via their fork: ygglib, VTun, transports, autopeering, no daemon. Pages created: yggdrasil-embedded-go (summary), yggdrasil-network (concept), asciimoth-ygg (entity). Cross-referenced domain-fronting, bypassing-dpi-with-ebpf, serverless-relay-transport.

[2026-05-10] ingest | re_gent (regent-vcs)

Git-shaped VCS for AI agent activity: per-tool-call Steps with workspace + transcript + tool args, BLAKE3 + SQLite, blame-by-prompt. Pages created: re_gent. On watchlist — pre-v1.0, Claude-Code-only.

[2026-05-10] ingest | Since You Arrived Vol. IV (Rise Up Labs)

Web art piece by Matt W. — four-volume browser piece using time-on-page to populate "what happened elsewhere." Page created: since-you-arrived-vol4 (summary, small). Cross-referenced paper-computer.

[2026-05-10] ingest | The Sync Bound Nobody Asked For (verrchu)

Rust deep-dive on why &self async trait methods returning Send futures silently demand Self: Sync, and why &mut self quietly fixes it. Pages created: rust-async-trait-sync-bound (summary), rust-send-sync (concept), verrchu-blog (entity).

[2026-05-10] ingest | I Want Local Models to Work (Armin Ronacher)

Ronacher on local-LLM UX gaps: missing tool-streaming, stack fragmentation, no critical mass; pi-ds4 / ds4.c bet. Pages created: lucumr-local-models (summary), lucumr-blog (entity). Cross-referenced titit-local-ai, deepseek, hold-on-to-your-hardware, deepseek-v4-roleplay-instruct.

[2026-05-10] ingest | The Agent Principal-Agent Problem (Crawshaw)

Crawshaw on how agents broke code review by collapsing the contributor effort signal; small high-trust teams escape, BigCo dead-end. Pages created: agent-principal-agent-problem (summary), code-review-principal-agent (concept), crawshaw-blog (entity). Cross-referenced skill-atrophy-supervision-paradox (added entry), i-dont-want-your-prs, no-silver-bullet-llms, agentic-coding-fatigue, contributor-poker.

[2026-05-10] ingest | Revisiting PQ-WireGuard (Hashimoto, Katsumata, Niot, Wiggers — IACR 2025/1758)

PQ-WireGuard redesign with new RKEM primitive (Rebar); 190–390× server PK memory reduction; fixes UKS attack and PSK-handling bug in prior model. Pages created: pq-wireguard-revisited (summary), pq-wireguard (concept), reinforcing-kem (concept). Cross-referenced crqc-timeline (added 2026-05-10 update note), ml-kem, post-quantum-cryptography, store-now-decrypt-later.

[2026-05-10] ingest | A Tale of Two Worlds — Hybrid-WireGuard (Lafourcade et al. — USENIX Security 2025)

Formal SAPIC+ analysis of PQ-WireGuard, fix (PQ-WireGuard⋆), Hybrid-WireGuard construction, Rust implementation. Pages created: hybrid-wireguard (summary). Cross-referenced pq-wireguard, pq-wireguard-revisited (concurrent independent work).

[2026-05-12] ingest | Floci — free local AWS emulator (floci-io/floci)

MIT-licensed drop-in replacement for LocalStack Community after its March 2026 auth-token sunset. 46 AWS services on port 4566; real Docker containers for Lambda/ElastiCache/RDS/MSK/EC2/ECS/EKS/CodeBuild/OpenSearch/ECR with real SigV4/IAM auth; DuckDB-sidecar Athena; 4 storage modes; auto-translates LocalStack env vars. Pages created: floci. Updated: index, watchlist (added row, next check 2026-08-10).

[2026-05-13] ingest | Local LLMs on 16 GB VRAM — Gemma 4 vs Qwen 3.6 vs Qwen Coder (Habr)

Vyacheslav (Habr 1033808) tests three MoE models on RTX 5070 Ti 16 GB via OpenCode + llama.cpp. Gemma 4 26B-A4B wins 12/12 in Fast mode; Thinking mode hurts rule-following across all three; Qwen models fail long agentic sessions; --n-cpu-moe gives +55-60% on Qwen; switching KV cache to q4_0 fits 256K context on 16 GB. Pages created: local-llm-16gb-vram-tests (summary), mixture-of-experts (concept), llm-quantization (concept), thinking-mode-rule-erosion (concept), moe-cpu-offload (concept), kv-cache-sizing (concept), llama-cpp (toolbox), opencode (toolbox). Cross-referenced lucumr-local-models, titit-local-ai, hold-on-to-your-hardware, deepseek, deepseek-v4-roleplay-instruct, gemma-gem.

[2026-05-13] ingest | Porto SAP (Mahmoud Zalt)

Architectural pattern repo at github.com/Mahmoudz/Porto (MIT, 1.6k★). PHP/Laravel-oriented; two-layer split (Containers per domain area + Ship for shared infrastructure), Actions orchestrating single-run() Tasks, everything-has-its-own-class-in-a-predictable-folder. Apiato is the Laravel framework that implements it. Current README leads with the AI-friendliness pitch (small named classes = cheaper agent navigation). Pages created: porto-sap (concept), porto-readme source. Cross-references: clean-code-coding-agents, programming-as-theory-building, no-silver-bullet.

[2026-05-13] ingest | Local LLM batch — Reddit Qwen3.6+MTP, little-coder, IKP, TurboQuant, Habr quantization deep-dive

Five sources covering local-LLM optimization, scaffold-model fit, and parameter-count estimation from black-box APIs. Pages created: reddit-qwen3-6-mtp-12gb (summary), little-coder-scaffold-model-fit (summary), incompressible-knowledge-probes (summary), interactive-turboquant (summary), habr-local-llm-quantization-deep-dive (summary), speculative-decoding (concept), scaffold-model-fit (concept), factual-capacity-scaling (concept), random-rotation-quantization (concept), reap-expert-pruning (concept), bf16-vs-fp16 (concept), unsloth (entity), pine-ai (entity), itayinbarr-blog (entity), arkaung-blog (entity), ik-llama-cpp (toolbox). Pages updated: mixture-of-experts (IKP total-vs-active params finding), llm-quantization (KLD vs perplexity reconciliation, IQK quants, TurboQuant, why I-quants slow CPU), moe-cpu-offload (full -fit/-fitt/-cmoe/-ncmoe family, Ollama gap), kv-cache-sizing (TurboQuant route past q4_0), thinking-mode-rule-erosion (IKP thinking-mode evidence; Opus 4.7 thinking < base), local-llm-16gb-vram-tests (cross-refs to all new sources), llama-cpp (-fit, speculative-decoding flags, turbo4 KV).

[2026-05-22] ingest | Kenn Software local-first agent tooling — kata, middleman, agentsview, msgvault, roborev

Five single-binary local-first Go tools from Kenn Software (kenn.io, "development and knowledge systems for the agentic era"; not Wes McKinney — the wesm install path in one fetch was a hallucination, verified via gh). Shared DNA: SQLite substrate, 127.0.0.1-only, no telemetry/accounts, agent CLI + human TUI, Go 1.25/1.26, MIT. Pages created: kenn-software-suite (overview), kata (toolbox, watchlist), middleman (toolbox), agentsview (toolbox), msgvault (toolbox, watchlist), roborev (toolbox). Pages updated: beads (kata comparison), forge (middleman cross-ref + Related section), wiki/index.md (Overviews), toolbox/index.md (5 entries), toolbox/watchlist.md (kata + msgvault rows, next check 2026-08-22). Verified metadata via gh: kata 210★/no release, middleman 110★/no release, agentsview 1.1k★/v0.29, msgvault 1.8k★/v0.14 alpha, roborev 1.2k★/v0.55.