A Google engineer tried building SQLite devtools with AI, got a working prototype, and discovered the architecture was unsalvageable. The story of what happened next is the clearest accounting I have seen of what AI does to design decisions.
image from Gemini Imagen 4
Google engineer Lalit Maganti spent three months vibe-coding SQLite devtools with Claude Code, building a working prototype with parser, formatter, and web playground—but the codebase was incoherent spaghetti with architecture belonging to the AI rather than his vision. He deleted everything and rebuilt in Rust with upfront human design decisions, treating AI as a tool rather than an architect. The project shipped complete (editor extensions, Python bindings, WASM playground, multi-ecosystem packaging) partly because AI made last-mile work affordable, while his research assistant use of AI compressed days of reading into focused conversations.
Lalit Maganti spent eight years wanting better devtools for SQLite. He spent three months vibe-coding them with Claude Code. Then he threw the whole thing away.
The Google engineer, who maintains PerfettoSQL (a SQLite dialect used internally at Google across more than 200,000 lines of code), describes the experience in a detailed post that Simon Willison, writing on his blog, called "one of the best pieces of long-form writing on agentic engineering I've seen." The short version: AI got him unstuck on a project he had been procrastinating for nearly a decade, then nearly wrecked it.
"I found that AI made me defer key design decisions," Maganti writes. "Because refactoring was cheap, I could always say 'I'll deal with this later.' And because AI could refactor at the same industrial scale it generated code, the cost of deferring felt low. But it wasn't: deferring decisions corroded my ability to think clearly because the codebase stayed confusing in the meantime."
The prototype he built in January worked. It had a parser in C extracted from SQLite sources, a formatter, support for both the SQLite language and PerfettoSQL extensions, and a web playground. It generated more than 500 tests that Maganti considered reusable. The approach was viable.
When he looked at the actual codebase in late January, it was spaghetti. Functions scattered across files without a coherent shape, a few files grown to several thousand lines each, large parts of the Python source extraction pipeline that he did not understand. The architecture (what little existed) was AI's, not his. It solved the immediate problem but would not survive his actual vision.
So he deleted everything and started over.
The second attempt switched from Python and C to Rust, and introduced something the first lacked: human judgment applied upfront, not in retrospect. Maganti took ownership of every design decision. He reviewed every change. He fixed problems when he spotted them rather than deferring. He invested in scaffolding (linting, validation, non-trivial testing) to check AI output automatically. The 500 tests from the dead prototype became the foundation for the second build.
What makes Maganti's account worth reading is that he does not draw a simple conclusion. The project exists because of AI. It shipped as complete as it did (editor extensions, Python bindings, a WASM playground, documentation, packaging across multiple ecosystems) because AI made the last-mile work affordable. Maganti estimates he would have shipped something much smaller without it. AI also served as a research assistant, pointing him to the Wadler-Lindig pretty-printing algorithm and compressing days of reading into focused conversations. When he needed to context-switch between parts of the project, AI reacquired him on demand.
The failure mode was specific and technical: design decisions with no objectively checkable answer. Implementation has a right answer at the local level (the code compiles, the tests pass, the output matches the specification). Design does not. "We're still arguing about OOP decades after it first took off," Willison notes.
Maganti's formulation is more precise. When he did not know what he wanted, AI was somewhere between unhelpful and harmful. "I spent weeks in the early days following AI down dead ends, exploring designs that felt productive in the moment but collapsed under scrutiny." He suspects it would have been faster to think through the architecture without AI in the loop at all.
The counterpoint matters equally. AI excelled at obvious code, at the kind of well-specified, predictable work where consistency and completeness are the goals. "For the vast majority of code in any project, standard is exactly what you want," Maganti writes. The problems came at the edges (the extraction pipeline, the parser architecture), where the project needed non-obvious solutions. Those were the parts AI could not see and that required human taste.
This is not a story about AI failing. It is a story about where AI fails and the conditions that create the difference. The project survived because Maganti recognized what AI was doing to his decision-making, threw away the evidence of his deference, and rebuilt with clearer boundaries.
The question worth sitting with: most developers using AI coding tools are not building SQLite parsers. They are building things where they know what they want. For that use case (well-specified implementation work), Maganti's experience suggests AI is genuinely good. The harder gap to close is knowing the difference between what you want and what you think you want, before the AI starts generating code that makes deferral feel free.
Syntaqlite 0.1 launched in mid-March. The project site is at syntaqlite.org and the GitHub repo is here.
Story entered the newsroom
Research completed — 4 sources registered. Lalit Maganti, Google engineer and PerfettoSQL maintainer, spent 8 years wanting SQLite devtools. Used Claude Code for 3 months (~250 hours) to build
Draft (791 words)
Reporter revised draft (802 words)
Reporter revised draft (762 words)
Approved for publication
Published (761 words)
Get the best frontier systems analysis delivered weekly. No spam, no fluff.
Artificial Intelligence · 12m ago · 5 min read
Artificial Intelligence · 22m ago · 4 min read
