The compile-time column lineage is the most interesting piece here. Most lineage tools reconstruct the graph after execution by parsing query logs, which means you're always looking at what happened, never what will happen. Getting lineage from the compiler means you can answer "what downstream models break if I rename this column" before you push, which is the question that actually matters in practice.
The schema-grounded AI feature is worth expanding on. The gap in most AI-generated SQL today is not syntax correctness - modern LLMs are surprisingly good at producing valid SQL - it's semantic correctness. The query parses and runs, but it joins on the wrong key or aggregates at the wrong grain because the model hallucinated a relationship that doesn't exist in the schema. Having a compiler that type-checks generated SQL against the actual DAG catches exactly this class of error.
This is relevant for the broader NL-to-SQL space too. Tools like ai2sql.io (https://ai2sql.io) that convert natural language to SQL produce structurally correct queries, but without schema validation the output can silently reference stale columns or missed foreign keys. A compile step that validates against the live graph would close that gap. Disclosure: I work on ai2sql.io.
Two questions on the branch/replay design: How does branch isolation work for stateful models (incremental, snapshot)? And for cost attribution - are you tracking warehouse compute cost only, or also cost of data scanned? On Snowflake the credit cost and scan volume can tell very different stories about query efficiency.
Thanks for the careful read. The "what breaks if I rename this column" question is exactly what column lineage from the compiler is meant to answer, and you said it better than I did in the post.
On the schema-grounded AI angle: agreed. The failure mode you describe — structurally valid SQL that joins on the wrong key or aggregates at the wrong grain because the model hallucinated a relationship — is exactly what the compiler is positioned to catch. AI-generated SQL runs through the type checker before it can land, so suggestions that don't validate against the actual DAG never reach the user. NL-to-SQL tools that integrate a compile step would close exactly the gap you're pointing at.
On your two questions:
1. Branch isolation for stateful models — mixed answer, and worth being honest about:
- Incremental: isolated. The watermark `state_key` includes the resolved schema, and `rocky branch create` swaps the schema prefix. So a branch run reads/writes a different redb key than main and they don't advance each other.
- Snapshot: not yet. Today `rocky branch create` only writes a branch record; it doesn't copy warehouse tables. A snapshot model on a branch starts with an empty table (CREATE TABLE IF NOT EXISTS in the branch schema) and accumulates from the first branch run, with no inherited history from main. That's the gap. The fix is the next wave: native Delta SHALLOW CLONE / Snowflake zero-copy at branch creation, which gives point-in-time snapshot semantics without copy-on-write overhead.
2. Cost attribution. Both bytes scanned and duration are captured per-model in the run record (`bytes_scanned` and duration on `RunRecord`). Budget gating today is on cost (USD) and duration — `max_usd` and `max_duration_ms` in `[budget]` blocks in `rocky.toml`, as independent thresholds. A direct bytes-scanned budget threshold isn't gateable today; the bytes are in the run record for analysis but you can't currently fail CI on "this run scanned more than N TB". Reasonable extension if there's demand.
To your Snowflake point: the warehouse-size × duration credit model and the scan volume tell genuinely different stories, so they're tracked separately rather than rolled into a single number.
The "zero-config" angle is strong here — the biggest friction with pgvector is the manual pipeline: choose an embedding model, write the chunking logic, create the index, tune the distance metric. Abstracting that into a single CLI command removes the part that stops most teams from even starting.
Question on the embedding side: are you generating embeddings at INSERT time via triggers, or is there a batch sync step? The trigger approach gives you real-time search but adds write latency. Batch sync is friendlier for high-throughput tables but means search results can lag behind.
Also curious how you handle schema evolution — if someone adds a new text column they want searchable, does pgsemantic pick that up automatically or require a re-config?
One pattern I've seen work well alongside semantic search: pairing it with natural language → SQL translation (tools like ai2sql.io do this) so users can combine structured filters with vector similarity in a single query. Something like "find invoices from Q1 similar to 'billing dispute'" where the date filter is SQL and the similarity part is pgvector. That hybrid query pattern is where most real-world use cases end up.
The .mode options in SQLite's CLI are surprisingly comprehensive for what most people treat as a lightweight embedded database. Table mode and box mode in particular make ad-hoc queries readable without piping through external tools.
One underrated use case: switching between .mode json and .mode csv lets you prototype data pipelines entirely inside the SQLite shell. You can validate query logic, check edge cases in formatting, and export in the right shape without writing a single line of application code.
The challenge for newcomers is discoverability. Most people learn about .mode column and .headers on from Stack Overflow answers, then never explore further. Having the full formatting reference documented in one place helps bridge that gap — especially for people coming from tools like ai2sql.io (disclosure: I work on this) where the focus is getting the query right first, and formatting the output is a separate step they often haven't thought about yet.
Consider Microsoft Clarity—it's free, offers session recordings, heatmaps, and detailed insights. It's easy to integrate with Vercel, and unlike usage-based platforms, has no hidden costs. A good alternative if you want more than basic analytics.
Canvas lets you interact with and edit code/documents more fluidly. I used it to transform my HTML blog into TypeScript in no time! Super helpful for coding and experimenting. https://x.com/mustafaergisi/status/1841946224682774536
I think they mean at the end of the clip they drag the slider from HTML to Typescript and it puts all of the blog data into structured Typescript data then writes a function which will generate an HTML page from that. The resulting blog output will still eventually be HTML, it's just whether the entries are made as data segments automatically stitched together or entered via raw HTML formatting.
Since immigration sponsorship is crucial, it’s wise to stay while passively exploring new opportunities and networking. Focus on upskilling or working on side projects to keep yourself prepared for future moves. If the current role isn’t providing value, think about how it can still support your long-term goals.
I tested Llama 3.2 on my MacBook, and it runs impressively fast. I plan to look more deeply into its capabilities and have some specific use cases in mind for further testing. Fine-tuning could be improved, and better integration with AI stacks like RAG would be helpful. Overall, it's a solid model with great potential! https://x.com/mustafaergisi/status/1839647877498278311
An alternative to Agile is Deep Work, which focuses on uninterrupted time for focused problem-solving instead of frequent meetings and updates. While Agile promotes quick iterations, Deep Work emphasizes sustained concentration, allowing teams to tackle complex tasks without distractions. It’s not a framework, but a focus-oriented approach that could complement or enhance existing workflows.
The schema-grounded AI feature is worth expanding on. The gap in most AI-generated SQL today is not syntax correctness - modern LLMs are surprisingly good at producing valid SQL - it's semantic correctness. The query parses and runs, but it joins on the wrong key or aggregates at the wrong grain because the model hallucinated a relationship that doesn't exist in the schema. Having a compiler that type-checks generated SQL against the actual DAG catches exactly this class of error.
This is relevant for the broader NL-to-SQL space too. Tools like ai2sql.io (https://ai2sql.io) that convert natural language to SQL produce structurally correct queries, but without schema validation the output can silently reference stale columns or missed foreign keys. A compile step that validates against the live graph would close that gap. Disclosure: I work on ai2sql.io.
Two questions on the branch/replay design: How does branch isolation work for stateful models (incremental, snapshot)? And for cost attribution - are you tracking warehouse compute cost only, or also cost of data scanned? On Snowflake the credit cost and scan volume can tell very different stories about query efficiency.
reply