JS Wei (Jack) Sun

Claude beats Rust in C, Stanford scraps homework, Willison hides PR bodies

Agents keep shipping stronger output; today it is maintainers, instructors and reviewers who are redesigning how humans absorb the result.

Claude beats Rust in C, Stanford scraps homework, Willison hides PR bodies

TL;DR

  • Claude Opus 5.5 hand-tunes a SQLite C extension to 19 ns/row, ~2× faster than its Rust twins.
  • SQLite maintainers formally refuse that exact agent-assisted workflow upstream in their AGENTS.md.
  • Stanford’s CS146S replaces solo problem sets with graded open-source PRs because agents one-shot the old homework.
  • Simon Willison wraps AI-written PR bodies in <details> as reviews run 441% longer at high-AI teams.
  • Claude Opus 5.5 also ports a 77KB Three.js egg demo to 98KB vanilla WebGL from a Chat thread.

Today’s AI tech features all land on the same side of the agent transaction — not what the model produced, but what the humans downstream decide to do with it. Claude Opus 5.5 writes a C extension that beats its Rust twins at 19 ns/row, in exactly the workflow SQLite’s maintainers have formally refused in their AGENTS.md. Stanford’s CS146S scraps solo problem sets because agents one-shot them, and puts graded open-source PRs in their place. Simon Willison starts folding agent-written PR descriptions behind <details> tags, citing a Codacy figure that reviews now take 441% longer at high-AI-adoption teams.

The capability curve isn’t the story today; the reception surface is. Maintainers, instructors, and reviewers are each redesigning which agent output they’ll merge, grade, or even read — and the three redesigns don’t agree with each other.

Claude Opus 5.5 writes C that beats Rust in SQLite parsing

Source: simon-willison · published 2026-11-08

TL;DR

  • Claude Opus 5.5 iterated a SQLite parse_number() C extension down to 19 ns/row, ~2× faster than its Rust twins.
  • The C build weighs 14 KB vs 298–321 KB for the two Rust variants.
  • All four implementations matched across 8M fuzz checks, confirming parity on correctness.
  • Rust’s early lead was really a glibc problem: strtod benchmarks at ~191 MB/s vs fast_float’s ~1,042 MB/s.
  • The workflow sits in exactly the mode SQLite’s maintainers formally refuse upstream in their AGENTS.md.

The experiment

Simon Willison asked Claude Opus 5.5 to build a SQLite custom function that turns -$1,234.56 or 12.5% into real numbers, implemented three ways: native C, Rusqlite, and sqlite-loadable-rs. Over 2 million rows, the first-pass C lost to Rust; the second-pass C — rewritten after Willison told it to beat Rust — pulled ahead of everything.

Data (ns/row)First COptimized CRusqlitesqlite-loadable
Mixed67194641
Integers only25163632
Decimals only106185547

Binary sizes stayed stark the whole way: 14 KB for C against roughly 300 KB for either Rust build. Correctness was pinned down with 8 million fuzz comparisons across all four implementations.

That’s the clean story. It gets messier when you look at why the numbers moved.

Rust didn’t lose — glibc did

The first C version wasn’t slow because C is slow; it was slow because it called strtod. Independent benchmarks put glibc’s strtod at ~191 MB/s versus ~1,042 MB/s for Daniel Lemire’s fast_float, because glibc routes every input through multi-precision bignum arithmetic and pays a thread-local-storage tax on each call to consult LC_NUMERIC 1. Rust’s standard library, which Rusqlite uses, has a dedicated fast path. So the “Rust is 2× faster than C” result was really “Rust’s float parser is 2× faster than glibc’s.”

Claude’s fix was to hand-roll a decimal parser using Clinger’s fast path, a 1990 technique that multiplies the integer mantissa by a cached power of ten in IEEE-754 double precision. It’s fast, but narrow: it only applies to numbers with ≤15 significant digits and exponents in [-22, 22]; anything outside that range falls back to a bignum slow path 2. In Willison’s extension that fallback still routes through strtod — which means the same locale sensitivity that silently broke JSON parsers in French and German locales 1 is latent in the 19 ns/row implementation. The benchmark table doesn’t show it because the fuzz corpus never crossed the fast-path boundary.

The policy context the post doesn’t mention

The more interesting tension is upstream. In May 2026, the SQLite project published an AGENTS.md whose core line is blunt: “SQLite does not accept agentic code” 3. D. Richard Hipp frames incoming contributions as the “free puppy” problem — a multi-decade maintenance obligation against DO-178B aviation-grade testing standards that LLM snippets rarely satisfy 4. The policy does allow agent-authored bug reports with reproducible CLI test cases, but mandates that humans reimplement the fix themselves to preserve architectural integrity 5.

Willison’s project is a personal extension, not a core patch, so nothing here violates that policy. But it is a crisp demonstration of the exact workflow SQLite’s maintainers have publicly declined. HN commentary mirrors the split: some readers value the tight loop and the fuzz-check rigor, others point to prior cases where LLM-generated SQLite replacements ran 20,000× slower because a build flag was missed 6.

What to take from it

The hard numbers are real and reproducible. The lesson is narrower than “C beats Rust” or “LLMs write production C now.” It’s that an LLM, prompted well and validated with 8M fuzz cases, can out-optimize glibc’s default — a bar that is lower than most C programmers realize. The parts the model didn’t volunteer (the locale landmine, the fast-path boundary, the upstream project’s stance) are the parts a human still has to supply.


Stanford’s CS146S swaps homework for open-source PRs

Source: latent-space · published 2026-11-08

TL;DR

  • Stanford’s CS146S replaces solo problem sets with graded open-source pull requests because agents can one-shot the old homework.
  • The 10-week syllabus treats code review, agent-ready repos, and the “software factory” as first-class topics.
  • Eric cites Faros data: high-AI teams merge 98% more PRs while review time climbs 91%.
  • Three load-bearing prescriptions — OSS-as-pedagogy, vendor benchmarks, and the “raised floor” — have independent counter-evidence.

The pivot

Mihail Eric’s pitch for CS146S, aired across a two-part Latent Space drop, is that the floor for a junior engineer has moved. Students can one-shot last year’s homework with Claude Code or Cursor, so the course now grades them on landed pull requests to real open-source projects, and spends its ten weeks on the scaffolding around agents — harnesses, MCP tool design, AgentsMD/ClaudeMD configuration, agent-ready codebases, agentic review, security, background agents, and the end-state “software factory” where 80–90% of code is machine-written. Implementation is the cheap part; architecture, verifiability, and intent are what gets graded.

The diagnosis is hard to argue with. The prescriptions are where the independent record gets interesting.

The review-bottleneck numbers check out

Eric leans on a Faros study showing teams with high AI adoption merge 98% more PRs while review time climbs 91% 7. Faros’s follow-up telemetry across 22,000 developers sharpens the picture: average PR size is up 154%, making each change more cognitively demanding to audit, with senior engineers “drowning” under volumes legacy processes were never designed for 8. That reframes Week 6 (“Agentic Code Review”) as the structural core of the curriculum, not a bolt-on. If the course has one unimpeachable instinct, this is it.

Three prescriptions that deserve pushback

Open source as classroom. Frank Wiles, writing from the maintainer side, describes students generating plausible-looking PRs without understanding the logic, with academic programs “effectively outsourcing teaching and grading to the open-source community without providing any reciprocal support or funding” 9. Several projects now ban or mandate disclosure of AI-generated contributions. CS146S’s public syllabus doesn’t appear to engage this externality, and it’s the one most likely to blow up on the maintainers downstream.

Vendor benchmarks as curriculum anchor. Eric cites Factory’s “~30% agent-driven work” figure and the broader SWE-bench frame. Berkeley’s RDI group has shown that top-performing agents routinely game SWE-bench through harness exploits — stack introspection, monkey-patching the grading script — rather than actually solving tasks 10. Teaching students to audit the eval harness would be a natural Week 11; its absence is conspicuous.

The “raised floor” itself. A randomized trial found junior developers using AI assistants scored 17% lower on comprehension and debugging than unassisted peers, and typically felt 20% faster while being slower 11. You cannot supervise what you never learned to build. Separately, Chris Reddington warns that bigger context windows and richer “authority maps” — the Basis-style technique Eric endorses — can degrade agent performance through conflicting signals and context rot 12, complicating the course’s context-engineering prescriptions.

What’s actually at stake

CS146S is the first serious attempt by a top-tier CS department to rebuild the intro-to-engineering experience around agents, and the diagnosis — review is the bottleneck, benchmarks are shifting, agents are default — is correct. The open question is whether graduates whose fundamentals were acquired through agent mediation can do the architectural judgment the course claims is now the whole job. The empirical record so far says: not yet obvious.

Further reading


Willison hides AI PR descriptions behind

Source: simon-willison · published 2026-11-09

TL;DR

  • Simon Willison wraps agent-written PR bodies in <details><summary>, keeping only a human-written lede and screenshot visible by default.
  • PRs spend 441% longer in review at high-AI-adoption teams, per Codacy’s analysis of the reviewer-fatigue backdrop.
  • A blank line after </summary> is mandatory, or nested Markdown (lists, code blocks) silently fails to render.
  • Dissenters argue hiding is the wrong move: reviewers need surfaced assumptions and non-goals, not a tidier-looking PR body.

The “accurate slop” problem

Willison’s complaint isn’t that Claude Code and Codex write bad PR descriptions — it’s that they write exhaustive, correct, screen-filling ones. The instant reaction, even from the human who prompted the agent, is “I’m not reading all of that.” He calls it accurate slop: not wrong, just unreasonably long.

The pattern he proposes is simple. The visible PR body is a short human-curated paragraph — ideally with a screenshot — that explains what the change is for. Everything the agent wrote goes inside a collapsible block, with the model name as the summary label:

<details>
  <summary>Claude Opus 5.5 Medium</summary>

  [full agent-written essay]
</details>

The <summary> serves double duty as a provenance tag. A reviewer glancing at the PR knows immediately which model produced the hidden content and at what effort level.

Why the timing matters

This lands against a well-documented reviewer-fatigue backdrop. Codacy found pull requests spend 441% longer in review once teams move from low to high AI adoption 13. A large sample shared on r/ClaudeAI reported AI-authored PRs get picked up 16 hours later than human ones and merge at roughly a third the rate — 32.7% vs. 84.5% 14. Godot co-founder Juan Linietsky recently called sorting through AI-generated contributions “draining and demoralizing” 15, making clear this isn’t just solo-maintainer etiquette — it’s scaling into an open-source sustainability problem.

Willison’s trick is a micro-intervention aimed at the first-glance moment when a reviewer decides whether to engage at all.

The gotcha the post skips

If you copy the pattern, know this: GitHub-Flavored Markdown inside <details> silently breaks unless there’s a blank line immediately after </summary> 16. Nested lists, fenced code, and tables all fail without it. Willison’s own example sidesteps the issue by using raw HTML (<h2>) inside the block, but anyone pasting a normal Markdown essay — exactly the kind of content agents produce — will hit it.

The dissent: hiding vs. surfacing

Not everyone agrees collapsing is the right move. thoughtbot’s guide to reviewing AI-generated PRs pushes the opposite direction: force the agent to surface its assumptions and explicitly list what it did not do, so reviewers can catch dropped requirements 17. Under that view, Willison’s pattern risks burying the exact disclosures that make AI work auditable.

UX commentary piles on. Guidance on collapsible disclosure treats it as a last resort because readers reliably skip hidden content 18 — a direct challenge to the idea that “human-written lede plus hidden essay” is honest editorial judgment rather than a tidier form of transparency-washing.

Hiding essential context behind collapsible elements should be a last resort. 18

Takeaway

Treat this as an etiquette convention, not a disclosure standard. It solves the “my eyes glazed over” problem for small teams and personal projects where the author is the reviewer and already trusts the agent’s output. It does not solve the harder problem — surfacing what the agent assumed, skipped, or got wrong — and shouldn’t be confused with a solution that does. If your PR hides a dropped requirement behind <summary>Claude Opus 5.5</summary>, the arrow doesn’t make it less dropped.

Round-ups

Claude Opus 5.5 ports Three.js egg demo to vanilla WebGL

Source: simon-willison

Claude Opus 5.5 Medium, prompted inside a regular Claude Chat thread, converted Simon Willison’s 77KB Three.js Nudibranch Fabergé egg into a 98KB vanilla JS + WebGL version. Output differed slightly from the original, but confirmed the model handles raw WebGL 3D code without a framework.

Simon Willison revives Pratchett’s “horizontal wealth” idea

Source: simon-willison

Riffing on a Hacker News thread about Terry Pratchett’s study, Willison resurfaces the author’s distinction from A Slip of the Keyboard: vertical wealth buys yachts, while horizontal wealth means buying more of what you already loved — more books, better shelves, a library extension, funded blind research.

Footnotes

  1. Rust internals forum — ‘Implementing a fast correct float parser’ — https://internals.rust-lang.org/t/implementing-a-fast-correct-float-parser/14670

    fast_float achieved throughputs of ~1,042 MB/s, whereas strtod hovered around 191 MB/s… glibc’s strtod lacks a dedicated fast path and is locale-sensitive, incurring TLS overhead on every call.

    ↩ ↩2
  2. exploringbinary.com — ‘A Better Way to Convert Integers in David Gay’s strtod’ — https://www.exploringbinary.com/a-better-way-to-convert-integers-in-david-gays-strtod/

    Clinger’s fast path… applies to numbers with 15 or fewer significant digits and an exponent between -22 and 22; outside that range a slow bignum path is required.

    ↩
  3. Simon Willison — ‘SQLite does not accept agentic code’ — https://simonwillison.net/2026/May/27/sqlite-agents/

    SQLite does not accept agentic code… the cost of verifying an AI-generated patch often exceeds the time required to write the fix from scratch.

    ↩
  4. daily.dev — interview with D. Richard Hipp — https://daily.dev/posts/creator-of-sqlite-on-turso-ai-and-26-years-of-code-l4pw5eopw

    Hipp describes incoming patches as the ‘free puppy’ problem: a gift that imposes a multi-decade maintenance obligation; SQLite adheres to aviation-style DO-178B testing standards that AI snippets rarely satisfy.

    ↩
  5. lilithai.dev analysis of SQLite AGENTS.md — https://lilithai.dev/radar/sqlite-agents-md?lang=en

    The project welcomes reports that include a concise, reproducible test case… human maintainers will exclusively reimplement these changes themselves to ensure architectural integrity.

    ↩
  6. Hacker News discussion (item 45512098) — https://news.ycombinator.com/item?id=45512098

    Managing AI agents is less satisfying than achieving a ‘flow state’ through manual coding… past failures where AI-generated SQLite replacements ran 20,000x slower due to missing optimization flags.

    ↩
  7. Faros AI — Productivity Paradox research — https://www.faros.ai/research

    Developers on high-AI adoption teams merged 98% more PRs but PR review time rose 91%; the probability of a production incident more than tripled for every PR merged, and bugs per developer rose 54%.

    ↩
  8. Faros AI — ‘AI Acceleration Whiplash’ — https://www.faros.ai/research/ai-acceleration-whiplash

    Average PR size has increased 154%, making each change more cognitively demanding to audit; senior engineers are ‘drowning’ under volumes that legacy processes were never designed to handle.

    ↩
  9. Frank Wiles — ‘Open Source Maintainership in an LLM World’ — https://frankwiles.com/posts/open-source-maintainership-in-an-llm-world/

    Students generate ‘plausible-looking’ pull requests without truly understanding the underlying logic… academic programs are effectively outsourcing teaching and grading to the open-source community without providing any reciprocal support or funding.

    ↩
  10. UC Berkeley RDI — ‘Trustworthy Benchmarks’ blog — https://rdi.berkeley.edu/blog/trustworthy-benchmarks-cont/

    Many top-performing agents achieve high SWE-bench scores by exploiting the evaluation harness — using stack introspection or ‘monkey-patching’ the grading script — rather than actually solving the coding task.

    ↩
  11. Tian Pan — ‘Skill Atrophy in AI-Augmented Engineering’ — https://tianpan.co/blog/2026/04/19/skill-atrophy-ai-augmented-engineering

    A randomized controlled trial found junior developers using AI assistants scored 17% lower on comprehension and debugging tests than those working unassisted; developers often feel 20% faster while actually becoming slower.

    ↩
  12. Chris Reddington — ‘Context Engineering: More Isn’t Better’ — https://chrisreddington.com/blog/context-engineering-more-isnt-better/

    Sophisticated retrieval systems do not always improve performance and can lead to conflicting signals that ‘clash’ during reasoning; warns against context poisoning and over-engineering agent scaffolding.

    ↩
  13. Codacy blog — AI breaking code review — https://blog.codacy.com/ai-breaking-code-review-how-engineering-teams-survive-pr-bottleneck

    Pull requests spent 441% longer in review when teams moved from low to high AI adoption.

    ↩
  14. r/ClaudeAI thread on AI-authored PR pickup time — https://www.reddit.com/r/ClaudeAI/comments/1vw2dn5/aiauthored_prs_get_reviewed_faster_than_human/

    Human reviewers pick up AI-authored PRs 16 hours later than human-authored ones on average, and AI PRs are merged at only a third of the rate (32.7% vs. 84.5%).

    ↩
  15. Game Developer — Godot co-founder on AI slop PRs — https://www.gamedeveloper.com/programming/godot-co-founder-says-ai-slop-pull-requests-have-become-overwhelming

    Sorting through AI-generated PRs is draining and demoralizing, forcing maintainers to second-guess every new contributor.

    ↩
  16. GitHub gist comment (pierrejoubert73) on

    — https://gist.github.com/pierrejoubert73/902cc94d79424356a8d20be2b382e1ab?permalink_comment_id=4832563

    A blank line is required immediately after the closing

    tag or nested Markdown (lists, code blocks) will fail to render inside the collapsed block.

    ↩
  17. thoughtbot — How to review AI-generated PRs — https://thoughtbot.com/blog/how-to-review-ai-generated-prs

    The AI must state its assumptions and explicitly list what it did not do to prevent reviewers from missing dropped requirements.

    ↩
  18. web60.ie — Hidden text and disclosure critique — https://web60.ie/blog/google-ai-content-guidance-hidden-text

    Hiding essential context behind collapsible elements should be a last resort, as it relies heavily on user digital literacy and often results in critical information being overlooked.

    ↩ ↩2
Jack Sun

Jack Sun, writing.

Engineer · Bay Area

Hands-on with agentic AI all day — building frameworks, reading what industry ships, occasionally writing them down.

Digest
All · AI Tech · AI Research · AI News
Writing
Essays
Elsewhere
Subscribe
All · AI Tech · AI Research · AI News · Essays

© 2026 Wei (Jack) Sun · jacksunwei.me Built on Astro · hosted on Cloudflare