Dan πŸ‡¬πŸ‡§ (@dnlpearce) header
Dan πŸ‡¬πŸ‡§ (@dnlpearce) profile picture

Software Engineer by day, side quests by night. Unpacking the weird bits of tech, games, music and markets - always asking why it’s actually happening.

England, United Kingdom
Joined February 2014
nginx 1.31.9 and 1.30.7 fix CVE-2026-123007, an HTTP/2 heap overflow in every version since 1.9.5 with http2 on. After upgrading, restart it. nginx -s reload only re-reads config, so the old binary keeps running. If you can't patch yet, set http2 off. nginx.org/en/security_adviso…
19
An eval case where the right answer is "do nothing" is the easiest case to pass by accident. Doing nothing correctly and failing to do anything leave the same trace: no tool call, no state change. Unless your harness can tell those apart, your false-action rate is partly measuring how often the agent broke. There's a clean example in an open issue on the Berkeley Function Calling Leaderboard that was still active this week. BFCL has an irrelevance category: the model gets a set of functions, none of which fit the request, and the correct output is no call. The scoring line is success = not contain_func_call, and contain_func_call is set to false whenever the AST decoder throws. So a model that tried to call a function and got the syntax wrong is credited exactly like one that sensibly declined. The issue's numbers come from the published score files, not a rerun, and they're stark. Falcon3-1B-Instruct is credited correct on 229 of 240 irrelevance cases, and 228 of those outputs contain a tool call with a function name and arguments. The 11 it's marked wrong on are the ones where the syntax happened to parse. Llama-3.1-Nemotron-Ultra-253B is the limit case: every stored result is empty, it scores zero on plain function calling, and a perfect 240 of 240 and 884 of 884 on irrelevance. That's its entire published overall score. The author is careful to say the top of the table isn't affected. The point isn't the leaderboard, it's the shape of the bug. That shape turns up anywhere you score agents by outcome. If you check final database state, a request that policy forbids has an unchanged state as its goal, and an agent that crashed on its first turn leaves exactly that. If you check for no tool call in the transcript, a timeout passes. If you check for a refusal phrase, you're grading tone. In each case the negative cases, the ones meant to catch an agent acting when it shouldn't, quietly reward it for not working. The fix I'd make in my own evals is to stop treating abstention as the absence of something and make it an act. Give the agent an explicit way to decide not to act, a structured decision field or a no-op tool that takes a reason, and score silence, errors and unparseable output as failures in their own bucket. Record three outcomes per case, acted, abstained and errored, and never fold errors into either of the other two. Then pair every should-not-act case with a near twin where acting is correct, the same request with the permission granted or the relevant function added, and report the pair together. An agent that never acts scores perfectly on one half and zero on the other. That's the same consistency check the BFCL issue proposes: near-perfect irrelevance next to zero relevance isn't good judgement, it's a decoder that never succeeds. There's a real trade-off. The author tried the obvious stricter rule first, treating any decode failure as wrong, and found it penalised models that genuinely abstained in prose that happened to trip the parser. An explicit no-op tool has its own failure mode too: it's an exit, and a model will take it to dodge a hard task. That's why the pairing matters more than the mechanism. Without the positive twin you can't tell restraint from avoidance. It's also worth weighting the two errors properly. A missed action usually costs a retry. A false action, a refund issued twice or a migration run against the wrong database, can cost far more, so a single blended accuracy number hides the failure you actually care about. Doing nothing is a decision, and an eval should only credit it when the agent made it on purpose. If your harness can't show that, the score for that category is partly measuring your parser. github.com/ShishirPatil/gori…
1
24
PostgreSQL 19's REPACK (CONCURRENTLY) can replace VACUUM FULL without blocking writes, but it isn't lock-free. The final swap still takes ACCESS EXCLUSIVE, so an old open transaction can stall it and queries queue behind it. Check pg_stat_activity first. postgresql.org/docs/19/sql-r…
9
ASP .NET Core 11 changes your OpenAPI document with no code change: AddOpenApi() now emits 3.2, not 3.1. If a client generator or contract test downstream can't read 3.2 yet, pin it: options.OpenApiVersion = OpenApiSpecVersion.OpenApi3_1 learn.microsoft.com/en-us/as…
1
19
Ruby just fixed seven memory bugs in core Regexp and String case conversion, some with RCE PoCs. They're in the interpreter, so bundle update won't fix them. Bump .ruby-version and rebuild images: 4.0.10, 3.4.13 or 3.3.14. 3.2 and older get no fix. ruby-lang.org/en/news/2026/1…
20
CocoaPods trunk goes read-only on 2 December and not a single build will break. That's exactly what makes it risky. A deprecation that fails loudly gets fixed within a sprint. One that keeps working turns quietly into a dependency nobody will ever patch. The mechanics are simple. From that date trunk rejects every new podspec at the server, and the CocoaPods/Specs repo gets archived on GitHub. The Specs repo and the CDN keep serving what's already published, so pod install resolves exactly what it resolved the day before. CI stays green. What broke during the early November test run was publishing, things like pod trunk push in release pipelines. If you only consume pods, you saw nothing then and you'll see nothing on 2 December. What changes is the future, not the present. Every pod that only ships through trunk is frozen at its last published version. Whatever bug it has that day, it keeps. When a fix lands later, it lands somewhere else, usually as a Swift package, and nothing in your setup will tell you. pod outdated can only compare against the specs repo, and a frozen repo will always say you're current. The first time one of those pods gets a security advisory, the upgrade isn't a version bump. It's a package manager migration for that dependency, done under pressure, plus whatever version gap has built up in the meantime. The date for your app isn't really 2 December either. Publishers can leave earlier, and the biggest one already has. Firebase's migration page says Firebase 12 is the final major version published to CocoaPods and that new versions stopped going there in October 2026, and that covers its subdependencies too. So an app that never mentions Firebase in its Podfile can still be capped by something it pulls in. That's why the Podfile is the wrong thing to read. The lockfile (Podfile .lock) lists everything that actually resolved, and that's where the exposure sits. Frozen doesn't automatically mean dangerous, though. A small, stable pod that hasn't needed a release in years isn't getting any worse on 2 December. Private specs repos and vendored dependencies aren't affected at all, according to the CocoaPods post. The risk concentrates in pods that parse untrusted input, talk to the network or wrap a platform SDK Apple changes every year, because those are the ones that will need a release you can't get. Copying podspecs into your own specs repo keeps things building, but Firebase's docs are blunt that you're then responsible for keeping them up to date. You've become the maintainer of someone else's packaging, which is fine as a bridge and a poor place to end up. So the useful move is to turn a silent change into a decision now, while it's cheap. Go through the lockfile and note three things for each pod: whether a Swift package exists, how far your locked version is behind the latest release, and whether it touches the network or untrusted data. Move the risky ones with small gaps first, because a minor version move to SwiftPM is an afternoon and a jump across several majors is a project. Then add a CI check that fails when someone adds a new trunk pod, so the list only gets shorter. The lesson travels well beyond CocoaPods. When infrastructure is retired by freezing it rather than switching it off, nothing forces you to notice, so you have to create the failure yourself. A red build you chose is far cheaper than an advisory you can't patch. blog.cocoapods.org/CocoaPods…
35
Agents turned 185,000 lines of curl's C into 340,000 lines of Rust in about three weeks, Daniel Stenberg counted. In those weeks curl merged 300+ commits, 200+ of them bug fixes the port lacks. An agent rewrite is a fork. Budget for keeping up. daniel.haxx.se/blog/2026/11/…
1
1
102
On the iOS 27.3 beta, Apple lists a known issue for App Intents: if an AppEntity's authenticationPolicy requires unlock, Siri AI might show it without asking for an unlock first. Don't make that policy your only guard on sensitive data yet. developer.apple.com/document…
56
GitHub and Microsoft's MDASH pilot: 9,791 raw AI security findings on six projects became 99 private reports, each with a suggested fix. As of 15 November, maintainers had fixed 55, and 14 of those were in a release. Send a verified fix, not another scan. github.blog/open-source/main…
25
The useful question about sandboxing a coding agent isn't how strong the box is. It's which of the agent's actions actually go through it. Simon Willison's write-up of the "external sandbox" pattern, published with Prime Radiant this week, makes that unusually easy to see, because the same sandbox ends up giving three agents three different levels of protection. The pattern is simple. The agent keeps running on your machine, and every command it wants to execute goes to a separate Linux sandbox over a localhost API. The sandbox only sees the folders you mount and has no network unless you switch on an allow-list proxy. Keeping the agent outside the box also means it can't modify itself or its own environment. Now look at how each agent plugs in. Pi swaps its bash, read, write, edit, grep, find and ls tools for sandboxed versions. Codex sends its process and filesystem operations, including its native patch tool. Claude Code, through a shell prefix variable, sends only its Bash commands. Its own Read and Edit tools still run on the host, and the write-up says so plainly: the mount rules limit what Bash can touch, but Claude can still read and edit files on your Mac directly. Same sandbox, very different boundary. The strength of the box is irrelevant for any action that never enters it. That generalises well beyond these three agents. Every agent has a tool surface: shell, native file tools, MCP servers, hooks, web fetch and whatever plugins you've added. A sandbox protects exactly the part of that surface routed through it. So the first job when you set one up is to list every tool the agent can call and mark which ones cross the boundary. Anything unmarked runs with your user account's permissions. The second property is what happens on failure. Pi is run with its built-in tools disabled, so if the extension fails to load there's nothing left that runs on your computer, and if the sandbox can't be reached the tools return an error instead of quietly falling back to the defaults. A sandbox that falls back to the host when something breaks is arguably worse than none, because you stop watching closely while the agent runs unconfined. Fail closed, and test it by stopping the sandbox mid-session and seeing what the agent can still do. The third is secrets. The proxy supports credential replacement: code in the sandbox sends a placeholder token, and the proxy on the host swaps in the real one for hosts you've allowed. The agent makes authenticated calls without the key ever entering its context or the sandbox. That matters because anything the model can read, a prompt injection can ask it to repeat. The write-up is honest about the limit too: an allowed host could echo the credential back in a response, so keep those rules to trusted services with narrow methods and paths. The qualification I'd add is that a read-write mount is itself a path back to the host. The project folder is mounted precisely so the agent can change it, and plenty of things in a project folder get executed later by you, outside any sandbox: build scripts, test config, package manifests, git hooks. Isolation stops the agent's commands touching your SSH keys today. It doesn't stop it leaving something in the repo that your own unsandboxed tooling runs tomorrow. That risk still lands on review, so read the files that execute, not only the code you asked for. The pitch for any sandbox is the isolation technology. What decides whether it protects you is more boring: which tools are routed through it, what happens when it's unreachable, and where the secrets live. Those three are worth checking before you trust any agent setup, this one included. They're also why a model-judged approval check and a sandbox aren't substitutes. One decides whether an action looks safe; the other limits the damage when that judgement is wrong. blog.primeradiant.com/extern…
2
1
46
The new OpenJDK RCE (CVE-2026-114938) depends on your CPU as well as your JDK. Malformed Base64 can corrupt memory in the AVX-512 VBMI decoder on JDK 17.0.6+. ARM64 and pre-Ice Lake/Zen 4 x86 aren't affected. Until you patch: -XX:-UseBASE64Intrinsics access.redhat.com/security/v…
60
.NET 11 raises the x86/x64 baseline to x86-64-v2 (SSE4.2, POPCNT, CX16). On a CPU without those, the runtime won't start at all. Worth checking old build agents, and VMs set to a generic CPU model rather than host passthrough, before upgrading. learn.microsoft.com/en-us/do…
19
In October, Linear merged 53% of PRs with only an agent review and the author's approval, up from about 2.5% in early 2026. The bit worth copying is the line they drew: auth, infra and deploy config always need a second human, enforced before merge. linear.app/data/code-review
1
25
Most of the work to get an iPhone app ready for iPhone Duo isn't foldable design. It's deleting one assumption that has been quietly true on iPhone for years: your app's size is fixed for the whole session. Apple's preparation guide makes this clear without quite saying it. Apps built with the iOS 27 SDK resize dynamically, so folding or unfolding the device resizes the app in the middle of whatever someone is doing. Then look at the list of things it tells you to fix. Replace UIScreen.main.bounds with the view or window bounds. Don't read the size once at launch or in viewIsAppearing. Don't use device orientation to decide layout. Don't treat regular width as meaning iPad. Remove checks against specific screen heights. Those look like five separate problems, but they're one bug. Each is code that read a value it believed couldn't change, then kept it. On a normal iPhone that belief held, and that's why the code survived review. The screen was the window, the size was known when the app launched, and orientation was a fair proxy for shape. iPad multitasking broke all of that years ago, but plenty of iPhone-only apps never ran there, so nothing ever proved them wrong. A fold does. So does resizable iPhone Mirroring on macOS 27, which Apple lists alongside Duo as a way an iPhone app can end up with any combination of size classes. This isn't only about people who buy one device. Thinking of it as a data-flow problem rather than a layout problem changes how you search for it. Apple's first step is to run the app resizability skill in Xcode, which scans for the patterns above, and the guide is honest that it finds most issues but not all. That's what you'd expect. A scan can find where a stale value comes from, such as a UIScreen.main call or an orientation check. It's much worse at finding where that value went. A column count worked out on first appearance and stored on a view model, an image cache keyed to the launch width, a layout constant computed once in a singleton: none of those mention the screen at the point where they go wrong. They're downstream copies of a number that's now out of date, and they only break after a fold. So the fix isn't to swap every UIScreen.main for view bounds and call it done. It's to stop storing derived geometry at all, or to recompute it whenever size changes. That means size-dependent layout in layoutSubviews or viewDidLayoutSubviews, viewWillTransition(to:with:) for work that has to run on a resize, and GeometryReader or onGeometryChange in SwiftUI. If a value depends on size, it should be cheap enough to recompute instead of cached. The same reasoning applies to testing. Launching the app in each pose and checking how it looks tests three static screens, and a cold launch at the right size is the one case the old code already handles. The bugs live in the transition. Fold while a sheet is open, halfway down a long list, or with the keyboard up and half a message typed, then check that the content, scroll position and focus all survived. The iPhone Duo simulator in Xcode 27.1 can do this without the hardware, so it's a test you can actually run. There's a fair qualification. Not every app needs a bespoke two-pane layout for the inner display. Apps built with the iOS 26 SDK still run, just centred with empty space around them when the device is open, and with the iOS 27.1 SDK the system moves toolbars and tab bars for you. The polish is optional. Correctness under resize isn't, because once you build with the iOS 27 SDK your app will be resized, and the question is only whether your code notices. The lesson goes further than one device. Any value you treat as a constant because it has never changed is a cache with no invalidation, and the day the platform changes it, the bug turns up somewhere a grep won't find. developer.apple.com/iphone-d…
9
6
377
Dan πŸ‡¬πŸ‡§ retweeted
Claude Code on desktop now supports iPhone Duo in the iOS simulator (public beta). You can run your app on Duo next to your conversation and Claude can fold and unfold the device to test each layout.
334
579
244
15,287
1,099,196
SQLite 3.54.1: json_object('a', (select json_array(1))) now returns {"a":"[1]"}, not {"a":[1]}. 3.54.0 was the bug. Only a value straight from a JSON function stays JSON, and a subquery result is text. Wrap it: json((select ...)). simonwillison.net/2026/Nov/1…
1
20
Xcode now comes as an Apple Encrypted Archive (.aea), and Apple says 27.3 is the last release supporting .xip. If CI or a setup script installs Xcode from a .xip, change it before the next version. archiveutil extractXcodeAEA unpacks the new format. developer.apple.com/document…
1
53
EF Core split queries run one SQL query per included collection. If rows change in between, EF Core 10 and earlier quietly returned an empty collection. EF Core 11 throws DbQueryConcurrencyException. Retry, use a snapshot transaction, or AsSingleQuery(). learn.microsoft.com/en-us/ef…
15
When a coding agent tests against a fake, the fake becomes its definition of done. Whatever the fake gets wrong, the agent learns to get wrong as well, and it won't feel any doubt about it. AWS Emulator, which went GA on 11 November, is a good case for thinking this through, because AWS has been unusually honest about where it stops. It serves AWS APIs locally, built from the same API models the SDKs use, and AWS pitches it partly at coding agents: a copy per agent, iterate offline, fix the code before you deploy. The security page is the part I'd read first. The emulator never denies a request signed with its own key. It doesn't check KMS key policies or S3 bucket policies, and it has no cross-account or cross-Region behaviour. So a request AWS would deny can succeed locally. Fidelity is published per service as tests passed out of total, and the evaluation suite says it plainly: behaviour that no fidelity test covers is not verified. A human using a fake carries a rough mental model of what's fake. You know the local stack won't tell you about IAM, so you read a green run as "the logic works" and expect to fight permissions on deploy. An agent reading the same green tick has none of that context unless you give it. It was told to make the tests pass, they pass, and it reports done. That isn't the agent being careless. The oracle can't produce the failure, so the agent never sees it. It goes further than one missed permission. If AccessDenied can never happen locally, the agent never exercises the code that handles it. The retry, logging or fallback around that path goes untested, because nothing in the loop can trigger it. The loud gaps are the friendly ones: an unsupported operation returns 501 NotImplemented and the test fails straight away. The quiet ones are an operation that's implemented but behaves slightly differently from the real service, and policy checks that always say yes. .NET developers have seen this before. Microsoft's EF Core testing guidance says using the in-memory provider as a database fake is highly discouraged: transactions are ignored, raw SQL is unsupported, and queries can behave differently from your real database. Even SQLite standing in for SQL Server differs on case sensitivity by default. The lesson there was never "don't use fakes". It was that a fake passes tests your real system fails, and you need to know which ones. So treat an emulator result as a claim with a scope, and write the scope down where the agent will read it. In your AGENTS .md or equivalent, say what a local pass means: API shapes and control-plane logic, not permissions, policies or anything cross-account. List the AWS operations your code calls and check each against the published fidelity tests. For the ones nothing covers, run the same test against the emulator and a real sandbox account and compare. Then keep a small contract suite against real AWS for exactly the things the emulator says it can't judge, and make it part of done for any change that touches IAM or resource policies. There's a real trade-off. Real-account tests are slower, cost money and need credentials in CI, which is its own risk. That's why the suite should be small and aimed at the documented gaps rather than a second copy of everything. None of this is a case against the emulator either. Fast, isolated, offline feedback is exactly what agents need to iterate well, and separate state per copy suits running several at once. The point is narrower. A fake tells you what it was tested to tell you. When you were the one reading the result, you could remember the rest. When an agent reads it, the limits have to live in the repo, or as far as the agent is concerned they don't exist. docs.aws.amazon.com/emulator…
5
1
4
159