When Claude Code Wrote a Full Database Engine Overnight: What ‘Ultracode’ Mode Actually Did
Simon Willison used Claude Code's Ultracode mode — which coordinates parallel AI subagents for complex tasks — to produce a full SPARQL 1.1 SQLite extension in Rust overnight from a single typo-filled prompt. His account honestly surfaces the core tradeoff: agentic AI can now build at extraordinary speed, but the gap between 'looks finished' and 'is trustworthy' still demands expert review.
A Typo Became a 12-Hour Engineering Project
In October 2026, Simon Willison — the developer and researcher whose site at simonwillison.net is one of the most closely watched sources for AI tooling analysis — published a candid account of something remarkable and unsettling. He typed a prompt into Claude Code for web, made a typo (he meant “hit the rows directly” but wrote “hit the delete rows directly”), and walked away. The next day, he had what appeared to be a fully functioning SPARQL 1.1 implementation embedded inside SQLite, written in Rust, complete with multiple crates, README files, a tutorial, and realistic example data scripts.
The tool he accidentally commissioned is now called sparqlite. But the real story here is not about the software. It is about what Claude Code’s “Ultracode” mode is, what it can do, and what the experience of using it honestly looks like — including the parts that should give you pause.
What Is Ultracode Mode?
According to Anthropic’s Claude Code documentation, specifically the section titled Orchestrate subagents at scale with dynamic workflows, Ultracode is a setting within Claude Code for web that changes how the agent approaches complex problems. Simon Willison’s analysis describes it this way: with Ultracode turned on, Claude Code “makes aggressive use of dynamic workflows — it generates JavaScript that defines and coordinates a network of subagents to take on complex problems.”
To put this in plain language: instead of Claude working on your problem as a single, sequential chain of thought, it effectively splits the job into many smaller tasks and assigns those tasks to a coordinated group of sub-processes, each handling a piece of the puzzle simultaneously. Think of it less like hiring one freelancer to build your office, and more like commissioning an entire construction crew — architect, electrician, plumber, carpenter — who all work in parallel.
This is why a single prompt, even a badly worded one, could produce a multi-file, multi-module Rust project spanning an entire night’s worth of compute time. The system was not just writing code; it was orchestrating an internal assembly line.
What Did It Actually Build?
Based on Willison’s account, the output of this 12-plus-hour session was a SQLite extension written in Rust that embeds SPARQL 1.1 — a query language used for navigating graph-structured data, particularly in the semantic web and knowledge graph world. SQLite is the lightweight database that lives inside almost every Android phone, web browser, and countless enterprise applications. SPARQL is the language used to query RDF (Resource Description Framework) data — the kind of structured, linked data that powers knowledge graphs.
Combining the two is a non-trivial engineering challenge. Normally, you would need separate infrastructure to handle graph queries, a standalone triple store or a dedicated graph database. What sparqlite theoretically offers is the ability to ask graph-style questions directly inside a SQLite database, without standing up separate systems.
Willison also notes that when he followed up with a second prompt, Claude Code added documentation across every folder in the project, produced a full tutorial.md teaching users how to install the extension and learn SPARQL from scratch, and generated scripts to populate the database with realistic example data. All from one follow-up message.
A Scenario Closer to Home: A Knowledge Management Team in Hyderabad
Consider a policy research team at a think tank in Hyderabad that tracks legislative data — bills, their authors, the committees that reviewed them, the amendments they went through, and the organizations that lobbied for or against them. This is fundamentally a graph problem: everything is connected to everything else through relationships, not just rows and columns.
Today, that team likely stores this data in spreadsheets or a simple relational database, then struggles to answer questions like “Which organisations lobbied for bills authored by members of the finance committee in the last three years?” because the data lives in separate tables with no elegant way to traverse relationships.
Something like sparqlite — if it works as described — would let that team keep all their data in a single SQLite file and write SPARQL queries to navigate the graph of relationships directly. No separate graph database server, no cloud subscription, no vendor lock-in. The entire setup would run on a laptop.
The catch, which Willison himself acknowledges plainly, is that he cannot fully verify whether what was built actually works correctly. And that is the honest limitation you need to understand.
The Limitation Willison Named Directly
This is where Willison’s post becomes genuinely important for you to read, not just for the excitement of what was produced, but for the intellectual honesty about what it means. He writes: “This project feels like next-level vibe coding — it’s not remotely feasible to review the code that was produced here, and even following the documentation is a significant investment in work.”
He then asks the question directly: “I’m not entirely sure what to do with this — I appear to have a full SPARQL implementation in Rust inside SQLite now, but how valuable is that if I created it on a whim and can’t (or won’t) invest the necessary time to understand what it can do?”
This is the core tradeoff of Ultracode-style agentic coding at this scale. The output is voluminous. It is structured. It comes with documentation. But the person who prompted it into existence has no clear path to trusting it without significant independent expertise — in this case, Rust, SQLite extension APIs, SPARQL specification compliance, and graph query performance benchmarking.
There are no benchmark scores cited in Willison’s account. There is no verification that the SPARQL 1.1 implementation is spec-compliant. There is no production-readiness assessment. What exists is a project that appears to work, produced at a speed that no human team could match, but which carries an invisible quality ceiling that only deep expert review could measure.
What This Tells You About Claude Code’s Direction
The Ultracode mode, as documented by Anthropic and analyzed by Willison, represents a shift in what AI coding tools are being designed to do. Earlier AI coding assistants completed lines of code or suggested functions. Ultracode coordinates entire project architectures across parallel subagents.
For non-technical professionals, this is simultaneously more accessible and more dangerous. More accessible because you can describe a problem in plain language — even a typo-filled one — and receive something that looks like a finished product. More dangerous because the gap between “looks finished” and “is trustworthy” is now wider than ever, and crossing that gap still requires exactly the kind of domain expertise most non-technical users do not have.
The honest framing is this: Ultracode mode is a powerful research and prototyping accelerant. It can compress weeks of initial scaffolding into hours. But the result it produces is a starting point for expert review, not a finished product ready for use.
What to Watch For Next
Willison’s sparqlite experiment sits at the intersection of several fast-moving areas: agentic AI systems, SQLite as a universal data layer, the revival of semantic web tooling, and the Rust ecosystem’s growing dominance in systems programming. Each of these has independent momentum.
If you are a non-technical professional curious about AI coding agents, the most useful thing you can do right now is read Willison’s full account at simonwillison.net — not to learn Rust or SPARQL, but to develop an accurate mental model of what “AI built this” actually means in practice. It means a foundation was laid, quickly and impressively. It does not yet mean the foundation was inspected.
Anthropics Claude Code documentation on Ultracode mode is also worth bookmarking, particularly the section on dynamic workflows, because this capability is still being actively developed. The ceiling of what a single prompt can commission is rising fast. Understanding where that ceiling sits — and what lies above it that still requires human judgment — is becoming one of the most important professional skills of the next few years.
