Llms

John Gruber takes apart Anthropic’s plan to apply semantic watermarking to all Claude-generated text globally. The technique — based on Google’s SynthID-Text — works by subtly biasing token selection toward “green list” words at each generation step, creating a statistically detectable fingerprint. It applies to every Claude output over ~150 words, including private conversations and proofreading. Gruber’s objection is not technical but philosophical: No two synonyms carry the exact same meaning. A system that occasionally swaps banana for pineapple to leave a fingerprint is deciding, without the user’s consent, that word precision is optional The watermark is easily defeated by paraphrasing (tools like Declaude already exist), so it punishes honest users while motivated bad actors bypass it Detection requires a secret key held only by Anthropic — users cannot verify whether their own text is marked, creating an asymmetric power dynamic Google’s claim of “no statistically significant difference” in thumbs-up rates is dismissed: users don’t thumbs-down subtly wrong word choices, and Gemini’s baseline quality may already mask the degradation The regulation driving this (EU Code of Practice on Transparency of AI-Generated Content) is itself impractical — it requires providers to forbid users from rephrasing output, which is literally unenforceable. Anthropic applies it globally, claiming it cannot scope to the EU, despite being weeks away from a $2T IPO. ...

Simon Willison tests Qwen 3.8 27B — a new Apache 2 licensed 27B-parameter vision model from Alibaba’s Qwen lab that fits in a 17GB GGUF file and runs on consumer hardware. The model is genuinely impressive, but its default configuration is actively harmful. The problem: Qwen ships with reasoning effort set to xhigh. This turns trivial requests into epics: A “pelican riding a bicycle” SVG took 21 minutes and 22K reasoning tokens (vs 137 seconds with reasoning off) “Draw an SVG of a circle” produced an elaborate animated geometric study with concentric rings, tick marks, and a Bauhaus palette — beautiful, but entirely not what was asked When building a bounding box visualization tool, the model spent reasoning tokens deciding to draw its own pelican demo scene because the prompt used “pelicans” as the label Willison’s advice is blunt: turn reasoning down or off. Without it, the model is fast and capable. With 15-30 tok/s from LM Studio (vs 74-184 from hosted APIs), speed is the main barrier to daily-driving this thing, but Multi-Token Prediction via llama.cpp gives a ~72% boost. ...

Walter van der Giessen documents a deliberate industry shift: frontier models are trading factual knowledge for reasoning capability. GLM-5.2 hits 99.2% on AIME 2026 with ~40B active parameters while GPT-4 (~280B) could barely solve AIME in 2023 — but ask the same small models a plain factual question and hallucination rates hit 80-82%. The mechanism: Reasoning compresses well — it’s a small set of repeated procedures (break into parts, track state, backtrack). Facts need ~2 bits per parameter and don’t compress. Distillation and RL on verifiable tasks transfer reasoning into small models remarkably well. Phi-4 (14B) is good at math and bad at trivia — by design. The knowledge that survives is shallow breadth: enough to understand what a question is about, not enough to answer it without tools. The argument for why this is the right trade: ...

When an LLM solves a hard math problem, the reflex is to say it’s getting smarter. Davide Piffer offers a simpler, more interesting explanation: the context window is an enormous external notebook, and that matters more for formal reasoning than superior reasoning itself. Human working memory is severely limited — try multiplying two three-digit numbers in your head; the difficulty is carrying partial results, not the operations themselves Studies show working memory predicts mathematical performance even after controlling for IQ (Alloway & Alloway 2010; Alloway & Passolunghi 2011) A context window is “augmented symbolic working memory” — weaker at private internal states than humans, vastly stronger at maintaining an explicit persistent record Mathematics is especially suited to this architecture because its symbols are precise, assumptions can be externalized, and every step can be checked AI’s advantage is largest on problems involving many interacting constraints, long calculations, case analysis, and exact bookkeeping The gap narrows on problems requiring a single short conceptual leap or an entirely new representation Piffer’s framing matters because it shifts the question from “how smart is AI?” to “what cognitive architecture does it have?” — and that distinction has real implications. Reducing a model’s usable context or preventing it from writing intermediate steps should disproportionately hurt its performance on long math tasks. Expanding a human’s external memory (clear notation, software, structured notes) should narrow the gap. The fairest comparison isn’t AI vs. unaided human — it’s AI with its tools vs. a human with equally powerful external memory and verification systems. The closing analogy — von Neumann (speed, breadth, symbolic memory) vs. Einstein (reconceptualizing the problem) — is the cleanest distillation of where we actually are.

GLM-5.3 is an instructive data point in a question the field is actively figuring out: how far can pure post-training scaling push a fixed base model? Z.ai’s answer is “much further than anyone expected” — and the gains aren’t limited to benign coding tasks. The key mechanism is environment scaling: Instead of hand-building benchmarks, Z.ai built a pipeline where research agents collect real task patterns and synthesize runnable long-horizon environments, complete with multi-step dependencies and hidden state. Judge agents verify each environment is solvable (no shortcuts, no dead ends). Verifiers pass oracle, no-op, and unsolved-state checks to produce binary rewards reliable enough for direct RL training. The environments now cover production workflows — ML infrastructure optimization, complex debugging, cross-system diagnosis — representing days of work for an experienced engineer. The results on public benchmarks are dramatic: ...

Elad Rosenheim (Principal PM at Netlify) ran the same “build a coffee shop website” prompt through 11 different AI models — Claude Opus 5, Sonnet 5, GPT 5.6 Sol, GPT 5.6 Terra, Gemini 3.6 Flash, Gemini 3.1 Pro, Kimi K3, Kimi K2.7 Code, GLM 5.2, DeepSeek V4 Pro, and DeepSeek V4 Flash 0731 — and compared the visual quality against credit cost. The results are sobering for anyone buying into the “just use the best model” narrative. ...

Shreya Shankar (Stanford, Bargain/LLM cascades) live whiteboards model cascades on Hamel Husain’s channel: cut LLM classification costs by ~90% with no fine-tuning and no accuracy sacrifice. 26 minutes. The problem: the Oracle plan Every record (e.g. customer support tickets) goes to one high-quality LLM (say GPT-5.6) → yes/no label (escalate to human or not) Great accuracy, brutal at scale — back-of-envelope: tens of thousands of dollars for a million tickets Goal: match the Oracle’s accuracy at ~95% agreement on your data, but much cheaper The fix: a model cascade Proxy model first: every ticket hits a cheap nano LLM, which returns a prediction AND a confidence score C(x) (0–1) Decision point: if C(x) ≥ threshold τ, accept the proxy’s label; otherwise route to the Oracle Confidence scores come free from every LLM API (token log probabilities); ground truth = “what the Oracle would say,” not absolute truth Step 1 — find the threshold (offline) Sample 200–500 tickets, run the proxy on each → (prediction, confidence) pairs Label each sample ticket with the Oracle Simulate the cascade for every possible τ = one of the observed confidences: record accuracy and cost Return the τ with minimum cost that still meets the target accuracy — sort ascending and take the first one that qualifies Trivial sanity check: τ = 1 routes everything to the Oracle → 100% by definition; the real question is how low you can go Lower τ = cheaper (more accepted by the proxy) — but the proxy’s mid-confidence predictions are where it gets wrong Step 2 — run the cascade Run the proxy on ALL tickets; accept every C(x) ≥ τ; query the Oracle only on the rest That’s the whole inference path Caveats and results Target accuracy on the full set is an estimate, not a guarantee — you measured it on a sample Statistical guarantees are possible via concentration inequalities; their open-source package/paper (“Bargain”) adds adaptive sampling — plain random sampling wastes effort on low-confidence points that are probably wrong anyway In practice: 90%+ cost cuts on a wide variety of classification tasks with just a nano model Cascades vs. model routers Routers are black boxes — no way to estimate the accuracy you’re actually getting Cascades are sample-driven and fit to YOUR data; the threshold search tells you whether any τ even meets the target Works for binary AND multi-way classification (well-calibrated confidence from logits over the class tokens); not for open-ended tasks — poorly calibrated probabilities there often mean no τ exists Don’t trust the nano model’s confidence a priori — that’s fine. The simulation either finds a threshold that meets the target or it doesn’t; “the procedure is not going to lie to you.” “You don’t have to have any confidence in the confidence.” — Hamel Husain, on why the simulation matters more than trusting the nano model ...

When an AI coding agent can generate hundreds of lines of syntactically valid code in seconds, the rate at which a human can write code stops mattering. What matters now is reviewing, verifying, and maintaining that code once it’s already written. Balahan and Seroter make the case that Go — designed 20 years ago for team-scale software engineering — turns out to be the right language for this new world. ...

A research team (stolen-thoughts.com, arXiv 2608.09867) demonstrates that hidden chain-of-thought reasoning traces from proprietary LLM APIs — Anthropic, OpenAI, Google — can be recovered with near-perfect fidelity. They ran a decoding pipeline on 6,708 public agent trajectories from GitHub and Hugging Face that still contained encrypted reasoning blocks, reconstructing 315,320 reasoning blocks whose token count closely tracks the hidden thinking-token count reported by the API. The privacy finding is the real story: ...

Kuber Mehta makes a sharp case against the growing trend of “humanising” LLM outputs via prompt instructions (ASD-STE Simplified Technical English, “talk to me like I have ADHD”, short-sentence-only agent.md directives): these are lossy compression applied too early in the pipeline, and they hide exactly the information you most need to see. When a subagent runs six tests, a smoothed summary of “most tests passed, one issue worth looking into” is strictly worse than the raw 5/6 PASS FAIL: test_cache_invalidation CAUSE: stale key survives restart REPRO: cache_test.py:184. Human prose is excellent at glossing over uncertainty, hallucinations, and edge cases — the smoothing is the bug, not the feature. Mehta draws the right architectural parallel: databases don’t store data in dashboard format, compilers don’t make IR pleasant to read, and APIs don’t exchange friendly summaries. The correct pattern is to keep the highest-fidelity representation through the pipeline and transform only at the consumption boundary. LLM tooling does this backwards today, and the viral “make the model talk to me like…” repos are valuable not as end-state solutions but as bug reports pointing at the right fix.

Anthropic gave an unreleased research version of Claude an unreasonable challenge: “take a real stab at the Riemann hypothesis.” It didn’t crack the 1859 problem — but as a byproduct, it improved a longstanding lower bound. The proven fraction of zeta zeros on the critical line rose from 41.6% to 67.2%. The mechanics matter as much as the number: Two sessions in Claude Code, 31 million output tokens First 650 ideas failed; a second push ran ~60 subagents 2,400 shell commands and hundreds of Python scripts Subagents cross-refereed one another’s work and ran thousands of numerical checks against known zeros Claude built on Montgomery’s pair-correlation techniques (made RH-free by Baluyot, Goldston, Suriajaya, and Turnage-Butterbaugh) plus a 2000 Bombieri paper. Its key step: treating the whole quadratic-form space — positive- and negative-definite subspaces together, non-diagonal forms allowed. ...

Laurentiu Raducu’s technique for learning with LLMs, born from frustration with their explanations (“too simplistic and, depending on the number of emojis used, a bit annoying”): instead of asking a model to explain a topic, ask it to build a playable low-poly simulation of it — a RollerCoaster Tycoon-style animated game — then push it to GitHub Pages. The flow: in plan mode (Claude Code or OpenCode), have the model build the foundational knowledge base for the topic; have it review that knowledge base for accuracy; then have it build the simulation with UX requirements (responsive, controls to stop the flow); push to a repo and enable Pages. The result is an animation you can follow step by step — “100% accurate and free of hallucinations” per the author — and learning by watching a process beats reading. His worked example is ChipTycoon: chip manufacturing from sand collection to a finished chip delivered to a data center, motivated by researching AI data-center bottlenecks and realizing he didn’t understand chip production. Improvements: map the low-poly objects to realistic 3D models (his picture-to-3D skill), and add challenges — answering questions about previous steps “retains knowledge tremendously.” Same pattern applied to rocket engines, how LLMs work (Token Town), F1 engines, and EUV lithography. The insight: the simulation is the explanation — every step has to be concrete and sequential, and if the animation doesn’t make sense, that’s a gap in your understanding.

Steven Byrnes’s counter to the RLVR hype: yes, reinforcement learning from verifiable rewards is hot and it works, but if you ask where LLM capabilities actually come from, the answer is overwhelmingly imitative learning (pretraining + SFT), not RL. The structural argument: RLVR may be 20-50% of training compute, but each RL GPU-hour conveys orders of magnitude less information content than an imitative-learning GPU-hour (Toby Ord’s “Extreme Inefficiency of RL,” Dwarkesh Patel’s “bits per sample”) — compute share is not credit share. Supporting evidence: chain-of-thought is still legible, which imitative learning guarantees but RL would actively erode (Karpathy: “you can tell the RL is done properly when the models cease to speak English in their chain of thought”); labs still spend billions on pretraining/SFT data; and three papers show non-RLVR’d models reaching the same capability ballpark via sampling, iterative search, or weight-perturbation ensembles (Yue et al., Karan & Du, “Neural Thickets”). The cleanest picture comes from an interpretability paper (Venhoff et al., coauthored by DeepMind’s Neel Nanda): the base model already “knows” all the long-Co T moves — press on, backtrack, pivot strategies — from imitative learning; RLVR mostly refines the heuristics for which move to use in which situation, which is a huge practical difference but a small share of capability. His framing: “if the RL piece is an elephant in the room, the imitative learning piece is the friggin’ Mt. Everest.” Three implications. CoT legibility: Rohin Shah expects monitoring to stay viable ~4-5 years because pretraining is “by far the most powerful form of getting stuff into an AI system that we have ever built.” Capabilities: expect LLMs to be competent where human data and concepts exist — verifiable rewards alone being sufficient for arbitrary domains is “the jury is out.” Alignment: capabilities via RL produce “ruthless sociopathic behavior”; capabilities via imitative learning produce models that follow the human distribution — Bing-Sidney was pure imitative learning and misaligned with a human flavor of craziness, versus the RL-ish ruthless-goal-seeking craziness in recent incidents. His bottom line: the niceness LLMs have from imitative learning gets diluted away as RLVR scales, and if a comparatively small RLVR amount already causes obvious RL-style alignment problems, that’s a bad sign for the future.

Political theorist Gregory Conti (Princeton, writing in Compact) makes the strongest recent statement of the “AI is not the steam engine” case from the conservative side. His central move: AI opposition is misdirected because it targets future risks when generative AI is already producing moral and cultural harm. Anthropomorphic AI — models that mimic personality, emotion, and thought — is unsettling human psychology and the social fabric right now, so opposition should target what AI is, not only what it may become. The sui generis argument is the essay’s sharpest contribution: past innovations substituted for material processes; AI substitutes for language and cognition themselves — the things that constitute human distinctiveness — so the Luddite analogy is a category error. From there he prosecutes the case across four fronts: capitalism will be destroyed by its own success (quoting Marx’s prediction that production based on exchange value breaks down once machines out-produce labor, and noting Dario Amodei’s “Machines of Loving Grace” is fully automated luxury communism — the anti-communists may prove Marx right); individualism dies as AI becomes a homogenizer whose answers are statistical averages of human speech (Tocqueville’s soft despotism, Mill’s warning in On Liberty); democracy fails once citizens have no economic or military value, becoming subjects rather than rights-bearers; and the written word loses its human provenance — his grandmother’s-letters thought experiment: if she’d had Gemini, the access to the real person is denied forever. The essay also lands a sharp critique of AI-booster “productivity”: reading fifty papers in a month is really not reading fifty papers — you emerge with a facsimile minus the understanding, a slightly different person than the one who would have done the work. The prescription is uncompromising: not regulation but rejection — limit the diffusion of anthropomorphic AI in civil society and end the pursuit of superintelligence. Read it alongside the Cognitive Commons paper: same underlying claim (the cognitive labor itself is the product being destroyed), argued from political philosophy instead of labor economics.

Nolan Lovett’s conceptual paper (Human Resource Development Review, 2026) applies Garrett Hardin’s Tragedy of the Commons to professional expertise: each organization’s rational decision to replace entry-level cognitive labor with AI is locally sensible, but collectively it depletes the shared pool of deep human expertise that every organization in the profession depends on — especially for validating AI output. The key constructs: Internalized Mastery (deep domain knowledge built through sustained cognitive struggle) vs. Distributed Mastery (orchestrating human-AI systems), connected by the Validation Tether — effective AI oversight fundamentally depends on the very expertise AI adoption can undermine. Evidence is already visible in the cohort data: in AI-exposed occupations, employment for workers aged 22-25 fell 16% (Oct 2022 - Sep 2025) while workers 35-49 grew 8%+, exactly the pattern commons depletion through foreclosed regeneration predicts. The paper distinguishes surface validation (spotting obvious errors — no domain expertise needed) from substantive validation (recognizing plausible-but-wrong output — requires deep knowledge), and warns that as workers lose the cognitive struggle that builds mastery, they gain productivity on routine tasks while losing the ability to catch AI’s failures on non-routine ones. The argument borrows Hardin’s structure but not his fatalism — Ostrom showed commons can be sustained with governance at organizational, professional-association, and policy levels. The sharpest insight: the pre-AI equilibrium was never governed — developmental pipelines were maintained because organizations needed junior labor, and AI breaks that accidental alignment.

Michael Fogus’s short essay on why hobby programming communities — chess-engine devs, OSDev, EmuDev, the demoscene, code golfers — are aggressively hostile to LLM usage. The surface complaint is that LLM-generated code “misses the point entirely,” but the point is deeper: in these communities the process of mastering a difficult field is the product, and something that runs is a nice-to-have. Respect is earned slowly — years of forum activity, elegant code, displays of genuine curiosity, deep domain knowledge — and nobody cares whether your code works so much as whether you know why and how it works. Fogus traces how earnest early LLM engagement got poisoned fast, by practitioners who lacked deep understanding and by a vitriolic subset who view the whole enterprise as cheating. His own position is measured: an LLM is a force multiplier, not a surrogate — in the hands of an expert who already understands a domain, it acts like a lever, though he warns that expertise offers no natural immunity against being fooled. The closing line lands the thesis: using an LLM to generate the finished piece doesn’t make us craftsmen; it just robs us of the craft. Read it next to “Don’t Be a Meat Proxy” — both are really about what happens when the tool does the work and the human stops doing the learning.

Tom Zahavy’s ICML 2026 position paper makes a sharp claim about where LLMs actually stop: they can induce and they can deduce, but they can’t abduce. Using Einstein’s 1952 letter to Maurice Solovine as the frame, Zahavy maps scientific discovery as a cycle — sense experience, an intuitive “jump” to axioms, then logical deduction from those axioms. LLMs, he argues, have mechanized the last part (formal proof, à la AlphaProof) and the statistical pattern-matching of induction, but the generative step — the abductive leap that produces a genuinely new axiom from scarce or absent data — is structurally out of reach. The case study is the equivalence principle: Einstein didn’t derive general relativity by compressing data, because Newtonian physics faced no empirical crisis (the one anomaly, Mercury’s perihelion, was explained away with the hypothetical planet Vulcan). With no error signal, “creativity as compression” has no gradient to push a system toward restructuring spacetime. The fix isn’t a bigger LLM: Zahavy proposes action-controllable, physically consistent world models — synthetic laboratories where an agent can intervene counterfactually, cut the elevator cable, and ground symbols in simulated sensation. It’s a position argument, not a proof — reviewers pushed the conclusion from “confirms” to “suggests” — but it’s a genuinely provocative frame for what “AI for science” can and cannot mechanize.

Sean Goedecke pushes back on the idea that LLMs make everyone a generalist and that “prompting skill” is a myth. The real differentiator, he argues, is domain expertise. His proof point is Terence Tao’s conversation with ChatGPT about the Jacobian Conjecture counterexample — Tao’s prompts are short, precise, and push back surgically, not because he’s a gifted prompter, but because he understands the mathematics deeply enough to know exactly what to ask for and where to steer. Goedecke connects this to his own experience programming with AI: if you have a good theory of your codebase, you can push the LLM far harder than someone who doesn’t, asking questions like “but don’t we already do X?” or “can we express this problem in these familiar terms?” The practical implication is counterintuitive: as models get stronger, human expertise becomes more valuable, not less. The bottleneck shifts from what the model can produce to what the human can articulate — and only a domain expert can communicate the shape of a good solution. If you have no domain knowledge, you can at least get something from an LLM, and that’s not bad. But if you have expertise, you can wring far more value out of the same model by steering it hard in the direction you want.

Diogo Almeida, a co-author of InstructGPT, ChatGPT, and GPT-4, makes the case for a different target for post-training: reliable automation rather than a satisfying interaction. In this roughly 18-minute AI Engineer talk, the TypeSafeAI/Jev CEO explains why he considers Claude Code part of the assistance era—and sketches, without disclosing its mechanism, the alternative his team is building. ...

Shreya Shankar (UC Berkeley PhD) presents DAB — the Data Agent Benchmark (“Can AI agents answer your data questions?”), from her PhD work at Berkeley. ~27 minutes on Hamel Husain’s channel. Why data agents matter Huge real use case: AI answering business questions — much office work is this Enterprises struggle to use Claude Code / Codex off-the-shelf for BI tasks, so they build their own data agents: Uber’s Query GPT (1.2M queries/month at launch), OpenAI’s in-house agent, Databricks, Snowflake Existing benchmarks fall short: Text-to-SQL — assumes clean data in one Postgres/Snowflake; real enterprises have fragmented data; SQL alone isn’t enough (need domain knowledge, reasoning over outputs) Table QA — context table + question; doesn’t scale to enterprise data volume The formative study — 4 real-world challenges Interviews with enterprises + Hasura (PromptQL) surfaced four properties missing from existing benchmarks: ...