Building Syntaqlite with AI: Real Talk on Devtools for SQLite 🔥

by keyboardai-agentsdevtoolslink-noteparserssqlite

Yo, dude, this post is gold—Lalit spent 8 years dreaming of killer SQLite devtools (formatter, linter, LSP), then crushed it in 3 months (~250 hrs) using AI agents like Claude Code. But it's no fairy tale; he breaks down the wins and the pains. Let's unpack the big ideas without the hype. 🚀

WHY SQLite Devtools Sucked (The Pain That Killed Motivation) 💀

Before: SQLite powers everything—phones, browsers, embedded systems—but devtools? Trash.

  • No reliable parser: Existing ones approximated SQL, broke on edge cases (e.g., ate comments, ignored virtual tables).
  • No formal spec or stable parser API. SQLite skips parse trees entirely, jumps straight to bytecode. 🤯
  • Dense C codebase: 400+ grammar rules, fiendishly hard to grok.
  • Result? Formatters/linters slow, unreliable. For Lalit's PerfettoSQL (SQLite extension), workarounds everywhere.

The "ohhh" moment: Perfect parsing unlocks everything—accurate trees for formatters, linters, VS Code smarts like TypeScript. But solo? Too hard + tedious for side project. Bugs, tests, docs? Motivation killer.

PROBLEM (BEFORE)                  SOLUTION (SYNTAGQLITE)
════════════════                  ════════════════
    │                                   │
    ▼                                   ▼
┌─────────────────────┐         ┌─────────────────────┐
│ Approx parsers ❌    │  ───►   │ Exact parse tree ✅  │
│ Breaks on edges     │         │ Formatter/linter/   │
│ Slow, unreliable    │         │ LSP for *all* SQL   │
│ No PerfettoSQL      │         │ Rust-powered, fast  │
└─────────────────────┘         └─────────────────────┘

BIG PICTURE: What Syntaqlite Is & Where It Fits ⚡

Syntaqlite = High-fidelity SQLite devtools suite:

  • Core: Parser extracted from SQLite source (tokenizer + Lemon-generated grammar).
  • Built on: Parse tree (missing in SQLite) → powers formatter (Wadler-Lindig pretty-printing), linter, validator.
  • Exposed as: CLI, LSP (VS Code/Zed extensions), Python/WASM bindings, playground.
  • Fits: Any SQLite user, extensible to dialects like PerfettoSQL.
SQLite SQL ──► Tokenizer (C) ──► Grammar Rules (~400) ──► Parse Tree ──► Devtools
                                      │
                                      ▼ (AI helped generate/map rules)
                          Formatter/Linter/LSP/Validator

Not a DB wrapper—language tools like Prettier + ESLint for SQL, but SQLite-precise.

HOW AI Made It Happen (Mechanics + Wins) ✅

Lalit vibe-coded first (delegate everything to Claude), got prototype + 500 tests, but spaghetti → full Rust rewrite with him owning design.

Step-by-step AI workflow:

  1. Overcome inertia: AI prototypes fast → concrete code to critique, not endless head-thinking.
  2. Churn obvious code: AI > human for "standard" stuff (docs, consistent style). Broke problems into "write func X with Y params."
  3. Refactor loop: Generate → review → AI refactor → human taste-check. Constant, or codebase rots.
  4. Research TA: Explained Wadler-Lindig printing, Rust tooling, LSP APIs in convos. Hours → minutes.
  5. Last-mile polish: Extensions, docs, packaging—each a "weekend project," AI made 'em cheap.
  6. Scaffolding: Upstream SQLite tests (1.3k files) validate parser matches real SQLite exactly.

AI shine zones:

┌─────────────────────────────┐
│ AI KILLS IT ✅               │
├─────────────────────────────┤
│ • Obvious impl (funcs/classes)│
│ • Refactors at scale         │
│ • Research/new domains      │
│ • Parser rule gen (w/ review)│
│ • UX prototypes             │
└─────────────────────────────┘

            │ "Relativity"
            ▼ Knows what you know
┌─────────────────────────────┐
│ AI SUCKS ❌                  │
├─────────────────────────────┤
│ • Architecture/design       │
│ • Taste (API feel)          │
│ • History/time sense        │
│ • Unverifiable tasks        │
└─────────────────────────────┘

Result: Shipped complete (0.1 in Mar 2026). Without AI? Smaller, no extensions/docs.

The Dark Side: AI Costs & Pitfalls 😱

AI ain't free. Lalit calls it out raw.

Biggest traps:

  • Addiction loop: Slot machine vibes—"one more prompt." Tired? Vague prompts → slop → more tries → exhaustion.
  • Losing touch: Skip reading code → mental model fades → bad comms w/ AI ("fix the thing that does Bar").
  • Design procrastination: Easy refactor → defer decisions → confusing codebase → clear thinking dies.
  • False security: 500+ tests? Still scrapped prototype. No crystal ball for edges.
  • No time sense: AI forgets evolution/history. Humans carry "why this API changed" implicitly.

Fixes he learned:

  • Own all decisions upfront.
  • Read/review every change.
  • Tight process: Design → scaffold (lints/tests) → generate → refactor → audit.
  • Stay "in touch"—manual code walks.
AI USER SKILL MAP              (Lalit's "Relativity")
═══════════════════════════════
Your Expertise ─────► AI Win %
Known + verifiable ─► 100% 🚀 (parser rules)
Known + fuzzy ──────► 70%  (formatter)
Unknown ────────────► 20% 💀 (arch)

LOCK IT IN: TL;DR 🔥

  • Why Syntaqlite? SQLite huge, devtools weak → exact parser unlocks pro tools.
  • AI force-multiplier: Impl/research speed → bigger project, but you drive design/taste.
  • Golden rule: Concrete + verifiable = AI godmode. Abstract/global = human only.
  • Burn this: Vibe-code prototypes, rewrite structured. Refactor relentlessly or die.

Trackin'? Syntaqlite GitHub = here. Deeper on parsers/AI workflows? Hit me. 😂

Original article

← All notes