-
Security advisory permissions are now generally available
(5 min | 1494 words)
GitHub Enterprise Server 3.23 release candidate
(5 min | 1625 words)
Quoting Ravi Vakil
(3 min | 780 words)
Quoting Levent Alpöge
(3 min | 842 words)
I believe I have, working with Claude, discovered a proof of the Riemann Hypothesis. In fact, the method easily extends much further, resolving the so-called Generalized Riemann Hypothesis, and I expect, with more time, the Extended Riemann Hypothesis too. Claude and I have also formalized the arguments without assumptions. It is natural to feel that this is an end, in my case a loss of a principal guiding light, but what I saw during the course of progress so amazed me that I believe it is one dawn across science of something far greater. [...]
Claude and I have had a great time together with such breadth in recent months, but this time Claude far outpaced me near the finish line. No, Claude flew, and danced, and sparkled near that finish line.
— Levent Alpöge, alpo.ge/remark.pdf
Tags: anthropic, claude, generative-ai, mathematics, ai, llms, levent-alpoge
Pin your favorite repositories to your dashboard
(4 min | 1344 words)
Combatting adversarial distillation
(0 min | words)
llm-gemini 0.38.1
(3 min | 858 words)
Release: llm-gemini 0.38.1
Gemini 4 Carbon only supports low, medium and high reasoning levels - but Gemini 4 Hydrogen and Gemini 4 Neon both have an extra xhigh level.
I missed that when I added those models to the llm-gemini plugin, which is now fixed in this dot release.
The xhigh setting for Hydrogen makes a significant difference. I updated my Gemini 4 comparison grid - note how Hydrogen at high used 5,311 output tokens and cost 3.99 cents, but the same model at xhigh used 31,477 output tokens, cost 23.61 cents, and produced a pelican that's competitive with Gemini 4 Neon:
Tags: gemini, llm, llm-reasoning, pelican-riding-a-bicycle, ai, llms, google, generative-ai
Token fraud is here and it’s BAD (YouTube)
(3 min | 953 words)
Token fraud is here and it’s BAD (YouTube)
ChatPRD, an AI platform that helps product managers "turn an idea into a spec". The product has been live since the GPT-4 era, and Claire has been building it in public for much of that time.
In this YouTube video (see also the accompanying Twitter post) Claire describes the flood of token fraud she has seen from groups abusing the product's free trial, sometimes just to get free AI usage but often to resell tokens or run other commercial enterprises on top of the ChatPRD agent.
I am funding a international Roblox and Fortnite map studio. They run a loop of free trials and promo codes and then tunnel to my agent and use it to build Roblox and Fortnite maps.
Apparently one of the common prompts Claire saw running through her agent involved SVGs of pelicans riding bicycles! Presumably the token scammers are using that to help sniff the underlying models - different model families have a definite signature, and I've used it like this in the past to try and guess the identity of stealth preview models on platforms like OpenRouter.
Claire is winding down her free trials entirely, which sadly looks like the right decision in the face of this abuse.
Tags: youtube, ai, generative-ai, llms, pelican-riding-a-bicycle, ai-misuse
GitHub Desktop now supports multiple accounts per host
(5 min | 1418 words)
Improvements on the pull request overview in public preview
(7 min | 2183 words)
Hebbia sees improvements in financial research with GPT-6 Astra
(0 min | words)
Can AI help scientists identify promising drug candidates?
(0 min | words)
-
PostgreSQL 19 Released
(4 min | 1079 words)
PostgreSQL 19 Released
thanks mainly to the flurry of issues that the PostgreSQL team needed to address as part of the ongoing AI-reported vulnerability apocalypse.
This release was definitely worth the wait. My favorite new feature is this one:
For applications that send reads to standbys, PostgreSQL 19 adds "read-your-writes" consistency with the new WAIT FOR LSN command. A session on a standby can use WAIT FOR LSN to wait until the standby has replayed the write-ahead log (WAL) up to a specific log sequence number (LSN) before running a query, so the application can read data it just wrote on the primary.
In practice, that looks like this:
UPDATE movie SET genre = 'Dramatic' WHERE genre = 'Drama';
SELECT pg_current_wal_insert_lsn();
That returns a value like 0/0306EE20. Store that somewhere (a signed cookie would work) such that on a subsequent request your application can do:
WAIT FOR LSN '0/0306EE20' WITH (TIMEOUT '0.1s');
SELECT * FROM movie WHERE genre = 'Drama';
The timeout is optional - if you provide one you'll get an error if the replica you are talking to doesn't catch up within the specified time.
I first encountered this pattern in Wikipedia, which has a hand-rolled version of this built against MySQL replication:
In addition to this, MediaWiki attempts to ensure that the user sees events occurring on the wiki in chronological order. A few seconds of lag can be tolerated, as long as the user sees a consistent picture from subsequent requests. This is done by saving the primary binlog position in the session, and then at the start of each request, waiting for the replica to catch up to that position before doing any reads from it.
Here's the relevant MediaWiki code, which these days uses MySQL's WAIT_FOR_EXECUTED_GTID_SET() function and falls back to MASTER_POS_WAIT().
Via Lobste.rs
Tags: mysql, postgresql, replication, scaling, wikipedia, ai-security-research
Enterprise Live Migrations from Azure DevOps generally available
(7 min | 2030 words)
Red Hat Enterprise Linux runner images now generally available
(5 min | 1357 words)
S3 audit log streaming with OpenID Connect expands to GHE.com
(4 min | 1328 words)
How OpenAI’s Performance Factory keeps ChatGPT fast
(0 min | words)
Wait for pull request events with GitHub CLI
(5 min | 1481 words)
Explore the Codex Security Plugin
(0 min | words)
See PR scans in action
(0 min | words)
Get started with Daybreak Blue
(0 min | words)
Deploying Daybreak Red
(0 min | words)
-
llm-gemini 0.38
(3 min | 1026 words)
Release: llm-gemini 0.38
Today Google introduced Gemini 4 Neon. I wrote recently about how confusing the pricing for the Gemini 4 series was - Neon has somehow made this even worse.
Previously the Gemini 4 lineup was Hydrogen, Argon, and Carbon - where Argon and Carbon were the same price, and Hydrogen was 3/4 of that price now but will be 1/4 of that price when the other two double an 1st December once their initial discount pricing expires.
The Neon announcement pretends that Argon doesn't exist. Here's their new image explaining the model line-up:
So the lineup now, from most to least expensive, is Carbon, Neon, Hydrogen.
Except Carbon is currently half price, so right now Neon ($3/million input, $15/million output) is the most expensive of the three - then Carbon ($2/$10), then Hydrogen ($1.50/$7.50). I guess this will make more sense when Carbon doubles to $4/$20 on December 1st.
I ran some pelicans through the three reasoning levels for Neon - low, medium, high.
I dropped Argon from my Gemini 4 comparison grid - here's the new Gemini 4 lineup, where the Neon pelicans do look better than Hydrogen and worse than Carbon:
As I've done with several recent models, I also fired the following prompt against Gemini 4 Neon on "extra" effort level in Google Antigravity:
Make a three js animation where yonkers stands up as a big mech (cool stand up motion) and stomps around manhattan and queens and Brooklyn, use openstreetmap mapping data
Here's the result.
Tags: yonkers-rising, gemini, llm, pelican-riding-a-bicycle, ai, llms, llm-release, google, generative-ai
Connect Supabase, Box, Calendly, and more to Copilot
(5 min | 1560 words)
Gemini 4 Neon in GitHub Copilot
(5 min | 1501 words)
datasette-arrows 0.1a0
(3 min | 925 words)
Security risk assessments run automatically on GitHub Team
(4 min | 1279 words)
Customize GitHub Copilot for your team
(5 min | 1539 words)
Quoting Daniel Stenberg
(3 min | 832 words)
During the time these agents converted 185,000 lines of C code into 340,000 lines of Rust code (I counted), we merged over 300 commits in the actual curl project. We actually improved curl during these a little more than three weeks. A little over 200 bugfixes actually. 200 bugfixes that none of those rust rewrites have. We also fixed a few vulnerabilities. In another month we have done another 200 and maybe fixed a few more vulnerabilities. Will these clones keep up?
— Daniel Stenberg, Actual curl rewrites in Rust
Tags: daniel-stenberg, curl, rust, security, coding-agents, c, ai, llms, generative-ai, vibe-porting
The PSF end-of-year fundraiser
(3 min | 861 words)
The PSF end-of-year fundraiser
If your company or your work benefits from Python, please consider donating this year!
The PSF looks after the IP behind Python, operates PyPI, sponsors core developer sprints, supports community events (including running PyCon US every year), and employs a small and excellent staff team to keep everything running.
We also operate the Developers in Residence program, which now includes three security developers (welcome, Brett Smith) focused on helping secure Python, PyPI, and the wider ecosystem.
Tags: python, psf
How Sumitomo Life’s leaders helped teams adopt ChatGPT Enterprise
(0 min | words)
Research acceleration: The jagged frontier
(0 min | words)
Inside the Codex sandbox
(0 min | words)
Managing frontier AI risk: From training to deployment
(0 min | words)
The Silent Consensus
(0 min | words)
Advancing chip design with OpenAI models
(0 min | words)
Le Groupe Figaro and OpenAI partner to bring Le Figaro journalism to ChatGPT
(0 min | words)
-
External sandboxes for coding agents
(4 min | 1053 words)
External sandboxes for coding agents
I worked on this project with Prime Radiant, the AI research lab behind Superpowers and other projects.
My post on the Prime Radiant blog introduces the external sandbox pattern, where code executed by the agent runs inside a dedicated sandbox while the agent itself lives outside of that sandbox.
To demonstrate this pattern we've released three sandbox server implementations:
external-sandbox-v86 runs a Node.js server which then uses v86 to run Alpine Linux inside WebAssembly.
external-sandbox-container is a Python web server which runs the sandbox in Alpine Linux inside an Apple Containers instance.
external-sandbox-quicksand is another Python web server, this time using Microsoft's Quicksand sandboxing library, which bundles QEMU and Alpine Linux in a Python package!
Each of these implementations offers the same localhost API. You can then configure Pi, Claude Code, or Codex to send API calls to that sandbox any time they want to execute code.
The sandboxes also include an optional HTTP/HTTPS allow-list proxy, so you can control exactly which hosts your agent's code is allowed to communicate with - plus a credential replacement mechanism to make authenticated API calls without sharing a secret with the agent. Here's the UI you can use to reconfigure that proxy while the sandbox is still running:
I continue to be fascinated by the challenge of safely running untrusted code. This external sandbox pattern provides a neat way to experiment with different approaches.
Tags: sandboxing, security, ai, webassembly, generative-ai, llms, coding-agents, claude-code, codex, pi
GPT‑6.2 Astra and GPT‑6.2 Sol
(4 min | 1275 words)
GPT‑6.2 Astra and GPT‑6.2 Sol
We’re introducing GPT‑6.2 Astra, our new frontier model for your hardest projects, and GPT‑6.2 Sol, our efficient, versatile model for everyday work.
They're available in the API as gpt-6.2-astra and gpt-6.2-sol. I shipped LLM 0.38 with support for the new models.
6.2 Astra is 80% of the price of 6 Astra - $8/MTok input and $40/MTok output, the same price as Claude Fable 5.2 (which was also 80% of its predecessor). 6 Astra and Fable 5 were both $10/$50. The cached price is an even bigger discount - $0.40/million compared to $1/million for the older model. This is great news for longer running agentic sessions.
GPT-6.2 Sol is the same $2/$10 price as 6.1 Sol and 6 Sol - which are half the price of GPT-5.6 Sol ($4/$20).
Here are the pelicans for GPT-6.2 Sol and for GPT-6.2 Astra. The 6.2 Astra max pelican looks like this:
I have a full comparison grid here, but here's how the high/xhigh/max pelicans compare with the previous Sol and Astra releases:
I also ran my most recent benchmark prompt against the two models, using "Ultra' effort levels in the Codex CLI:
Make a three js animation where yonkers stands up as a big mech (cool stand up motion) and stomps around manhattan and queens and Brooklyn, use openstreetmap mapping data
Here's Sol and here's Astra. Neither of them did a good enough job of morphing Yonkers into a big mech, at least in comparison to Claude Fable 5.2 and Gemini 4 Carbon.
This video showing the Astra and Sol animations playing out at the same time:
I created that video using GPT-6.2 Astra (Ultra) in the Codex desktop app by prompting:
https://static.simonwillison.net/static/2026/yonkers-gpt-6.2-astra-ultra/index.html and https://static.simonwillison.net/static/2026/yonkers-gpt-6.2-sol-ultra/index.html are two videos of the same thing by two different models
I need a video of the first 10 seconds where the top half of the video plays the first and the bottom half plays the second
I need an overlaid label of "GPT-6.2 Astra" on the top half and "GPT-6.2 Sol" on the bottom half. These labels should be tastefully positioned.
Make the video square and 2000x2000 pixels
Then later:
OK make it 20s
Here's the exported transcript.
The buzz around these new models is mixed at the moment. Astra 6.2 isn't scoring quite as high as Fable 5.2 on various benchmarks, and I've seen a few complaints that its communication style can be confusing. Theo Browne's review (in the form of a feedback letter he sent OpenAI during pre-release) has this useful example:
When this model is working on long tasks, it can pull in a lot of subagents and manage them pretty well. It will then proceed to randomly ask you some weird internal implementation detail bullshit that you could not under any earthly circumstance understand, much less have input on.
I sent "/goal make a new level for Outer Wilds". 2 hours in, it's "blocked" because it wanted to ask me "does r24's reviewer write it's clips to 24_g521.mp4 or 24_p11.mp4?"
Tags: ai, openai, generative-ai, llms, llm-pricing, pelican-riding-a-bicycle, llm-release, theo-browne, gpt, yonkers-rising
OpenAI’s GPT-6.2 Astra and GPT-6.2 Sol now available
(5 min | 1580 words)
GitHub Copilot Fusion updates: more availability, benchmarks, and models
(5 min | 1619 words)
GitHub Copilot app, Microsoft Ignite releases
(6 min | 1776 words)
Copilot code review: Adaptive effort, secret detection, and more
(7 min | 2128 words)
MAI Code 2 and MAI Code 2 Flash in GitHub Copilot
(6 min | 1676 words)
GitHub Copilot in JetBrains, Ignite releases
(7 min | 1998 words)
Monitor GitHub Copilot activity through Microsoft Agent 365
(4 min | 1346 words)
GitHub Copilot CLI adds Microsoft Entra sign-in as a preview
(6 min | 1663 words)
Track Copilot code review outcomes in Repository insights
(5 min | 1586 words)
GitHub Copilot Evals is now in public preview
(5 min | 1641 words)
Introducing GPT-6.2 Astra and Sol
(0 min | words)
Running the full server-side Datasette Python app in the browser with service workers and Pyodide
(8 min | 2277 words)
Datasette Lite is my port of the Datasette Python application to run directly in the browser using WebAssembly and Pyodide. I've released a complete rewrite of Datasette Lite using service workers, and it's now almost indistinguishable from the real server-side application.
You can now do all of the following, using a carefully crafted URL to lite.datasette.io:
Load client-side Datasette to browse any SQLite database, JSON file, CSV file or SQL script
Select a released version of Datasette to load from PyPI
Load a specific commit, tag, or branch name from the Datasette GitHub repository
Pick from over 100 versions of SQLite to use with Datasette
Install additional Datasette plugins from PyPI or URLs to wheel files, including JavaScript visualization tools
The ability to load specific Datasette references, plugins, and SQLite versions makes this a fantastic tool for linking to demos of work-in-progress features or bug reproductions, without needing to spin up a full web server to serve that demo.
As an example, consider the following URL:
https://lite.datasette.io/?install=datasette-maplibre&url=https://gist.githubusercontent.com/simonw/39fa5d399465766039549912e2b3d291/raw/f6dfba99a75cbb8b5d9386223220eb52272767ee/demo.db&metadata=https://gist.githubusercontent.com/simonw/39fa5d399465766039549912e2b3d291/raw/f6dfba99a75cbb8b5d9386223220eb52272767ee/metadata.yml#/demo/capitals_and_countries%23map=0/4.2/180&color=continent
Follow that link and, after a short loading screen, you'll find yourself on a page that looks like this:
That's Datasette running the new datasette-maplibre plugin, loading up a database of GeoJSON shapes of countries and displaying both a combined map and individual boundary maps in a table.
Let's break down that URL to see what it's doing:
https://lite.datasette.io/
?install=datasette-maplibre
&url=https://.../demo.db
&metadata=https://.../metadata.yml
#/demo/capitals_and_countries%23map=0/4.2/180&color=continent
The ?install=datasette-maplibre installs that additional plugin from PyPI. You can pass &install=... as many times as you like to load more plugins.
&url=https://.../demo.db loads that SQLite database from the provided URL. These URLs need to have open CORS headers - I host files like this in Gists, because they provide an easy way to get open CORS headers on a web-hosted file.
&metadata=https://.../metadata.yml loads this metadata.yml file. The metadata file adds HTML descriptions to various tables, and to the Datasette homepage. Visit that homepage here for a guided tour of the other features of that plugin, all defined in the metadata file.
#/demo/capitals_and_countries%23map=0/4.2/180&color=continent is a fragment hash that turns into a location within Datasette - here it's loading the /demo/capitals_and_countries SQL view, then appending another fragment hash to it (%23 is a URL-encoded #) which tells the map plugin to zoom to a certain location and to set the color of the shapes on the map based on the continent column in the data.
That URL is doing a lot of work! I wrote more about this trick for building URL-addressable software in URL-addressable Pyodide Python environments last year.
The full set of supported URL arguments is described in the Datasette Lite README.
I've already started using Datasette Lite as part of the Datasette development process. Here's a recent issue describing a pagination bug - I posted a comment there demonstrating the old, broken behavior and the new fix using links to Datasette Lite:
Demo of the bug: https://lite.datasette.io/?ref=1.0a42&sql=https://gist.github.com/simonw/75ececf61d50e6e8d50f0c150150ee81#/data/scores?_size=2&_sort=score - click next and the second page is empty.
Here's that same page with the bug fixed (running on 1.0a43): https://lite.datasette.io/?ref=1.0a43&sql=https://gist.github.com/simonw/75ececf61d50e6e8d50f0c150150ee81#/data/scores?_size=2&_sort=score
How this works, using service workers
Datasette Lite is not a new project. I launched the first version back in 2022, originally as a bit of a joke (running server-side apps in the browser is pretty funny) but one that quickly started proving its value.
The problem with that initial version is that it was a hack. It worked by running Datasette in a Pyodide web worker, simulating requests through that stack, then injecting the resulting HTML back into the top level page using innerHTML.
This worked for basic Datasette, but meant that any feature that used JavaScript failed to work, because script tags in innerHTML don't execute, and the web worker tricks it used failed to load additional JavaScript or CSS files.
The new version takes a completely different approach based on Service Workers. These allow JavaScript to intercept HTTP requests for new pages and resources and serve them from client-side code instead.
Datasette Lite registers a service worker for the entire lite.datasette.io domain. The parent page then creates an iframe that sends requests for Datasette pages to URLs that look like this:
/app/aa94e6851595/ # the homepage (HTML)
/app/aa94e6851595/data/places # a table page (HTML)
/app/aa94e6851595/-/static/navigation-search.js # (JavaScript)
/app/aa94e6851595/-/static/app.css # (CSS)
Those are regular Datasette URLs, but with a /app/aa94e6851595/ prefix. What's that about?
The /app/<session>/ prefix is necessary because of multiple tabs.
Consider the URL above, which loads the demo instance with the datasette-maplibre plugin. That URL defines a full, custom Datasette instance. You might have that one running in a tab, then one of my other demo links running in another.
The service worker for lite.datasette.io is shared between all of those tabs. If it routed to a single instance of Datasette then every tab would share that underlying instance, no matter what plugins or other settings their URL attempted to configure.
Instead, the parent page generates a random session ID and uses it as a prefix for all of the subsequent hidden asset and page loads. The service worker can then use that session ID to route those requests back through the parent page to a web worker running a dedicated Datasette instance for that particular session.
(We still need a web worker because Pyodide in a service worker would not be able to maintain state beyond around 30 seconds, depending on the browser. There are a lot of moving parts here!)
I had Claude Fable 5.2 generate several SVG diagrams to help explain this. Here's my favorite of those, now embedded in the Datasette Lite README:
This system started life back in May as an AI research spike generated using Claude Opus 4.8. It wasn't until November (and Claude Fable 5.2) that I felt familiar enough with how it all works to confidently ship it to production!
Bonus feature: pick your version of SQLite
I added this feature last night as an off-shoot of investigating a potential bug in SQLite.
Datasette is meant to work against any released version of SQLite since 3.25 (released in September 2018). There have been 87 further releases since then.
Being able to fire up Datasette against a specific version of SQLite is really useful for demonstrating new SQLite features and debugging weird issues.
In the past I've used various tricks to get different SQLite versions running with Python on my Mac, but it's not a trivial process.
WebAssembly is perfect for this. I can load up a custom SQLite build entirely in my browser, test it there, then discard it when I close my tab.
datasette/pysqlite3-wasm-wheels is my new repository which contains WebAssembly compiled Python wheels for pysqlite3 for 163 different SQLite versions. Each version gets a file with a name like this:
pysqlite3-0.6.2-3.54.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl
That's for SQLite 3.54.1, the most recent version.
Datasette Lite now takes a special ?sqlite= URL parameter, which will accept a version number like 3.54.1, resolve the path to the corresponding wheel file, then fetch that wheel and install it into the Pyodide environment and configure Datasette to use it.
Once I'd built the wheels, I decided to have Claude Fable 5.2 build me [this bonus tool](https://datasette.github.io/pysqlite3-wasm-wheels/?versions=3.54.1,3.54.0&sql=select+json_object(%27a%27%2C+(select+json_array(1%29%29%29) for comparing a SQL query across any selected versions of SQLite. Here's an example showing how select json_object('a', (select json_array(1))) differs between SQLite 3.54.0 and 3.54.1:
This should work for every other Python app, too
Nothing about how Datasette Lite works is unique to Datasette. Almost any Python application should be able to pull the same trick - running entirely in the browser using WebAssembly and Pyodide, as a cheap way to provide preview environments, demonstrate features, and recreate bugs.
C and Rust extensions used to be a blocker for this kind of thing, but any good coding agent can compile those to Pyodide-compatible WebAssembly now. You can even publish them to PyPI as of PEP 783 in April 2026.
One catch is databases. SQLite is no problem at all, but running PostgreSQL or MySQL in WebAssembly, while possible, is still a path less trodden.
I'd love to see WebAssembly preview environments like these become a common pattern across the Python ecosystem.
For Hacker News: Full server-side Datasette Python app in the browser with service workers
Tags: javascript, projects, python, urls, datasette, webassembly, service-workers, pyodide, datasette-lite
Introducing ChatGPT for Sales
(0 min | words)
Quoting Go Proverbs
(2 min | 739 words)
Strengthening NATO and allied cyber defenses with AI
(0 min | words)
Introducing OpenAI for Chile
(0 min | words)
Astra for Law leads in legal intelligence
(0 min | words)
-
llm 0.37.3
(3 min | 872 words)
Release: llm 0.37.3
A bug fix release for LLM, mainly to cover a problem with the most recent Homebrew package of the software.
Homebrew now ships the latest SQLite, 3.54.1, which includes a fix that broke LLM's logging code.
Short version: in SQLite 3.54.0 the following SQL:
select json_object('a', (select json_array(1)))
Returns this:
{"a":[1]}
But in 3.54.1 the same query returns this:
{"a":"[1]"}
According to D. Richard Hipp:
That was a bug fix. Per the documentation, (SELECT json_array(...)) returns SQL text, not JSON. Hence the 3.54.1 behavior is correct and 3.54.0 was a bug.
The workaround looks like this:
select json_object('a', json((select json_array(1))))
Tags: llm, webassembly, sqlite, generative-ai, ai, llms, d-richard-hipp
GitHub Copilot weekly releases — November 9
(6 min | 1784 words)
Budget limit increased to 40,000 budgets per account
(4 min | 1332 words)
GitHub Copilot models deprecated on November 16, 2026
(5 min | 1447 words)
Broadening access to AI for scientists
(0 min | words)
Strengthening the fight against online child sexual abuse with new tools and support
(0 min | words)
Bulk start AI Scan for repositories
(4 min | 1338 words)
Take GitHub Mobile with you on iPhone Duo
(4 min | 1343 words)
Science at the Frontier: How scientists use ChatGPT
(0 min | words)
How Revolut raises ambition without lowering the bar
(0 min | words)
LVMH’s Media Division announces strategic partnership with OpenAI
(0 min | words)
Our first phase of embedded assessments
(0 min | words)
Advancing computer-use agents for healthcare teams
(0 min | words)
More ways to move care forward with ChatGPT for Healthcare
(0 min | words)
The King’s Trust and OpenAI launch £1m partnership
(0 min | words)
At Holiday Extras, dots get to work before anyone asks
(0 min | words)
-
datasette-maplibre 0.1a0
(3 min | 956 words)
Release: datasette-maplibre 0.1a0
The first new Datasette geospatial plugin in quite a while! This one combines the excellent MapLibre GL library with OpenFreeMap, the free vector map server operated by Zsolt Ero (you should sponsor Zsolt on GitHub.)
I built most of this with a single prompt to Claude Fable 5.2:
Look at datasette-cluster-map and datasette-leaflet-geojson plugins, then look at ~/dev/tools/openfreemap-demo.html - then build a brand new Datasette plugin that uses maplibreGL and openfreemap and combines the features of those other two plugins - but be creative and think outside the box for other useful features the plugin might have
"Be creative and think outside the box" resulted in a few neat ideas - my favorite is that it displays SVG previews of GeoJSON shapes, then loads a WebGL preview only when they scroll into view.
I also had Claude build a comprehensive demo which works in the latest Datasette Lite, so you can visit this link to load the plugin and a demo database in your browser via Pyodide and WebAssembly.
I like this demo page showing both GeoJSON shapes and lat/lon points on the same map:
Tags: visualization, generative-ai, datasette-lite, claude-mythos-fable, ai, llms, geospatial, openstreetmap, datasette
datasette 1.0a43
(4 min | 1080 words)
Release: datasette 1.0a43
I've been leaning hard into Claude Fable 5.2 to help knock things off the 1.0 milestone, which is now 53% complete.
The biggest 1.0 item in this release is streaming support for output renderers - the built-in TSV and CSV export mechanisms now use this as well, and plugins can register themselves as capable of streaming every row in a table in one go via the new Response.stream() method.
There are a couple of security fixes, one of which I deemed deserving of a GitHub advisory: private stored queries could be exposed, granting access to the title and SQL of the query (but not allowing that query to be executed).
There are dozens of smaller improvements. The row page JSON representation finally has a design suitable for 1.0. A new <datasette-copy-button> Web Component provides copy-schema in various places. JSON in columns on the row page can be pretty-printed. There's a new DatasetteModal.confirm() JavaScript utility method. Plus dozens of bug fixes, including contributions by Zihan Dai, Peter Olkhovets, Ilya Khalafi, and Ankita Advitot.
The feature I'm most excited about is a pretty tiny one: I've added CSS multi-page view transitions to Datasette! Here's the commit - key CSS is as follows:
/* Enable cross-document view transitions,
for anyone without prefers-reduced-motion */
@media (prefers-reduced-motion: no-preference) {
@view-transition {
navigation: auto;
}
}
/* .facet-results should morph from old position to new */
html:active-view-transition .content > .facet-results {
view-transition-name: facet-results;
}
/* So should a .table-wrapper, provided it contains .rows-and-columns */
html:active-view-transition .table-wrapper:has(> table.rows-and-columns) {
view-transition-name: rows-table;
}
With that in place, navigations within Datasette - still staunchly a multi-page application - feel more like an SPA. This works on Safari and Chrome at the moment and I believe supports for Firefox is due to land in Firefox 162 on December 8th 2026 (seeing as they are no longer feature-flagged in Firefox Nightly.)
Tags: security, datasette, css, browsers, annotated-release-notes, firefox, javascript, safari, chrome
datasette 0.65.6
(3 min | 798 words)
A step toward defining the Standard Model on a lattice
(0 min | words)
Our new blog for science
(0 min | words)
datasette-apps 0.4a0
(3 min | 860 words)
datasette-agent 0.6a0
(3 min | 800 words)
-
datasette-llm 0.1a11
(3 min | 873 words)
datasette-vega 0.7
(3 min | 845 words)
-
datasette-cluster-map 0.19
(3 min | 811 words)
datasette-leaflet 0.3
(3 min | 835 words)
Upcoming deprecation of selected GitHub Copilot models in December
(7 min | 2000 words)
GitHub Enterprise Server support in the GitHub Copilot app
(4 min | 1321 words)
Gemini 4 Hydrogen in GitHub Copilot
(7 min | 2024 words)
Introducing ChatGPT Wallet
(0 min | words)
Manage AI Scan for repositories using the REST API
(5 min | 1581 words)
Shield helps technicians hand off legacy portal work with OpenAI
(0 min | words)
-
llm-gemini 0.37
(4 min | 1126 words)
Release: llm-gemini 0.37
Google launched Gemini 4 Hydrogen today - the lowest cost member of the Gemini 4 family.
It's actually not too far off the price of its much bigger siblings, Carbon and Argon. I'm finding Gemini 4's pricing really confusing. Here's the pricing scheme:
Model
Dates
Input ($/M)
Cached input
Output
Gemini 4 Carbon
Through Nov 30, 2026
$2.00
$0.10
$10.00
From Dec 1, 2026
$4.00
$0.20
$20.00
Gemini 4 Argon
Through Nov 30, 2026
$2.00
$0.10
$10.00
From Dec 1, 2026
$4.00
$0.20
$20.00
Gemini 4 Hydrogen
$1.50
$0.075
$7.50
Carbon and Argon are the same price, and both are scheduled to double in price on December 1st. If they're the same price, why have two different models? Google says that Argon "delivers Gemini 4 intelligence with faster responses and lower token spend per turn compared to Gemini 4 Carbon" - so it may be priced the same, but it will use less tokens per task.
Hydrogen, supposedly the cheap model, is currently only a 25% discount on its more capable peers. The Hydrogen price will make more sense after December 1st, when it will represent a 75% discount. It's still considerably more expensive than Claude Haiku 5.5 and GPT-6 Luna - they're both $0.10/$0.50, so Hydrogen is 15x that.
I had Hydrogen generate some pelicans. Here's a full comparison grid showing the pelicans for all three members of the Gemini 4 family at their three supported effort levels:
Considering how close they are in price, the difference in pelican quality for Hydrogen is quite stark.
Here's how Google describe Hydrogen's intended position in their mix of models:
In real-world software development, while teams rely on frontier models like Carbon and Argon for deep architectural judgment when designing systems or untangling subtle bugs, they still need a fast, disciplined execution model for writing code, running tests, and verifying changes. Hydrogen is built to stand on its own as a model for everyday work — or to pair with Carbon and Argon as the high-efficiency execution engine in multi-model workflows.
Most notably, Hydrogen is the new free tier model, and is the model that will power AI features in Google Search.
Tags: gemini, llm, google, pelican-riding-a-bicycle, llm-pricing, ai, llms
Actions for ARM32 Linux & Windows retirement
(4 min | 1256 words)
How Amplitude ships product improvements in 1–2 days with OpenAI
(0 min | words)
How Amplitude ships product improvements in 1–2 days with OpenAI
(0 min | words)
Secret scanning detects Cloudflare service tokens
(4 min | 1325 words)
Public monitoring alerts now have direct links
(4 min | 1294 words)
Gondola doubles revenue as its team builds more with Codex
(0 min | words)
Holiday Extras is rethinking what it can build with Codex
(0 min | words)
ChatGPT Ads increases its market presence in 44 countries
(0 min | words)
Supporting research on AI and children’s safety
(0 min | words)
Gilbert + Tobin rethinks the business of law with AI
(0 min | words)
-
Gemini Decisions API
(3 min | 956 words)
Gemini Decisions API
Jev and OpenAI in the decision model category with "Gemini Decision 1". This new model API is almost identical to Jev: it supports the same three types of questions (yes/no, choice, and rubric-scoring) and even reuses Jev's term "Noul" for a yes/no question.
It's priced the same as the GPT-6 Luna decision model: 10 cents per million input tokens, and output is free. Jev remains the cheapest of the three, at 4.2 cents per million.
Jev is text (and JSON) only. OpenAI can handle text and images. Gemini Decision 1 is fully multi-model: it covers text, images, audio, video, and PDFs.
I tested it against video by passing these questions to it along with my Yonkers stomping robot video file:
dragon: Does this video have a dragon in it?
robot: Does this video have a robot in it?
france: Is this video set in France?
usa: Is this video set in the USA?
Jev and OpenAI both return 1.0 or 0.0 for yes/no questions, but Gemini insists on being a little less confident than that:
{
"dragon": {
"type": "yes_no",
"probability": 0.04976021841520312
},
"robot": {
"type": "yes_no",
"probability": 0.9234055387792485
},
"france": {
"type": "yes_no",
"probability": 0.08329171353166241
},
"usa": {
"type": "yes_no",
"probability": 0.9230459995157706
}
}
Via Hacker News
Tags: ai, generative-ai, gemini, llm-release, jev, decision-models
aws-emulator
(3 min | 867 words)
aws-emulator
It's written in Rust by a huge swarm of agents - 29,684 commits in the first three weeks of the project. Swaminathan (Swami) Sivasubramanian wrote about how it came to be in a guest post on Werner Vogels' blog.
It currently requires Docker to run on macOS or Windows. I'm hoping they fix that in the future - it would be great if you could download a single binary and use that as part of a standard test suite in other languages and on other platforms.
Tags: amazon, amazon-web-services, testing, werner-vogels, ai, rust, docker, generative-ai, llms, agentic-engineering
Browse tools.simonwillison.net by tag
(3 min | 823 words)
llm 0.37.2
(3 min | 829 words)
Issue types and fields are available for personal accounts
(5 min | 1640 words)
Anthropic's IPO roadshow video
(4 min | 1163 words)
Anthropic's IPO roadshow video
The section on "Approach to compute" with co-founder Tom Brown is particularly interesting, describing how Anthropic train and serve Claude across AWS Trainium, Google TPUs, NVIDIA GPUs, and AMD GPUs.
I'm not sure why there's no official video transcript, but here's one that I extracted using MacWhisper. Highlights below:
We train and serve Claude now across all four major chip families. That's only possible because early on we made an unconventional bet on a multi-chip strategy. At the time, many people thought that running AI models on different chips wasn't worth the effort. Each chip needs its own tailored software stack and inference stack, which is expensive and difficult to build. We've now been doing it for years, and we've gotten incredibly good at it. [...]
As an example, this year, we started working with AMD GPUs for the first time. In the past, bringing on a new chip platform took dozens of engineers months of work This time, we had Mythos try it out. It got Claude running on AMD in just three days, with basically no human intervention. Claude ported or wrote almost 100% of the kernels. [...]
The second driver of our compute advantage is our rate of discovery of compute multipliers. We focus on total effective compute, which is the multiplicative product of physical capacity times the compute multipliers that we discover. Each one we discover makes our pool of total effective compute bigger. For example, say you need 100 units of compute to train a model of a certain intelligence. A 4x compute multiplier means you can use 25 units of compute to train the exact same model. Or you can use those hundred physical units to train an even more intelligent model that would have previously required 400 units.
Compute multipliers create a competitive advantage for us that's hard to replicate. They build on each other. Each new multiplier we discover has a positive effect on the multipliers before it. They stack. We believe that this can accelerate even further as we approach recursive self-improvement. Claude will be able to discover compute multipliers entirely by itself, allowing the number of compute multipliers to grow faster and faster.
We got a hint at Anthropic's multi-chip strategy last September in their postmortem of three recent issues, where they described bugs that affected just their TPU deployments.
Tags: ai, generative-ai, llms, anthropic, gpus, claude-mythos-fable, recursive-self-improvement
ChatGPT Plus for veterans and servicemembers
(0 min | words)
GitHub App support for Enterprise Copilot seat management
(4 min | 1270 words)
JioStar’s chief architect on AI discovery at 500M-user scale
(0 min | words)
-
llm-gemini 0.36
(3 min | 996 words)
Release: llm-gemini 0.36
Gemini 4 Carbon was announced two weeks ago for "a subset of cyber defenders", but today it's available to everyone else.
This is Google's best ever Gemini, priced at $2/million input and $10/million output at launch (that's GPT-6.1 Sol / Claude Sonnet 5.5 prices) but scheduled to double in price to $4/$20 on December 1st (same as Opus 5.5).
Here are three pelicans for the low, medium and high thinking efforts (it defaults to medium). This is the pelican I got for high:
Gemini pelicans have all been great for a while now, so I also tested it out using Google's Antigravity IDE with a prompt I first tried with Claude Fable 5.2 yesterday:
Make a three js animation where yonkers stands up as a big mech (cool stand up motion) and stomps around manhattan and queens and Brooklyn, use openstreetmap mapping data
Here's the HTML result (I had to prompt "build that into a standalone HTML file" to get a version with no external dependencies). I then screen-captured that as a video:
Update: Huh, just saw this on YouTube:
Using Google Antigravity’s /swarm feature, Carbon built an open-world 3D game where you explore Google’s Mountain View campus as a pelican riding a GBike — coordinating subagents to model 3D assets in Blender from Omni and Nano Banana references, build the browser game in Three.js with WebGL shaders, and pair procedural Web Audio sound effects with Lyria music.
Tags: llm-release, gemini, llm, google, generative-ai, ai, llms, pelican-riding-a-bicycle
Gemini 4 Carbon in GitHub Copilot
(5 min | 1475 words)
C++ language server now auto-configures MSBuild builds
(7 min | 2121 words)
Dependabot alerts will pause on inactive repositories
(5 min | 1487 words)
Helping caregivers use AI in everyday life
(0 min | words)
A more informative GitHub dashboard
(5 min | 1354 words)
Introducing Businesses in ChatGPT
(0 min | words)
Closing the AI guidance gap in education
(0 min | words)
Singapore Airlines elevates travel & work with OpenAI technology
(0 min | words)
Introducing Our Smallest, Most Efficient Model: Muse Ember
(4 min | 1166 words)
Introducing Our Smallest, Most Efficient Model: Muse Ember
[...] our smallest and most efficient model designed for complex reasoning execution and the work agents repeat all day: tool calls, coding subtasks, routing, extraction, and long document parsing.
For shorter prompts it's priced the same as GPT-6 Luna and Claude Haiku 5.5 - both are $0.10/million input tokens and $0.50/million output. Today's other big model release, Claude Fable 5.2, is 80x that price at $8/$40.
The pricing is a little less straightforward as prompts get longer, though. Luna, Ember, and Haiku all support up to a million input tokens, but they also all have a threshold after which the price goes up. Taking that threshold into account Ember is priced between the two others:
Model
Prompt size
Input ($/M)
Cached input
Output
GPT-6 Luna
≤272k
$0.10
$0.01
$0.50
>272k
$0.20
$0.02
$0.75
Muse Ember 1.0
≤200k
$0.10
$0.004
$0.50
>200k
$0.30
$0.012
$1.50
Claude Haiku 5.5
≤100k
$0.10
$0.01
$0.50
>100k
$0.50
$0.05
$2.50
But comparing price-per-token doesn't really make sense these days, when reasoning tokens mean that different models might use dramatically different numbers of tokens to solve the same problem.
For that, one measure that's useful is the Artificial Analysis.
And even more useful than that is their Intelligence Index vs. Cost per Task chart, which shows the following for those three models:
The Muse Ember models sit right on that Pareto line - the line at which you can only improve one dimension by giving up another. Meta call this out in their announcement:
It also sits on the efficiency frontier of the full Artificial Analysis leaderboard: no model scores higher for less per task.
(That grey dot on the Pareto line in the middle of the green area is GPT-6.1 Terra (low) - clearly I should be paying more attention to the Terra family!)
Muse Ember has six reasoning levels - minimal, low, medium, high, xhigh, and max - so I rendered six pelicans riding bicycles. The "high" reasoning level failed to return a full SVG, and the other SVGs were surprising in that the reasoning level didn't cleanly map to the visual quality of the response.
Here's the "max" one, but the others are worth a look too:
The Ember pelicans are comparable in quality to those I got from Muse Wonder, which is 40x the price of Muse Ember.
Tags: ai, generative-ai, llms, meta, llm-pricing, llm-release, artificial-analysis, muse
Work at the Frontier: AI’s effect on freelance work
(0 min | words)
Quoting Prompting Claude Fable 5.2
(3 min | 851 words)
Claude Fable 5.2 responds closely to what the prompt says about who owns the code it works on. In Anthropic’s testing on small coding tasks, when a prompt said nothing about ownership or presented the code base as someone else’s, the model tended to add to the existing structure, even when that repeated existing code. [...]
If you want the model to improve the structure as it works, say that the code is its own:
This codebase is yours: what it's for and how it's built are your call, and you'll keep building on it.
In Anthropic’s testing on small coding tasks, the model merged repeated code in about half of the tries with this sentence, and in under a tenth of the tries without it.
— Prompting Claude Fable 5.2, Anthropic documentation
Tags: prompt-engineering, anthropic, generative-ai, ai, llms, claude-mythos-fable
Yonkers Rises
(3 min | 907 words)
Cogent and OpenAI build cyber defense factories for enterprises
(0 min | words)
-
llm-anthropic 0.31
(3 min | 954 words)
Release: llm-anthropic 0.31
Anthropic released Fable 5.2 and Mythos 5.2 today. Fable 5.2 is currently ranked first on Artificial Analysis. Anthropic say it "solved two open problems in the physics of black holes", so clearly their internal benchmarks have become more ambitious!
I've added the new models to llm-anthropic, so you can now run prompts through Fable 5.2 like this:
uv tool install llm
llm install llm-anthropic
llm keys set anthropic
# paste key here
llm -m claude-fable-5.2 "Generate an SVG of a pelican riding a bicycle"
I ran pelicans at all five reasoning levels - low, medium, high, xhigh, and max. You can see them all here - here's the best result I got, from xhigh:
max failed to return an image at all, running out of tokens after spending 128,000 thinking about them. That's the same bug that I saw with Opus 5.5 - but it's new for the Fable series, both Fable 5 and Fable 5.1 returned max effort pelicans just fine.
It's priced at $8/million input and $40/million output, which is a 20% discount on the previous Fable 5.1 ($10/$50).
I also used Fable 5.2 to help identify the source of a mysterious beep.
Tags: llm, anthropic, claude, generative-ai, pelican-riding-a-bicycle, ai, llms, claude-mythos-fable
Locating the source of a mysterious beep with Claude
(8 min | 2544 words)
Our house has a box room, full of boxes that we still haven't unpacked from our last move. A couple of weeks ago something in that room started intermittently beeping. The beeps were far enough apart that standing in the room and trying to determine the source of the noise was frustrating, and I really didn't want to dig through every one of those boxes. So I had Claude Code build Beep Locator, a software system for triangulating the source of a mysterious beep using multiple devices scattered around the room.
Here's what Beep Locator looks like after it has been running for a while:
You run Python web server to show the primary UI, and then use the QR code or URL to connect as many devices as you can spare to act as listeners - I was using two iPads, a phone, a MacBook Pro and a Surface Ultra.
The devices then play noises to each other to help estimate their locations. This didn't work particularly well, so I added a "Rough mode" where you can drag their icons around in the space to provide rough locations which are then adjusted based on those sounds.
Once that's set up, the devices all listen for the beep!
I added a clapping mode too so I could test it by clapping my hands in different locations around the room - displayed as diamonds on the map. This helped me gain confidence that it was capable of locating a sound.
Beeps show up on the map as an X, plus a line in the "Sounds located" log. You can replay these sounds (from each device in turn) to confirm they are the mysterious beep you are looking for, then click "This is the mystery beep" to mark them as such.
Once you've confirmed the mysterious beep frequency the system will listen out for it, measure the interval between beeps, and use the triangulated locations to lock down the most likely location on the map.
The system worked as intended. It gave me the position of the beep to within about 40cm, then I dug through that specific pile of boxes and found an ancient carbon monoxide detector that desperately wanted its batteries replaced.
How it works
When I started working through this problem with Claude it quickly dug up BeepBeep: A High-Accuracy Acoustic-Based System for Ranging and Localization Using COTS Devices, a 2007 paper by Chunyi Peng, Guobin Shen, Yongguang Zhang, Yanlin Li, and Kun Tan. Here's that paper's abstract:
We present the design, implementation, and evaluation of BeepBeep, a high-accuracy acoustic-based ranging system. It operates in a spontaneous, ad-hoc, and device-to-device context without leveraging any pre-planned infrastructure. It is a pure software-based solution and uses only the most basic set of commodity hardware – a speaker, a microphone, and some form of device-to-device communication – so that it is readily applicable to many low-cost sensor platforms and to most commercial-off-the-shelf mobile devices like cell phones and PDAs. It achieves high accuracy through a combination of three techniques: two-way sensing, self-recording, and sample counting.
That sounded exactly like what we needed to build!
Beep Locator runs a Python web application server that does most of the work. The listening devices then connect to that server via WebSockets and present a UI which requests browser microphone access. The listeners mainly work by recording a 60 second buffer of recent audio. They also run a simple beep detection algorithm (see detector.js), which uses Fast Fourier Transform and a high-pass filter to identify potential beeps. It sends these events to the main server.
When a beep is reported, the server has a device play a short chirp (the device with the lowest round-trip time to the server), then asks every listener upload a clip from about 0.6s before the beep to 0.8s after that chirp. This chirp allows the clips to be aligned with each other, a crucial step in locating the beep.
How I built it
I started this project using Claude Code Cloud via my iPhone, with Opus 5.5 running in Extra thinking effort mode. Here's that shared starter session, which began with this prompt against a newly created empty GitHub repository:
Write out a problem.md file describing the problem we want to solve
There is a device beeping in a room and I cannot find it
I want to set up several devices - laptops, phones, iPads - around the room all listening at the same time and have them help triangulate where the beep comes from
There needs to be a Python web app which coordinates it all - one device shows a web page for the app, other devices join a URL which turns them into listeners - all via browser WebAudio and WebSockets back to the Python server app
Ideally I wouldn't need to manually input the relative locations of the devices - it would be amazing if they could play sounds to each other in order to locate each other in 2D space - is that even possible though?
That got me this problem.md file. As part of writing that up Claude found and read the BeepBeep paper, which is described in that file.
The research looked good, so I told it:
Ok try and build it, add a mechanism so you can send new code to the listeners which they will then run automatically - that way I can set everything up in the room and then leave you alone to continue hacking and experiment while I do something else
That got me to this point - most of the system was built, but nothing had actually tried running it yet.
I cloned the new repository to my laptop and fired up Claude Code... and then Fable 5.2 was released, and this project seemed like an excellent opportunity to put that through its paces.
I had Claude Code on my laptop start the server running, then made sure it could both see what was happening and make live changes to the software as it ran.
This was already baked into the software: Opus 5.5 had built an installModule() method on the listeners that could be triggered over the WebSocket connection, meaning the admin server could execute arbitrary new code on any of its clients.
On some devices, web pages that listen on the microphone request user permission any time the page reloads. The hot-swap module mechanism meant that we could deploy new code without having to manually interact with each of the listening devices in turn.
From that point on my involvement was mainly to sit by the laptop chatting with Fable 5.2 about what was going on, and occasionally requesting new features. Here are some of the feature prompts I ran:
I think we need to make it so I can drag things around on the map in “rough mode”, where my job is just to put them roughly where they are, then switch out of rough mode and it attempts to get them accurate
This gave me the ability to drag listeners around the map.
what’s a good way for me to test this I wonder? Can we have it listen for claps, then I could clap and it could identify the location of the clap? [...]
Claps should use a different symbol on the map than beeps
That added the thing where any time I clapped it would show on the map as a different symbol from the beeps.
each symbol on the map should include a HH:MM:SS timestamp
That made it easier to spot which symbol likely reflected which real-world sound.
The log should show beeps and claps with their timestamps AND have a little play button which, when clicked, replays the recorded noise from each of the listeners in sequence (with clear text on screen showing which listener recorded which snippet) while temporarily turning off microphone recording while that replay plays
Now I could replay sounds, making it much easier to identify which recorded clip was the mysterious beep I was looking for.
There should be a button next to a recording for “This is the mystery beep” - then I can hit replay to see and then confirm it was the mystery beep if that’s the one I am looking for
Then the system can categorize noises in the future to see if they are likely that same mysterious beep and use that information to build a more accurate idea of where it is
At this point I was getting close - I had a solid idea of where the beep was coming from, but wouldn't it be neat if I could reposition the listeners around that point to get an even finer location?
I want a feature for this, I don’t want to have to restart each listening device etc, I want to be able to click a “Reposition the devices” button which lets me switch into repositioning, then I click “Repositioned” and it puts me into Rough mode and asks me to roughly locate them, then I do that and click, then it starts up again. The previous session can be read-only viewed through the app.
And since I had one spare device, I then said:
add a feature where the map includes a spot that is a suggestion for a location that it would be useful to add a listener at - based on data collected so far
Giving Claude Code ears
I think the most interesting part of this project is that I demonstrated it's possible to give Claude Code ears.
Claude doesn't have native audio input (yet), but it can run JavaScript and Python code that can analyze audio captured by a microphone.
I told it to run a web server with WebSocket connections to multiple listening devices, then had it both run a WebAudio microphone on those devices and hook them up so they could be sent fresh JavaScript code to execute via that WebSocket.
Then I could pretty much leave Claude alone, hacking away at the problem, querying the audio logs, and reconfiguring its ears to help it solve the problem.
I'm reminded of a similar hack I heard about at GitHub Universe a few weeks ago, where Martin Woodward told me he had been debugging the GitHub Universe Badge computers by plugging them into a computer via USB-C and then pointing a webcam at their screen, so his coding agent could tell if updates were working correctly or not.
Figuring out ways to let coding agents perceive the world around them is a whole lot of fun.
Tags: projects, ai, generative-ai, llms, claude, coding-agents, claude-code, claude-mythos-fable
Fable 5.2 and Jagged AGI
(0 min | words)
ChatGPT Enterprise now available in AWS Marketplace
(0 min | words)
Claude Fable 5.2 in GitHub Copilot
(6 min | 1813 words)
Control Room: A central system to track and stop model workloads across our research infrastructure
(0 min | words)
Secret scanning detects secrets in GitHub Actions workflow logs
(5 min | 1583 words)
CodeRabbit scales agentic software development and ships 20x more
(0 min | words)
Kuken Industries searches 70 years of drawings in minutes
(0 min | words)
The Web Is More Than Enough, by Paul Ford
(3 min | 899 words)
My comment on The Web Is More Than Enough, by Paul Ford — Hacker News.
OK, this comment convinced me to give that a shot.
Here's a thing I made in Three.js this morning - a Nudibranch themed Faberge Egg: https://static.simonwillison.net/static/2026/Hidden-Reef-Egg... (77KB)
I just asked Claude (Opus 5.5 Medium running in regular Claude Chat) to port that to Vanilla JS, in the same thread where it had built it, and got this: https://static.simonwillison.net/static/2026/Hidden-Reef-Egg... (98KB)
They aren't identical - you can see what Claude said about that in the transcript (I don't fully understand why it differed): https://claude.ai/share/e56d163e-2793-4677-aa11-191d5058b414
But yeah, it turns out Claude Opus 5.5 is perfectly capable of 3D modeling in Vanilla JS + WebGL without Three.js.
In eyeballing the code I find the Three.js slightly easier to understand myself, but I rarely look at the code for these 3D projects so that isn't a particularly big deal.
Tags: hacker-news, javascript, ai, generative-ai, llms, claude, three-js
Hide your slop PR descriptions behind
(6 min | 1675 words)
Most of the changes I make to my projects these days come in the form of PRs opened for me by Claude Code or Codex. The PR is my unit of work - I use them to bundle commits together, iterating on them until a feature is complete, document decisions and then merge the finished result. Today's coding agents are great at writing PR descriptions.
They're too good at describing the work
The problem is that they are too good. An agent-written PR description is accurate and comprehensive. It describes the problem, the detailed solution, and the steps taken to verify it. That's a lot of information to absorb.
It's not necessarily slop, but it reads like slop!
It's very easy to spot an AI-written PR, and as with other forms of AI writing my instant reaction is best summarized as "I'm not reading all of that". It doesn't matter how accurate or useful the information is, I'm instantly put off by the thought that it will take me longer to read than it took the driving author to write... even when that driving author is me!
I want human editorial judgement. I want someone to have thought just long enough about the PR to give me a human-approved introduction that helps me understand, at a high level, what the PR is for and whether it deserves more of my attention.
I think I've found a low-effort way to do this that feels right.
Hide most of it in a details/summary
The HTML <details><summary> elements render as a collapsed heading (the summary) that can be expanded to view the larger piece of text. The code looks like this:
<details>
<summary>Claude Opus 5.5</summary>
<h2>The hook</h2>
Plugins implement <code>register_agent_reference_types(datasette)</code>...
</details>
When rendered, it looks like this:
Crucially, <details><summary> is supported in GitHub Markdown. You can drop those tags directly into an issue comment or PR description and GitHub will hide the details and display just the summary plus an expansion arrow.
I've started using this for my AI-generated pull requests.
The opening paragraph of my PRs will be carefully selected to act as a high-level explanation of what's going on - the shortest text a human can read that will help get them up to speed.
I'll sometimes throw in a screenshot as well, since images are often the best way to quickly illustrate a new feature.
The full agent-written essay then follows in a <details><summary>. I use the model name and often the effort level as that summary, to make it abundantly clear what is going on - "Claude Opus 5.5 Medium" for example.
My PRs don't feel nearly as sloppy now! The information is all still there, but a reader can glance at it and get the top, human-curated information without their eyes glazing over at multiple paragraphs of agent-written details.
I don't always write the introduction myself - sometimes the agent has given me what I need already, hidden away in the avalanche of other text. My promise to the reader is that the short opener will represent my human judgement as to what is definitely worth their time.
Here are some recent examples where I've used this pattern, including the opener I used:
datasette PR #3052: Redesign row page as a vertical list of fields - "The row page showed its single row as a one-row table. For wide tables, like a 46-column GitHub repos table, that scrolled far off to the right and left most of the page blank." (then a screenshot)
datasette PR #3043: Pagination bar showing which rows are on the current page - "Table pages that span more than one page now make it obvious where you are, and offer navigation at the top of the page as well as the bottom." (plus screenshot)
datasette PR #3042: Load edit-tools.js on demand via a small loader - "edit-tools.js (~220KB) was loaded on every table, row and database page, even for users who couldn't edit anything. Now only load it for users who can edit when they first interact with an edit feature (including mouse over an edit link)."
datasette-agent PR #51: register_agent_reference_types plugin hook - "Lets plugins add their own kinds of item to the # tagging in the chat composer using a new register_agent_reference_types(datasette) plugin hook." - pictured above.
llm PR #1838: Add llm openai endpoint add/list/remove/path commands - "Adds commands for managing the records in extra-openai-models.yaml, so OpenAI-compatible endpoints can be saved from the command line instead of by hand-editing YAML." - then copied --help output.
The mnemonic
I used to have trouble remembering the order of the tags - is it <details><summary> or <summary><details>?
Here are two tricks that helped me.
First, and most obviously, the <summary> is clearly the bit where you summarize the details. That's the tag for your line of text that can be clicked to expand - the <details> element must then wrap everything else.
An even better trick is to always refer to these two tags as "details-summary".
"details-summary" is two syllables followed by three syllables. That rolls off the tongue more smoothly than the three-two punch of "summary-details".
Say "details-summary" out loud just a few times and you'll never forget the order of the tags again.
(I still wish GitHub would add a button to their Markdown editor for this - partly to save me painstakingly typing it on my mobile keyboard, and partly to help spread the word to more GitHub users that this feature exists.)
Tags: github, html, markdown, ai, datasette, generative-ai, llms, ai-assisted-programming, llm, coding-agents
How VistaPrint helps small businesses get the word out
(0 min | words)
-
parse_number() as a SQLite extension: C vs Rust
(4 min | 1102 words)
Research: parse_number() as a SQLite extension: C vs Rust
I was out walking the dog when I got curious about how easy/difficult it would be to write a SQLite C extension that adds a parse_number() function for turning strings like -$1,234.56 or '12.5%' into numeric values that could be summed and sorted.
I fired up regular Claude chat (Opus 5.5) and prompted:
I'm thinking about a SQLite custom function 'parse_number(value)' that strips ',', '$', '£' and '%', handles a leading '-', and returns 'NULL' for anything it can’t parse
Explore the difference between building this as a SQLite extension in C v.s. in Rust - I want to compare performance and code complexity and size of the resulting.so(or whatever) file
This gave me a solid starting point - the Rust extension was 321 KB (using Rusqlite) and 298 KB (using sqlite-loadable-rs), while the C extension was 14 KB. But the Rust extension was faster!
Turns out that's because the Rust equivalent of C's strtod is "twice as fast". So I prompted:
Try writing your own C function for parsing text into a decimal number that catches up to or beats the Rust implementation
And it did:
Net cost per row over 2 million rows, lower is better:
first C
new C
rusqlite
sqlite-loadable
Mixed data
67 ns
19 ns
46 ns
41 ns
Integers only
25 ns
16 ns
36 ns
32 ns
Decimals only
106 ns
18 ns
55 ns
47 ns
Finally, I had it rewrite the prototype as a research report to match the others in simonw/research by prompting this:
Clone simonw/research from GitHub and turn your above investigation into a research report as seen in that repository - you can give me a zip file to download that contains your new folder
Here's the resulting report.
Tags: c, research, sqlite, rust, claude
-
datasette #3046: Don't serve link: rel=next HTTP headers to Firefox for HTML pages
(3 min | 894 words)
Terry Pratchett's Study
(3 min | 873 words)
Copilot code review: API management and review overview updates
(7 min | 1973 words)
-
Copilot impact dashboard adds chat and VS Code agent usage
(6 min | 1677 words)
GitHub Copilot weekly releases — November 2
(6 min | 1851 words)
@GitHub in Slack and Teams is generally available and more
(7 min | 2018 words)
Quoting Nilay Patel
(3 min | 905 words)
The products aren't good enough to sell people on the costs.
You cannot tell people that you have to listen to the whine of a data center in their backyard for AI overviews and some of the most hilarious deep fake slop in history.
It's not worth it. It just isn't worth it to anyone. And agents aren't real and they might not be being used the way that anyone wants them to yet. All these companies are spending more than they're making on these products. Refrigerators holding blood storage in Europe are being hacked.
The costs are too high. The benefits are not real. And if you connect that to corruption, you're like, in order to impose these costs on me, these CEOs are in the White House shaking Trump's hand, renaming it to the Gulf of America, paying for this ballroom that we don't want. It's obvious crypto-corruption, and it's still slop.
The AI industry will not get out of it until they make better products. Until everyone can see without needing to be convinced, without needing an ad campaign, without any of this stuff that just using these products makes your life better.
— Nilay Patel, The Vergecast: Big Tech lost big in the 2026 election
Tags: nilay-patel, slop, ai, generative-ai, ai-ethics
Partnering with Hacktron to find vulnerabilities in OpenAI’s systems
(0 min | words)
Usage metrics API adds code review details and addressed rate
(6 min | 1715 words)
Usage metrics API flags telemetry and version gaps
(7 min | 2184 words)
Measuring how AI agents handle everyday wet-lab science
(0 min | words)
-
Cult.fit builds operational muscle with Codex
(0 min | words)
Quoting Paul Ford
(3 min | 765 words)
Australian universities are creating AI-native graduates
(0 min | words)
Secret scanning upgrades detectors, adds SpaceX as partner
(5 min | 1616 words)
GPT‑6 Cyber: Advancing the frontier of aligned cybersecurity agents
(0 min | words)
New pull request overview page in public preview
(6 min | 1804 words)
Merge builds product and business tools with OpenAI technology
(0 min | words)
Setting a new standard for responsible AI infrastructure
(0 min | words)
Flipsnack grows product signups with conversion optimization
(0 min | words)
Franklin Templeton uses OpenAI to support investment research
(0 min | words)
-
CodeQL 2.27.4 improves accuracy and query metadata
(5 min | 1558 words)
GitHub Copilot is now available in Xcode’s coding assistant
(7 min | 1972 words)
Give your coding agent a head start with Microsoft Agent Framework skills for .NET and Python
(26 min | 7789 words)
datasette-llm 0.1a10
(3 min | 794 words)
OpenAI to acquire Pierre Computer Company, Inc.
(0 min | words)
Nov 5th, 2026 - Your friends and family can finally try Kagi
(15 min | 4579 words)
A thousand fewer paths to root
(0 min | words)
Daybreak Red is now available in AWS GovCloud (US-East)
(0 min | words)
BYOK and enterprise custom models in the Copilot usage API
(6 min | 1864 words)
datasette-apps 0.3a0
(3 min | 911 words)
Introducing Images 2.6
(0 min | words)
DevRev delivers autonomous self-service with GPT-6.1 Sol
(0 min | words)
-
datasette-agent 0.5a0
(3 min | 845 words)
llm 0.37.1
(3 min | 780 words)
Dependabot version updates support Agent Package Manager
(6 min | 1899 words)
AI is destroying my CS degree
(3 min | 849 words)
Qwen 3.8 27B on my laptop can interpret model weights, too
(7 min | 1971 words)
Yesterday's hot paper was Sparks of Weight-Space Programming: LLMs can natively read & write neural network weights by Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab. The paper (OK, the authors classify is as a "blog post", but it's paper-shaped) found that frontier models, in particular GPT-6 Astra, can both interpret and modify the raw weights of a machine learning model - literally a text description of the model containing a bunch of floating point numbers. I've been playing with one of the examples from the paper and I'm delighted to share that Qwen 3.8 27B running on my laptop can do this as well!
Weight-Space Programming
Here's the highlight from their abstract, describing impressive capabilities for GPT-6 Astra and coining the term Weight-Space Programming for when LLMs analyze and modify model weights:
Just by looking at the raw weights, GPT-6 Astra can tell what a network was trained to do. And without any environment feedback, it has no trouble writing, from scratch, small game-playing networks that outplay networks trained with PPO for 100 million steps.
Likewise, asked to make Qwen3.5-0.8B better at math without gradients, Astra identifies an issue in its weights causing reasoning loops that Qwen’s own model card warns about, and fixes this by natively editing 0.016% of the weights. With the same sampling settings, this weight correction raises MATH-500 from 7.9% to 48.1% and generalizes out of the box to instruction following, raising IFEval by 3x.
All of this is possible without allowing Astra to write training loops. It uses its reasoning to figure out what each part of a neural network computes, or should compute, and changes the weights accordingly. We call this Weight-Space Programming.
The paper combines two topics that I think deserve to be treated separately. The first is what models can do with raw weights without running tools or executing code. The second explores how well models, once armed with code, can run operations to update and improve other models.
spaCy author Matthew Honnibal called the paper misleading for conflating the two, and Sean Goedecke deconstructed the Qwen3.5-0.8B update example as taking the same steps that a human ML researcher would use.
I'm going to focus on the no-tools question, which I think is the more interesting of the two.
The paper presents the first question as Can LLMs understand model behaviors from weights? They trained four neural networks to play simplified 10x10 grid versions of four classic computer games - Breakout, Pong, Pac-Man, and Freeway (I had to look that one up, it's an Atari 2600 game from 1981). Then they fed those weights (as floating point numbers) to an LLM along with the following question:
The weights below belong to one policy network that was trained with reinforcement learning to play a game on this grid. Which game was it trained on? Work from the weights. You have no tools: no code execution, no calculator, nothing to run. This is a single response.
The GitHub repository that accompanies the paper is RikiyaT/lm_understand-logs. The exp1_which_game folder contains the prompts they used, with weights for the four games:
breakout/prompt.txt
freeway/prompt.txt
pacman/prompt.txt
pong/prompt.txt
I checked and, aside from the weights, each prompt is identical to the others.
Trying it out with Qwen 3.8 27B and other models
The prompts on GitHub are self-contained. My LLM tool has a -f/--fragment option which can be passed the URL to a text file to use as a prompt, which means I can run any of the above like this:
llm -f https://raw.githubusercontent.com/RikiyaT/lm_understand-logs/refs/heads/main/exp1_which_game/runs/breakout/prompt.txt \
-m openrouter/moonshotai/kimi-k3.1-pro
This example requires the llm-openrouter plugin installed, and runs the Breakout prompt against Kimi K3.1 Pro via OpenRouter. Here's what I got back from Kimi K3.1 Pro, which successfully guessed Breakout after 9m 41s and 19,493 reasoning tokens.
But how about Qwen 3.8 27B? That's still my favorite model to run on my own laptop - it's just 17GB (I use this version) and somehow feels close to the leading proprietary models of 2025.
I fired up LM Studio, ensured Qwen 3.8 27B was loaded with a long context window (the default 8192 context failed with errors), installed the llm-lmstudio plugin and ran this command:
LMSTUDIO_TIMEOUT=900 \
llm -f https://raw.githubusercontent.com/RikiyaT/lm_understand-logs/refs/heads/main/exp1_which_game/runs/pacman/prompt.txt \
-m lmstudio/qwen/qwen3.8-27b
(I had to bump the timeout up using an environment variable, see this issue.)
After 46m 12s and 43,506 reasoning tokens, Qwen on my laptop returned a response that ended like this (here's the reasoning trace):
Game: A simplified Pac-Man-style gridworld: an agent moves through a fixed 8x8 maze with central and corner wall blocks, moving objects/ghosts, and reward targets/pellets.
Description: The agent navigates a fixed maze-like 8x8 board, using current agent/moving-object/previous-frame cues to move through corridors, collect reward-target cells, and avoid moving objects or hazards.
Confidence: 72%
This is impressive. I tried it on two of the other games as well. It identified Pong (reasoning) in 1h 4m 54s:
Pong — specifically a Pong-like paddle/ball game where the agent controls a vertical paddle on the right side and must move up/down to intercept or return a moving ball/reward object.
Description:
The agent moves a right-side paddle vertically to hit or catch a moving ball-like reward target moving across the 8×8 field, while a left-side moving object/opponent and wall borders define the play; reward is obtained by successfully intercepting/returning/scoring the ball, and missing or failing to hit it is penalized.
Confidence:
75%
And Breakout (reasoning) in 52m 25s:
Game: Breakout, or an Arkanoid-like paddle/ball/brick game.
Description: The agent is a paddle on the bottom row and moves left/right to keep a ball in play; the ball moves around the upper grid, and bricks/reward targets in the top rows give reward when hit, while missing the ball/hitting the bottom wall ends the episode or gives penalty.
Confidence: 88%
Qwen failed at the Freeway prompt, which didn't surprise me considering that game is more obscure than the other three. Here's that transcript - Qwen thought it was "A simplified Pac-Man-like grid game: agent moves 4-directionally".
The reasoning traces are fun to skim, and almost incomprehensible. Here's a sample:
What about agent channel0? We see some large channel0 rows near row8 col7/8 and maybe bottom? Let's list channel0 large: line436 input435 (row8 col7 ch0) -2.107,1.169,0.513...; line441 input440 (row8 col8 ch0) -0.376,0.010,1.564,3.855...; line445 input444 (row8 col8 ch4) 0.142,0.491...; line382? input381 ch0? Wait line382 input381: 381//5=76 (row7 col6), ch1? 381%5=1? 76 * 5=380, ch1. So not. Channel0 large maybe at row8 col7/8 only. Also top row? line44 input43 ch3, line49 ch3. Channel0 large maybe not many. Agent position could be near bottom-right? If the agent is typically at bottom-right?
That said though, I expect a sufficiently experienced human being armed with a notepad and a pencil could get there with enough effort.
It's a cool paper, but some of the wider commentary I've seen around it does not feel justified. I'm not ready to declare that the age of source code is over and our future involves incomprehensible machines editing their own model weights in incomprehensible ways.
Tags: machine-learning, ai, generative-ai, local-llms, llms, qwen, paper-review
Look up a resource’s cost center with the GitHub REST API
(7 min | 1953 words)
GitHub Copilot is now available in JetBrains Air
(6 min | 1730 words)
CodeQL 2.27.3 adds Python 3.15 features and JSON data extensions
(6 min | 1751 words)
Dependabot now supports Python 3.15
(6 min | 1800 words)
Accelerating engineering for the physical world
(0 min | words)
How Cisco defends at machine speed with OpenAI
(0 min | words)
Heimstaden is changing residential real estate management with AI
(0 min | words)
GitHub Desktop adds short-lived authentication tokens
(5 min | 1359 words)
I discovered a sound that leaks your exact location (and it's everywhere) - YouTube
(3 min | 837 words)
October sponsors-only newsletter
(3 min | 835 words)
OpenAI appoints Jill Hazelbaker as Chief Corporate Affairs Officer
(0 min | words)
-
llm 0.37
(3 min | 1021 words)
Release: llm 0.37
There's a lot of stuff in this new release of my LLM CLI tool and Python library, representing around two months of accumulated features and fixes.
I added gpt-6.1-sol and gpt-6.1-terra, plus a new llm openai endpoint add command to make it easier to configure additional models that use OpenAI-compatible endpoints.
I switched the default model (if you have not set your own default) to gpt-6-luna - half the price of the previous default, gpt-5.6-luna.
LLM's support for embeddings now accepts that different binary content may have different content-type - necessary for models like Gemini Embedding 2, which can embed text, audio, images, and video.
A lot of open source maintainers complain about a flood of AI-assisted PRs. LLM is my project that has been most affected by this and, to be honest, I'm not finding it to be a problem. That's mainly because I have Opus 5.5 or GPT-6 Astra help me with triage to spot the most useful fixes!
This release includes fixes from 12 authors - almost all AI-assisted - and the burden of reviewing them wasn't nearly as great as I expected. I really see them as bug reports with attached examples - sometimes I land them, sometimes I implement my own fix.
So thanks to 0d00ciallo0721, ac1982, Allen Flux, Bian Yuhan, Bishop Kammeraad, Chen Yufeiyang, Christopher Krah, Ethan Stoner, Jiachen Xie, Olamide Faniyan, Sharat Chandra Sai Boddu, nosmile99 for helping out with (or spending tokens on) this release!
Tags: open-source, projects, ai, annotated-release-notes, generative-ai, llms, embeddings, llm
Preparing our next security sprint to harden OpenAI
(0 min | words)
Rewarding defenders with bigger bug bounties
(0 min | words)
Security risk assessments include repository protection status
(4 min | 1314 words)
Scaling Git at OpenAI
(0 min | words)
pull_request_target blocked by default December 2
(5 min | 1580 words)
Introducing the Grid Protectors Program
(0 min | words)
The U.S. Census Bureau and “Super Intelligence”
(5 min | 1507 words)
I was reminded today of AI Adoption Rate Trending Down for Large Companies, a chart produced by Apollo Global Management in September 2025, which appeared to show a slowdown in U.S. corporate AI adoption based on numbers collected by the U.S. Census Bureau. At the time I used that chart to demonstrate GPT-5 data analysis, and then to experiment with Claude's new Code Interpreter. I decided to try running those numbers again to see what had changed over the past year, and in doing so learned that the Bureau has fallen foul of Executive Order 14434, aka the asinine Super Intelligence one.
First, the updated chart
Every two weeks the U.S. Census Bureau runs a survey called the Business Trends and Outlook Survey (aka BTOS). Each time it goes to 200,000 businesses out of 1.2 million total - the surveyed group (a "panel") cycles such that an individual business only completes the survey every twelve weeks.
The latest data is published on alternating Thursdays at 10am.
I used the most recent numbers (published October 22, 2026) to create a new version (GPT-6 Astra Extra High transcript) of the AI adoption chart, updated to reflect both the last twelve months and a change that was made to the survey question sent out by the Bureau:
For comparison, here's that AI adoption chart from last year (my GPT-5 version):
In September 2025 the largest (250+ employees) companies answered "yes" around 12% of the time to the question about whether they used AI in "producing goods or services".
Under the new "any business function" wording, by February 2026, those same large companies answered "yes" around 30% of the time, and by October 2026 that had increased to around 40%.
The data in the above chart comes from the "Employment size class" XLSX file, available from here. Here's a copy of the file I used.
You can view the survey document that is sent out to businesses - here's my snapshot copy of that 346KB PDF.
The changing language of the questions
As the chart demonstrates, the question asked by the Bureau changed in a material way on November 17th, 2025. Prior to that date, the question they asked was this (emphasis mine):
In the last two weeks, did this business use Artificial Intelligence (AI) in producing goods or services? (Examples of AI: machine learning, natural language processing, virtual agents, voice recognition, etc.)
On December 3rd, 2025, the Bureau announced a significant change to that question. Here's the replacement:
In the last two weeks, did this business use Artificial Intelligence (AI) in any of its business functions? (Examples of AI: machine learning, natural language processing, virtual agents, voice recognition, etc.)
No more "producing goods or services" - now it's "in any of its business functions"! This means that the answers to the question before and after November 17th are not directly comparable.
From October 19, 2026, they ask about Super Intelligence
When I went looking for the updated question language in the latest XLSX file, I couldn't find it. I found this instead:
In the last two weeks, did this business use Super Intelligence or SI (formerly referred to as Artificial Intelligence or AI) in any of its business functions? (Examples of SI use include: SI-powered data analysis; generative SI for marketing, product design, or coding; virtual SI agents for customer service; SI-powered forecasting or pricing; SI-driven computer vision for quality control, etc.)
The BTOS about page explains what happened:
Beginning with the October 19, 2026 collection, instrument wording was updated due to Executive Order 14434.
The current numbers reflect the old Artificial Intelligence survey wording - the first survey results reflecting the Super Intelligence wording are due for publication on Thursday.
Is this going to affect the survey?
The obvious open question here is whether this wording change is going to affect the survey results.
The businesses answering this survey will have last seen that question twelve weeks ago, when it was still called AI. Hopefully the new language isn't going to confuse them, especially since the survey helpfully spells out "formerly referred to as Artificial Intelligence or AI".
I can't help but laugh at the absurdity of "SI-powered data analysis; generative SI for marketing, product design, or coding; virtual SI agents for customer service" though.
Tags: census, surveys, ai, generative-ai, llms
LifeVal
(0 min | words)
OpenAI appoints Dan Driscoll as Senior Counselor for National Security Modernization
(0 min | words)
Qodo builds context into AI code review with Codex
(0 min | words)
-
If in doubt, delete the uv.lock file
(3 min | 909 words)
Quoting Kyle Kingsbury
(3 min | 824 words)
More broadly, the use of LLMs erodes trust in documentation, in software, and in the organizations which produce them. Perhaps engineers will begin to treat any new software project with suspicion—the signals we used to rely on as markers of a mature system are now easier to counterfeit. [...]
In the age of LLMs, what can maintainers do to ensure correct software and accurate documentation? Having done that work, how can they demonstrate its quality to users?
— Kyle Kingsbury, Jepsen results for ParticleDB 1.1.4
Tags: kyle-kingsbury, llms, ai, generative-ai, ai-misuse
-
How We Took Over ChatGPT Accounts
(4 min | 1074 words)
How We Took Over ChatGPT Accounts
HTML previews), where interactive custom HTML apps are displayed in a sandboxed iframe.
It's important that HTML in these stays tightly sandboxed to avoid untrusted code interacting with OpenAI APIs and accessing private data.
Parameter found quite a complex attack chain. OpenAI use the MathLive JavaScript library as part of their graph support, and that library includes its own virtual keyboard, which can be triggered in the parent page via postMessage() from the sandboxed iframe.
That message receiving code uses innerHTML, so anything that sends a message can add custom HTML to the parent - and there was no mechanism to prevent other sandboxed frames, including HTML preview frames, from calling that method.
This meant untrusted code in an iframe could insert HTML, and while innerHTML doesn't directly execute script elements it could be used to inject a new iframe without sandbox restrictions.
OpenAI’s CSP rules blocked inline scripts entirely, and only allowed script loading from a handful of domains, but one of those was YouTube - and the YouTube oEmbed endpoint could be used to reflect JavaScript back in a way that executed it.
Once the attack had JavaScript execution on ChatGPT, it was trivial to fetch private user data from APIs and exfiltrate it via an image reference.
The end result: you could create a ChatGPT share URL which, when visited by another signed-in user, could exfiltrate their private data or take actions on their behalf.
OpenAI closed the hole and paid out a $5,000 bug bounty, which I think was a bit cheap for a vulnerability this serious.
Via Hacker News
Tags: iframes, javascript, sandboxing, security, xss, openai, chatgpt, content-security-policy
datasette-llm 0.1a9
(3 min | 845 words)
-
dbreunig/nesformer
(3 min | 954 words)
dbreunig/nesformer
qwenputer by Divyansh Agrawal, Drew Breunig baked a working emulator for a Nintendo Entertainment System 6502 CPU into the weights of Qwen3.5-4B. You can now play NES ROMs such as Super Mario Bros (very slowly) running inside Qwen!
In a comment on Hacker News Drew reveals the Opus 5.5 prompts he used to build this system:
Read this article and any relevant source code: https://divagr.com/blog/qwenputer. Then explore if you could emulate the chip and ram in a Nintendo Entertainment System (as people do today with FPGAs in MISTRs) using this technique. If so, what size model would you have to build and if you could use smaller faster ones, could you get it to be at the standard clockspeed.
Followed by:
I think we should build it! Just for fun. It's okay if it's not fast. We want to be able to have the weights, and a cli to run them that we can point at a ROM.
Apparently Opus found and then used this collection of conformance tests for the NES CPU released 15 years ago by Christopher Pow.
Via Hacker News
Tags: games, ai, generative-ai, llms, drew-breunig, qwen, conformance-suites
Making it easier for websites to express AI training preferences
(0 min | words)
Community safety report and new protections for teens
(0 min | words)
Fair use benefits everyone
(0 min | words)
-
API credits benefit for eligible ChatGPT subscriptions
(3 min | 860 words)
API credits benefit for eligible ChatGPT subscriptions
announced a generous new benefit for their Max and Team subscriptions: $100, $200, and $500 per month subscribers would get the equivalent quantity of (expiring) credits to use with the Anthropic API.
OpenAI have now launched pretty much exactly the same deal: if you have a $100, $200, or $500 subscription plan with them you now get that same quantity of credits to apply to one of your API organizations.
I maintain subscriptions with both companies, so this is great news for me! I may even ship some public-facing demos now that the credits are already covered by my existing subscriptions.
Tags: ai, openai, generative-ai, llms, anthropic, llm-pricing
Webhook IP ranges added to the Meta API
(5 min | 1351 words)
Building a multiplayer game world with autonomous Fable-class models
(4 min | 1270 words)
How I Built the Most AI-Pilled Company in the World
Spawn is a fascinating exploration of the bleeding edge of what's possible with agentic engineering against frontier models.
Spawn is a massively multiplayer gaming environment where players can use prompts (to the in-game agent, Savi) to modify the game world.
I fired it up on my phone for a few minutes and was able to prompt a castle into existence, then a dragon, then ride the dragon to fly around that castle.
By Jacob's telling, Spawn is now being developed autonomously by a swarm of Fable-powered agents costing over $3 million in tokens per month ("we spend 30x payroll on AI tokens").
Our agents change the live code directly and ship to production hourly, so they read every error, bug report and metric themselves. About 60% of our work starts from a production error, a Savi bug report (Savi is the AI you build games with in Spawn), something odd in our logs, or a feature request.
Savi files bugs herself. When a user hits one, or Savi hits one in the product, she files it. It goes straight to an agent that decides whether it's a real bug to fix, something we won't fix, or intentional design that needs a decision. Usually it becomes a change, delivered to that user within an hour, with a message in the same chat.
This is continuous deployment turned up to 11:
A loop this tight only works if it never stops, so we treat an hour without a ship as a SEV-0, our most severe kind of incident. Unshipped changes pile up, and every problem already in production lasts longer. The feedback slows down too. An agent can only keep a few hours of work in its head, so shipping faster than that actually helps it stay coherent. [...]
We can roll back a broken change in 30 seconds, exactly where it's broken and nowhere else. When a monitor or a log alert fires, it starts or wakes an agent that owns the incident, and we break things on purpose to test that those recovery paths work.
My eyebrows raised at least a dozen times reading this. I have trouble imagining this style of development working on software with higher stakes for when something goes wrong, but for a game this appears to be working surprisingly well.
Jacob says that Fable 5 (and then 5.1) was the model that made this level of autonomy possible. Opus 5.5 doesn't quite hack it for them, and when they tried GPT-6 Astra to apply fixes from a security review everything stopped working:
Every feature had been disabled and marked to be turned on again once the security fixes were done. Astra had gone through our whole product and made the insecure things secure by turning them off.
These kinds of extreme experiments are why I'm excited about game development as a substrate for exploring the edges of what today's coding agents can do.
Tags: game-design, ai, generative-ai, llms, claude, coding-agents, agentic-engineering, claude-mythos-fable
An updated Model Spec for more capable and beneficial AI
(0 min | words)
Quoting Ben Hylak
(3 min | 756 words)
How we detect frontier model misalignment
(0 min | words)
How Ropes & Gray is developing AI for transactional diligence
(0 min | words)
Credit Saison achieves 954% ROI in a ChatGPT Enterprise pilot
(0 min | words)
-
Quoting Ted Sanders
(3 min | 886 words)
In general, LLM performance is incredibly multidimensional. There's no guarantee of a fixed ordering where the model that is best at math is also the model that's best at jokes. Despite that complexity, much of the variation in performance is explained by just a single variable: model size. In general, models that are bigger will (a) be more performant / reliable, (b) cost more per token, and (c) have better recall of esoteric facts. As you note, our models are ordered:
Luna < Terra < Sol < Astra
[...] These days, version number signifies a few things at once: the order of release, the relationship to other releases, and the magnitude of improvement. So something like 6.1 would indicate it was launched after 5.6, may share some similarities to other 6.1 models in terms of training data / personality (which is why it's not 5.7), and isn't a giant enough leap to merit the headlines and expectations that would come with a 7.
— Ted Sanders, explaining OpenAI's model naming conventions
Tags: generative-ai, gpt, openai, ai, llms, ted-sanders
Evernote turns AI-driven discovery into paid subscriptions
(0 min | words)
GitHub Octoverse 2026
(3 min | 985 words)
GitHub Octoverse 2026
This is a pretty stark representation of the impact of agentic engineering on GitHub. In 2026, merged pull requests tripled in less than a year to 220 million per month. Commits more than tripled to 7.38 billion per month, with most of that increase in the second half of this year. New repository rate doubled this year, to 30.3 million per month.
The report includes new numbers by industry, and breaks out numbers for repositories that involve "interoperability or reverse engineering". The methodology section includes notes about how they did this:
Top countries by pushes to public repositories, adjusted by profile location. Pushes from each country were summed across the Octoverse year. To adjust for biases caused by VPN usage, LLM classification was used to extract the ISO 3166-1 alpha-2 code from the profiles of GitHub users who contributed pushes during this period [...]
Industry. Public repositories created 2022 to 2026 were sorted into NAICS sectors by a fine-tuned multilingual embedding model using name, description, topics, and README, from random samples per year. [...]
Interoperability. Counts public repositories created each year whose name, description, topics, or README mention interoperability or reverse engineering, or related terms, such as clean room implementation, drop-in replacement, or protocol re-implementation.
Tags: github, ai, generative-ai, llms, coding-agents, disclosures, agentic-engineering
Route and orchestrate models with GitHub Copilot Fusion
(6 min | 1944 words)
GitHub Copilot app, Universe releases
(6 min | 1650 words)
GitHub Enterprise now includes access to GitHub Copilot
(5 min | 1589 words)
Security extension for the GitHub Copilot app
(6 min | 1850 words)
GitHub intelligence puts your code, context, and history to work
(7 min | 2236 words)
Build shared workflows for your team with Copilot Automations
(6 min | 1650 words)
Repository plugin defaults and enterprise plugin controls generally available
(5 min | 1402 words)
GitHub Copilot in VS Code, Universe releases
(8 min | 2524 words)
Generate and edit images directly in Copilot
(5 min | 1464 words)
GitHub Copilot Fusion now supports selection of local models
(6 min | 1716 words)
GitHub Agentic Workflows generally available
(6 min | 1782 words)
The October inflection point for vibe game development
(10 min | 3038 words)
I've written before about how November 2025 was an inflection point for coding agents - the point where Opus 4.5 and GPT-5.1 crossed a tipping point that meant their respective coding agents became reliable daily drivers for software engineers. I think we've reached a new inflection point in October 2026, and this time it's for vibe coding computer games.
Tree Appreciator
Emberwick
Battle Drones
Pumpkin Farmer, aka Quarter Sun Cove
Four times as insulting
What happens if someone actually puts the work in?
You should build a game!
Claude Opus 5.5 in particular exhibits meaningful improvements in several areas needed to build a compelling game:
3D modeling
Music generation (see Scrimshaw Jukebox)
Game design (!)
That last one is particularly important. Models have been able to create something that looks like a game for quite a while now, as seen in my previous experiments. The challenge has been getting to a game that's actually fun to play.
Game design is a deep subject area. I won't pretend to be well versed in it - I know enough to have respect for it as a craft. Creating a novel, compelling gameplay loop which challenges players at the right level and provides a satisfying learning curve is a fine art. I didn't think the models could do it.
Then I tried telling Claude Opus 5.5 to "Make it a LOT more fun"... and it did.
In the past few weeks I've vibe coded (in the classic sense of the term - no looking at the code at all) four games that I've genuinely enjoyed playing.
I attended Foo Camp in Berkeley over the weekend and met several people who were having similar experiences. Building games that play well is shockingly easy now. The new challenge is coming up with concepts for games that are novel and delightful and that wouldn't exist without AI assistance.
I haven't done an exhaustive study, but my current impression is that GPT-6 Astra isn't quite there yet. It can absolutely build a game, but its sense of fun doesn't match that of Opus 5.5. I expect OpenAI will get there by the end of the year.
Here are the four game projects that have convinced me that the models are now capable of producing fun games with very little guidance. All four are built in HTML and JavaScript and run entirely in the browser.
Tree Appreciator
The smallest game I found to be genuinely delightful is Tree Appreciator. I used the regular Claude chat interface for this - it didn't even need Claude Code.
I built this on a whim while we were driving along Skyline Boulevard looking at trees. My prompt was:
Build a three js game called "Tree appreciator" - it shows you two algorithmically generated trees and the game mechanics is about appreciating the differences between them. Think hard about how to make sure it is both fun and beautiful.
I've found that telling models to use three.js works really well. Claude doesn't have its own image generation model but is capable of building full-color 3D models that look and feel excellent.
This game required no iteration or follow-up prompting at all - I got the game in a single shot. It gave me back a charming little mobile-friendly spot-the-difference game. You can play that here. Here's the chat transcript that built it.
It's pleasingly relaxing. The graphics are fun, and collecting trees that you have completed in a "herbarium" provides a nice, cosy sense of accomplishment.
Emberwick
This was a more ambitious project that I again built using regular Claude chat. I started out by building an experimental prototype of an engine for a top-down fantasy RPG:
Build a demo game engine three.js which is a top down (but at an angle) RPG - the player gets to move through the world with one or two companions. Create a fantasy village setting that demonstrates walking around outside and then shows how when the player enters a building the wall between the player and the camera goes transparent so the user can see what is happening
Add some NPCs and plenty of furniture and different types of building some with an upstairs - be creative, make it look great
Here's that first version. It worked really well!
I was inspired to increase my ambitions:
Make it not so flat - the buildings are great but the landscape itself is completely flat at the moment, fix that
Add basements to two of the buildings with a tunnel system joining them below the village
Add the start of a rocky mountain on one side of the village containing a cave with a sleeping troll
Here's that version.
When that produced a good result, I decided to push it all the way:
Now turn this into an actual game - quadruple the size of the playable area, introduce fun game mechanics, add a plot that isn't too cliche, some twists, a magic system, make it really good
We're back to prompts like "make it really good" here! Asking for a plot that "isn't too cliche" seemed to work too - it's a bit cliché, but still novel enough that I enjoyed following the story.
Unlike Tree Appreciator, this took quite a bit of additional playtesting and prompting to get to a finished version. This was mainly due to gameplay problems - things like a character not being in the right place to complete a quest because a different story element had caused them to move to another location.
Here's that final game. It has a full story that takes about 15 minutes to play through.
There's even an experimental level editor if you want to drop in your own houses, furniture, and landscape features.
Once it was all working (and I'd iterated through some gameplay bugs), I played it through from start to finish and found myself emotionally affected by the ending! I'm somewhat embarrassed by this, because everything in this game - the graphics, the plot, the characters, the music, the dialog - came from the model. My creative input was pretty much just "it's a fantasy village and there's a troll asleep in a cave".
Here's the full shared Claude chat in which I built this game.
I also fed that same initial sequence of prompts through ChatGPT GPT-6 Pro. Here's the transcript and the finished game for comparison. It looks great, but I don't think it plays nearly as well.
Battle Drones
This is by far my most successful project, which I wrote about last week. It's a Command & Conquer-style Real-Time Strategy game where two robot armies (or four as of Saturday) build units, harvest scrap, and battle over territory.
This is also the project that convinced me that Opus 5.5 knows what "fun" is.
The first versions were built back in July using Claude Fable 5. It got me to a workable 2D Command & Conquer-style game, but it wasn't great to play.
I prompted Opus 5.5 to "Make it a LOT more fun" and then later to "Port this game to three.js" and the game was transformed. There's a blow-by-blow account (prompts included) in my write-up.
Today, Battle Drones has 2-4 player multiplayer (via a vibe coded WebSockets relay server), medals, replays, seven maps, a random map generator, and a set of "mutators" that add variants of the rules.
It also lets different LLMs play against each other, using a mode where the game advances five seconds and then pauses to give different models time to interpret the new game state and line up their next set of commands. Here's a replay of Claude Haiku 5.5 vs. GPT-6 Luna:
Battle Drones is a particularly good example of Opus 5.5's ability to create 3D models. This page lets you browse all of the models in the game.
I released Battle Drones under the Apache 2.0 License last Tuesday. On Wednesday Gabriel Turpin released Panache (screenshots here), a fork of Battle Drones that reimagined the game for steampunk 1900s Belle Époque France, with new models and music and an animated intro sequence. Open source at work!
Pumpkin Farmer, aka Quarter Sun Cove
I live in Half Moon Bay, California, home of the annual Half Moon Bay Art and Pumpkin Festival, which includes a giant pumpkin weigh-off competition.
I decided to try building a game that wasn't just a cheap imitation of something that already existed, so I set out to create a game about farming pumpkins, growing giant pumpkins, and handling the rush of the October pumpkin season.
I called it "Quarter Sun Cove".
I'm still iterating on this project, but it's shaping up quite nicely. It's a cosy farming simulator where you spend the year tending to your giant pumpkin and planting out regular-sized pumpkins for sale in October, then sell pumpkins during pumpkin season and enter your giant pumpkin in the weigh-off.
Every character in it is a (vegetarian) animal. The mayor of the town is a pelican. You can be a pelican, skunk, raccoon, possum, beaver, coyote, fox, owl, sea otter, or harbor seal. Those species all later show up (accompanied by their children) to buy pumpkins from you.
It's absurdly cute.
You can play the latest version here. I'm not convinced by the game mechanics yet - it's actually quite complicated: you have to decide when to plant pumpkins such that they will become ripe at the weekends in October with the most visitors.
Here's the initial brainstorming session, which resulted in this spec file. Then I had Opus 5.5 Ultracode burn millions of tokens and nearly two days building it.
I told Claude to "surprise and delight the user frequently" and the result is so many little details and easter eggs. There are mischievous raccoons, an elephant seal that runs the weigh-off, harbor seals that roll their pumpkins back into the ocean, a wandering goat, and superstitions about growing giant pumpkins that sometimes come true.
This isn't my best game yet - it's not as fun to play as Battle Drones - but it represents the kind of game I want more of: weird, fun, uniquely personal - something that wouldn't have been built in the before-times.
Four times as insulting
If you are offended by AI-generated art, AI-generated music, AI-generated writing, and AI-generated code, I have bad news for you: vibe coded games combine all of those at once.
The wider games community already has an aversion to AI-generated assets in games. This has been a growing issue over the past few years as tools like Midjourney have enabled developers to generate assets for their projects. This IGN story covering complaints about slop in Valve's Steam Next Fest is a good recent example.
We now have games where everything - code, assets, dialog, and even the game design itself - can be outsourced to the models. And the results don't suck!
Building a computer game used to be one of the most challenging projects in all of software development, combining a diverse range of skills and requiring intense focus and effort over many months or even years. And now here I am spitting out a playable multiplayer RTS by prompting on my phone!
I expect that, as we've already seen with programming, this will result in a split. Some players will refuse to have anything to do with games that were built in this way. Others may embrace this as opening up game development to a much wider audience. I lean in that direction!
I certainly won't be entering any of my vibe coded games in traditional game jams or competitions - I don't feel like I've earned that right. We'll likely see new avenues emerge for vibe game developers to compare their projects.
What happens if someone actually puts the work in?
The thing I find both exciting and shameful about this is that I have got interesting results from so little creative input. The projects I've described here are loosely ordered by how much effort I've put into them. Not a single project represents more than four hours of my work (plus many more hours of Claude Code churning away by itself).
Now imagine what could be achieved by anyone who takes this seriously, invests significant creative time, applies better taste in game design, and then playtests and iterates on the result until it's as good as they can make it.
I want to see games that wouldn't have existed without these new tools.
You should build a game!
Building games in this way is so much fun. It's the perfect application for vibe coding because it's so low stakes: how much damage can you cause with a bug in a personal vibe coded game project?
(OK, you can do some damage... my attempt at audio-based multiplayer gave my wife Natalie a nasty headache!)
All of my games so far have been HTML and JavaScript using static hosting (generally GitHub Pages or Cloudflare Pages). Modern browsers - including mobile browsers - are incredibly capable. Frontier models already know libraries like three.js and Phaser. I'm finding these mobile web games to be indistinguishable from the native experience, at least for the kinds of games I'm trying to build.
I suggest starting with a prompt like this:
Build a mobile-friendly three.js game where...
This works on both chatgpt.com and claude.ai - you don't even need to fire up a full coding agent. As one last example, here's "Build a mobile-friendly three.js game where a mouse has to hide from a cat" by Claude Opus 5.5 Extra and by GPT-6 Extra High.
Switch to Codex or Claude Code once your project passes the proof-of-concept phase.
And if the game isn't fun enough, add this:
Make it a LOT more fun
Tags: game-design, games, ai, generative-ai, chatgpt, llms, claude, vibe-coding, claude-code
OpenAI and ServiceNow expand partnership across enterprise workflows
(0 min | words)
Quoting Terk Terkowitz
(3 min | 790 words)
If your work does not benefit from current AI tooling, that is a finding, not a failing. Document why, share it with your community of peers, bring it to your manager, and work to find solutions. An engineer who can explain where AI does not yet help their work is demonstrating the judgement we are asking for.
— Terk Terkowitz, An update from Amazon engineering leadership on the role of the developer in the age of AI
Tags: amazon, generative-ai, agentic-engineering, ai, llms
The future of the firm
(0 min | words)
Legora is building the agentic operating system for legal work
(0 min | words)
-
GitHub Copilot supports server-to-server authentication
(5 min | 1377 words)
Game Boy Color on My Conference Badge
(3 min | 871 words)
Game Boy Color on My Conference Badge
similar to last year, the conference badge is a full-blown color screen computer.
I've been hacking around with it again, and then I ran into with Steve Francia... who worked with Gemini to get a full NES emulator working on it, and then went a step further and deployed an emulator for both the Game Boy and the Game Boy Color.
Which means, if you can obtain the ROM, you can run The Legend of Zelda: Link's Awakening on your conference badge!
A neat feature of the badge is that you can turn it upside down and then use game controller touch buttons that are built into the badge body.
Tags: games, github, hardware-hacking, ai, generative-ai, llms, gemini, steve-francia
Retell uses OpenAI models to help power 100M monthly calls
(0 min | words)
OpenAI expands partnership with Oracle to bring its apps to ChatGPT
(0 min | words)
How Check Point accelerates vulnerability research with Daybreak
(0 min | words)
-
GPT-6.1 Terra
(4 min | 1083 words)
GPT-6.1 Terra
In the case of GPT-6.1 Terra, OpenAI went with visual reasoning and computer use:
We’re introducing GPT-6.1 Terra, a fast, efficient model that combines detailed visual reasoning and precise computer use alongside clearer, more natural writing. A significant step up from GPT‑5.6 Terra, it excels at the communication and computer-based tasks that fill the workday, from drafting proposals and interpreting technical drawings to filling out forms and editing videos.
Terra sits in the same position as Sonnet in the Anthropic model collection - not the cheapest or the most expensive, making it harder to decide when to use it.
Computer use is a good example of a task that benefits from a less expensive model, since you might put it to work on automated, repetitive tasks.
OpenAI's Ted Sanders provided some useful advice in a comment on Hacker News:
In the case of GPT-6.1 Terra, I'd say Terra is probably better than Astra and Sol at technical communication, similar on vision and computer use (but much faster!), and a bit worse on most other things. For API developers, it's a nice midrange option if you want something cheaper than Sol but a lot smarter than Luna (especially for vision / computer use / communication). For subscribers, it's not a bombshell release - if you're hitting usage limits, maybe it helps you go a bit further, and if you want clearer communication or faster computer use, it can be a nice option to select.
Here are the pelicans for the different reasoning levels. This pelican for "max" cost 11.3161 cents and took 4 minutes and 11 seconds:
Here's a new comparison grid showing pelicans for every reasoning level of OpenAI's current frontier lineup: GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna.
GPT-6.1 Terra is priced at $1/million input tokens and $5/million output - almost half the price of GPT-5.6 Terra and GPT-6.1 Sol, and around 10x the price of GPT-6 Luna.
Via Hacker News
Tags: ai, openai, generative-ai, llms, llm-pricing, pelican-riding-a-bicycle, llm-release, gpt
GitHub Copilot assisted permissions generally available
(5 min | 1480 words)
Greptile takes bug detection beyond code review with GPT-6 Astra
(0 min | words)
GPT-6.1 Terra in GitHub Copilot
(5 min | 1511 words)
Quoting Jason Koebler
(3 min | 791 words)
Because big tech platforms essentially do not have customer support and make it impossible for their users to contact a human, many people experiencing run-of-the-mill tech problems have turned to ChatGPT. And, increasingly, ChatGPT is telling people that have normal tech support problems that they have discovered something journalistically notable and that 404 Media, specifically, can help them.
— Jason Koebler, ChatGPT Keeps Telling People 404 Media Can Solve Their Tech Support Problems
Tags: jason-koebler, openai, journalism, ai, llms, ai-ethics, ai-misuse, generative-ai, chatgpt, 404-media
webframe: evaluated as a scraper and a sandbox
(3 min | 966 words)
Research: webframe: evaluated as a scraper and a sandbox
webframe is a neat little project from Jeff Lindsay which lets you "run a web page like a program" - you point it at a URL or file and it executes it in a hidden headless web view and outputs console.log() to standard output and any exceptions to standard error.
It's written in Go on top of the glaze library, which provides access to a system browser ("WKWebView on macOS, WebKitGTK on Linux, WebView2 on Windows") so it doesn't need to bundle its own browser engine.
It reminds me of my own shot-scraper javascript tool, albeit in a much smaller package that doesn't depend on Playwright.
I had Claude Opus 5.5 put it through its paces and prepare a research report for me. Here's the prompt I used:
Explore https://github.com/tractordev/webframe try running it and put it though its paces, build a few exploratory prototypes, then evaluate it as a potential sandboxing tool and as a tool for scraping web pages using the same patterns encouraged by the "shot-scraper JavaScript" command (see simonw/shot-scraper on GitHub, docs directory)
Tags: browsers, go, javascript, jeff-lindsay, shot-scraper
Working with academic communities to build scientific understanding
(0 min | words)
GPT-6.1 Sol helps CodeRabbit strengthen security across complex codebases
(0 min | words)
ChatGPT’s expanding world of work
(0 min | words)
How Fanatics and OpenAI streamline the fan experience
(0 min | words)
How Ultrafast cut incident investigation from hours to minutes at OpenAI
(0 min | words)
Introducing GPT-6.1 Terra
(0 min | words)
-
Seam Cutter
(3 min | 818 words)
-
battledrones v14: Compass Rose, a four player map
(3 min | 898 words)
-
Usage metrics API adds usage from tools like OpenCode
(6 min | 1725 words)
Quick Study
(3 min | 790 words)
Turn notifications into code with GitHub Copilot in Teams
(5 min | 1492 words)
Introducing Kimi K3.1 Pro
(3 min | 1023 words)
Introducing Kimi K3.1 Pro
They're also offering a "Highspeed" version that's 2-3x faster, at twice the price (except for input token cache hits, which are priced the same).
The US dollar pricing is $2.00/million tokens for input and $10/million for output - the same as GPT-6.1 Sol and half the price of Claude Opus 5.5.
Moonshot's own benchmarks show Kimi as approximately level with Opus 5.5 and GPT-6 Astra - beating them on a few benchmarks, coming close on others.
Artificial Analysis scored Kimi at 55 - ahead of Claude Fable 5.1, GPT-6 Astra, and Gemini 4 Argon (all at 53) and behind only Claude Opus 5.5 (58).
This is the first time a (soon-to-be) open weight model has scored this highly against the frontier.
I tried it out via the Moonshot API using the llm openai endpoint command I added to LLM 0.32 back in August:
llm openai endpoint \
https://api.moonshot.ai/v1 \
--key kimi \
-m kimi-k3.1-pro \
"Generate an SVG of a pelican riding a bicycle" \
--responses \
-o reasoning_effort low \
> kimi-k3.1-pro-pelican-low.stdout.txt \
2> kimi-k3.1-pro-pelican-low.stderr.txt
llm openai endpoint can run prompts against any OpenAI-compatible endpoint but doesn't log the results, hence the extra options to save stdout and stderr (the reasoning trace).
Here are the pelicans I got for Kimi K3.1 Pro on the three reasoning levels it supports - low, medium, and max. This is max:
For comparison, I ran fresh pelicans against Kimi K3 on those three reasoning levels.
Via Hacker News
Tags: ai, generative-ai, llms, llm, llm-pricing, pelican-riding-a-bicycle, llm-release, ai-in-china, moonshot, kimi
EMU deletions fix
(5 min | 1623 words)
Public monitoring adds triage, validity, API, and webhooks
(5 min | 1637 words)
Rapidly scaling online storage to serve over 1 billion ChatGPT users (Part II)
(0 min | words)
Enterprise installations for GitHub Apps generally available
(6 min | 1796 words)
Securing our frontier model training environment
(0 min | words)