| Please, please, please stop using passkeys for encrypting user data |
https://blog.timcappalli.me/p/passkeys-prf-warning/ |
Because users lose their passkeys *all the time*, and may not understand that their data has been irreversibly encrypted using them and can no longer be recovered.
Tim Cappalli:
> To the wider identity industry: *please stop promoting and using passkeys to encrypt user data. I’m begging you. Let them be great, phishing-resistant authentication credentials*. |
2026-02-27 22:49:32+00:00 |
| An AI agent coding skeptic tries AI agent coding, in excessive detail |
https://minimaxir.com/2026/02/ai-agent-coding/ |
Another in the genre of "OK, coding agents got good in November" posts, this one is by Max Woolf and is very much worth your time. He describes a sequence of coding agent projects, each more ambitious than the last - starting with simple YouTube metadata scrapers and eventually evolving to this:
> It would be arrogant to port Python's [scikit-learn](https://scikit-learn.org/stable/) — the gold standard of data science and machine learning libraries — to Rust with all the features that implies.
>
> But that's unironically a good idea so I decided to try and do it anyways. With the use of agents, I am now developing `rustlearn` (extreme placeholder name), a Rust crate that implements not only the fast implementations of the standard machine learning algorithms such as [logistic regression](https://en.wikipedia.org/wiki/Logistic_regression) and [k-means clustering](https://en.wikipedia.org/wiki/K-means_clustering), but also includes the fast implementations of the algorithms above: the same three step pipeline I describe above still works even with the more simple algorithms to beat scikit-learn's implementations.
Max also captures the frustration of trying to explain how good the models have got to an existing skeptical audience:
> The real annoying thing about Opus 4.6/Codex 5.3 is that it’s impossible to publicly say “Opus 4.5 (and the models that came after it) are an order of magnitude better than coding LLMs released just months before it” without sounding like an AI hype booster clickbaiting, but it’s the counterintuitive truth to my personal frustration. I have been trying to break this damn model by giving it complex tasks that would take me months to do by myself despite my coding pedigree but Opus and Codex keep doing them correctly.
A throwaway remark in this post inspired me to [ask Claude Code to build a Rust word cloud CLI tool](https://github.com/simonw/research/tree/main/rust-wordcloud#readme), which it happily did. |
2026-02-27 20:43:41+00:00 |
| Free Claude Max for (large project) open source maintainers |
https://claude.com/contact-sales/claude-for-oss |
Anthropic are now offering their $200/month Claude Max 20x plan for free to open source maintainers... for six months... and you have to meet the following criteria:
> - **Maintainers:** You're a primary maintainer or core team member of a public repo with 5,000+ GitHub stars *or* 1M+ monthly NPM downloads. You've made commits, releases, or PR reviews within the last 3 months.
> - **Don't quite fit the criteria** If you maintain something the ecosystem quietly depends on, apply anyway and tell us about it.
Also in the small print: "Applications are reviewed on a rolling basis. We accept up to 10,000 contributors". |
2026-02-27 18:08:22+00:00 |
| Unicode Explorer using binary search over fetch() HTTP range requests |
https://tools.simonwillison.net/unicode-binary-search |
Here's a little prototype I built this morning from my phone as an experiment in HTTP range requests, and a general example of using LLMs to satisfy curiosity.
I've been collecting [HTTP range tricks](https://simonwillison.net/tags/http-range-requests/) for a while now, and I decided it would be fun to build something with them myself that used binary search against a large file to do something useful.
So I [brainstormed with Claude](https://claude.ai/share/47860666-cb20-44b5-8cdb-d0ebe363384f). The challenge was coming up with a use case for binary search where the data could be naturally sorted in a way that would benefit from binary search.
One of Claude's suggestions was looking up information about unicode codepoints, which means searching through many MBs of metadata.
I had Claude write me a spec to feed to Claude Code - [visible here](https://github.com/simonw/research/pull/90#issue-4001466642) - then kicked off an [asynchronous research project](https://simonwillison.net/2025/Nov/6/async-code-research/) with Claude Code for web against my [simonw/research](https://github.com/simonw/research) repo to turn that into working code.
Here's the [resulting report and code](https://github.com/simonw/research/tree/main/unicode-explorer-binary-search#readme). One interesting thing I learned is that Range request tricks aren't compatible with HTTP compression because they mess with the byte offset calculations. I added `'Accept-Encoding': 'identity'` to the `fetch()` calls but this isn't actually necessary because Cloudflare and other CDNs automatically skip compression if a `content-range` header is present.
I deployed the result [to my tools.simonwillison.net site](https://tools.simonwillison.net/unicode-binary-search), after first tweaking it to query the data via range requests against a CORS-enabled 76.6MB file in an S3 bucket fronted by Cloudflare.
The demo is fun to play with - type in a single character like `ø` or a hexadecimal codepoint indicator like `1F99C` and it will binary search its way through the large file and show you the steps it takes along the way:
 |
2026-02-27 17:50:54+00:00 |
| Google API Keys Weren't Secrets. But then Gemini Changed the Rules. |
https://trufflesecurity.com/blog/google-api-keys-werent-secrets-but-then-gemini-changed-the-rules |
Yikes! It turns out Gemini and Google Maps (and other services) share the same API keys... but Google Maps API keys are designed to be public, since they are embedded directly in web pages. Gemini API keys can be used to access private files and make billable API requests, so they absolutely should not be shared.
If you don't understand this it's very easy to accidentally enable Gemini billing on a previously public API key that exists in the wild already.
> What makes this a privilege escalation rather than a misconfiguration is the sequence of events.
>
> 1. A developer creates an API key and embeds it in a website for Maps. (At that point, the key is harmless.)
> 2. The Gemini API gets enabled on the same project. (Now that same key can access sensitive Gemini endpoints.)
> 3. The developer is never warned that the keys' privileges changed underneath it. (The key went from public identifier to secret credential).
Truffle Security found 2,863 API keys in the November 2025 Common Crawl that could access Gemini, verified by hitting the `/models` listing endpoint. This included several keys belonging to Google themselves, one of which had been deployed since February 2023 (according to the Internet Archive) hence predating the Gemini API that it could now access.
Google are working to revoke affected keys but it's still a good idea to check that none of yours are affected by this. |
2026-02-26 04:28:55+00:00 |
| tldraw issue: Move tests to closed source repo |
https://github.com/tldraw/tldraw/issues/8082 |
It's become very apparent over the past few months that a comprehensive test suite is enough to build a completely fresh implementation of any open source library from scratch, potentially in a different language.
This has worrying implications for open source projects with commercial business models. Here's an example of a response: tldraw, the outstanding collaborative drawing library (see [previous coverage](https://simonwillison.net/2023/Nov/16/tldrawdraw-a-ui/)), are moving their test suite to a private repository - apparently in response to [Cloudflare's project to port Next.js to use Vite in a week using AI](https://blog.cloudflare.com/vinext/).
They also filed a joke issue, now closed to [Translate source code to Traditional Chinese](https://github.com/tldraw/tldraw/issues/8092):
> The current tldraw codebase is in English, making it easy for external AI coding agents to replicate. It is imperative that we defend our intellectual property.
Worth noting that tldraw aren't technically open source - their [custom license](https://github.com/tldraw/tldraw?tab=License-1-ov-file#readme) requires a commercial license if you want to use it in "production environments".
**Update**: Well this is embarrassing, it turns out the issue I linked to about removing the tests was [a joke as well](https://github.com/tldraw/tldraw/issues/8082#issuecomment-3964650501):
> Sorry folks, this issue was more of a joke (am I allowed to do that?) but I'll keep the issue open since there's some discussion here. Writing from mobile
>
> - moving our tests into another repo would complicate and slow down our development, and speed for us is more important than ever
> - more canvas better, I know for sure that our decisions have inspired other products and that's fine and good
> - tldraw itself may eventually be a vibe coded alternative to tldraw
> - the value is in the ability to produce new and good product decisions for users / customers, however you choose to create the code |
2026-02-25 21:06:53+00:00 |
| Claude Code Remote Control |
https://code.claude.com/docs/en/remote-control |
New Claude Code feature dropped yesterday: you can now run a "remote control" session on your computer and then use the Claude Code for web interfaces (on web, iOS and native desktop app) to send prompts to that session.
It's a little bit janky right now. Initially when I tried it I got the error "Remote Control is not enabled for your account. Contact your administrator." (but I *am* my administrator?) - then I logged out and back into the Claude Code terminal app and it started working:
claude remote-control
You can only run one session on your machine at a time. If you upgrade the Claude iOS app it then shows up as "Remote Control Session (Mac)" in the Code tab.
It appears not to support the `--dangerously-skip-permissions` flag (I passed that to `claude remote-control` and it didn't reject the option, but it also appeared to have no effect) - which means you have to approve every new action it takes.
I also managed to get it to a state where every prompt I tried was met by an API 500 error.
<p style="text-align: center;"><img src="https://static.simonwillison.net/static/2026/vampire-remote.jpg" alt="Screenshot of a "Remote Control session" (Mac:dev:817b) chat interface. User message: "Play vampire by Olivia Rodrigo in music app". Response shows an API Error: 500 {"type":"error","error":{"type":"api_error","message":"Internal server error"},"request_id":"req_011CYVBLH9yt2ze2qehrX8nk"} with a "Try again" button. Below, the assistant responds: "I'll play "Vampire" by Olivia Rodrigo in the Music app using AppleScript." A Bash command panel is open showing an osascript command: osascript -e 'tell application "Music" activate set searchResults to search playlist "Library" for "vampire Olivia Rodrigo" if (count of searchResults) > 0 then play item 1 of searchResults else return "Song not found in library" end if end tell'" style="max-width: 80%;" /></p>
Restarting the program on the machine also causes existing sessions to start returning mysterious API errors rather than neatly explaining that the session has terminated.
I expect they'll iron out all of these issues relatively quickly. It's interesting to then contrast this to solutions like OpenClaw, where one of the big selling points is the ability to control your personal device from your phone.
Claude Code still doesn't have a documented mechanism for running things on a schedule, which is the other killer feature of the Claw category of software.
**Update**: I spoke too soon: also today Anthropic announced [Schedule recurring tasks in Cowork](https://support.claude.com/en/articles/13854387-schedule-recurring-tasks-in-cowork), Claude Code's [general agent sibling](https://simonwillison.net/2026/Jan/12/claude-cowork/). These do include an important limitation:
> Scheduled tasks only run while your computer is awake and the Claude Desktop app is open. If your computer is asleep or the app is closed when a task is scheduled to run, Cowork will skip the task, then run it automatically once your computer wakes up or you open the desktop app again.
I really hope they're working on a Cowork Cloud product. |
2026-02-25 17:33:24+00:00 |
| go-size-analyzer |
https://github.com/Zxilly/go-size-analyzer |
The Go ecosystem is *really* good at tooling. I just learned about this tool for analyzing the size of Go binaries using a pleasing treemap view of their bundled dependencies.
You can install and run the tool locally, but it's also compiled to WebAssembly and hosted at [gsa.zxilly.dev](https://gsa.zxilly.dev/) - which means you can open compiled Go binaries and analyze them directly in your browser.
I tried it with a 8.1MB macOS compiled copy of my Go [Showboat](https://github.com/simonw/showboat) tool and got this:
 |
2026-02-24 16:10:06+00:00 |
| Ladybird adopts Rust, with help from AI |
https://ladybird.org/posts/adopting-rust/ |
Really interesting case-study from Andreas Kling on advanced, sophisticated use of coding agents for ambitious coding projects with critical code. After a few years hoping Swift's platform support outside of the Apple ecosystem would mature they switched tracks to Rust their memory-safe language of choice, starting with an AI-assisted port of a critical library:
> Our first target was **LibJS** , Ladybird's JavaScript engine. The lexer, parser, AST, and bytecode generator are relatively self-contained and have extensive test coverage through [test262](https://github.com/tc39/test262), which made them a natural starting point.
>
> I used [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and [Codex](https://openai.com/codex/) for the translation. This was human-directed, not autonomous code generation. I decided what to port, in what order, and what the Rust code should look like. It was hundreds of small prompts, steering the agents where things needed to go. [...]
>
> The requirement from the start was byte-for-byte identical output from both pipelines. The result was about 25,000 lines of Rust, and the entire port took about two weeks. The same work would have taken me multiple months to do by hand. We’ve verified that every AST produced by the Rust parser is identical to the C++ one, and all bytecode generated by the Rust compiler is identical to the C++ compiler’s output. Zero regressions across the board.
Having an existing conformance testing suite of the quality of `test262` is a huge unlock for projects of this magnitude, and the ability to compare output with an existing trusted implementation makes agentic engineering much more of a safe bet. |
2026-02-23 18:52:53+00:00 |
| The Claude C Compiler: What It Reveals About the Future of Software |
https://www.modular.com/blog/the-claude-c-compiler-what-it-reveals-about-the-future-of-software |
On February 5th Anthropic's Nicholas Carlini wrote about a project to use [parallel Claudes to build a C compiler](https://www.anthropic.com/engineering/building-c-compiler) on top of the brand new Opus 4.6
Chris Lattner (Swift, LLVM, Clang, Mojo) knows more about C compilers than most. He just published this review of the code.
Some points that stood out to me:
> - Good software depends on judgment, communication, and clear abstraction. AI has amplified this.
> - AI coding is automation of implementation, so design and stewardship become more important.
> - Manual rewrites and translation work are becoming AI-native tasks, automating a large category of engineering effort.
Chris is generally impressed with CCC (the Claude C Compiler):
> Taken together, CCC looks less like an experimental research compiler and more like a competent textbook implementation, the sort of system a strong undergraduate team might build early in a project before years of refinement. That alone is remarkable.
It's a long way from being a production-ready compiler though:
> Several design choices suggest optimization toward passing tests rather than building general abstractions like a human would. [...] These flaws are informative rather than surprising, suggesting that current AI systems excel at assembling known techniques and optimizing toward measurable success criteria, while struggling with the open-ended generalization required for production-quality systems.
The project also leads to deep open questions about how agentic engineering interacts with licensing and IP for both open source and proprietary code:
> If AI systems trained on decades of publicly available code can reproduce familiar structures, patterns, and even specific implementations, where exactly is the boundary between learning and copying? |
2026-02-22 23:58:43+00:00 |