mritchie712

We[0] support Google Sheets as a source out of the box[1]. We have connectors for 500 sources and can grab data from anything with an API.

Definite spins up a datalake for you and pipelines to get data into the lake. We also have BI (semantic layer + dashboards) and an AI agent that will build reports for you. Let me know if you need a hand getting set up! I'm mike@definite.app.

0 - https://www.definite.app/

1 - https://docs.definite.app/extractors/gsheetquerying

this is why I liked Looker. The only way to build reports was from the semantic layer which was easy to use and built into the BI.

we took the same approach when we started https://www.definite.app/.

if you're looking for something like SQLMesh, then I'd stay away from crabwalk.

it's purely meant to run SQL transformations in DuckDB in a reliable way with data lineage.

We built a transformation library[0] (think a simpler, more performant dbt) for duckdb and I'd really like to create a semantic layer as an extension for it at some point.

Limiting support to only duckdb would make some really useful features trivial to implement. e.g. duckdb has a `json_serialize_sql` function that would handle a lot of the tedious parts of building a semantic layer.

0 - https://github.com/definite-app/crabwalk

you can host e2b: https://github.com/e2b-dev/infra/blob/main/self-host.md

we host it for https://www.definite.app/. You'd need pretty heavy usage to beat e2b's pricing.

yeah, I know notebooks are used broadly (used them for years myself). I just haven't run into companies using Observable specifically in the wild.

uv.

Observable has always demo'd well and looked cool, but I never understood the business application. Does anyone use it for work?

I want this in Warp. It's a solid terminal, but Claude Code is so good that I don't need my terminal trying to do something similar without me asking it to.

We just open-sourced our Meltano (Singer) target[0] for Ducklake (from DuckDB). This gives you access to 500+ connectors (e.g. Hubspot, Stripe, Postgres, etc.):

* Type conversion is automatic (timestamps stay timestamps).

* Append or merge: choose at runtime.

* Storage is portable (S3, GCS, or local).

* Works with Postgres, MySQL, SQLite, or DuckDB catalogs.

* Timestamp and categorical partitions are built in.

We're already running it in production here at Definite and open to feature requests / PRs.

0 - https://github.com/definite-app/target-ducklake

that's my point. He's "Betting Against AI Agents" without having taken a serious attempt at building one.

> agents that technically make successful API calls but can't actually accomplish complex workflows because they don't understand what happened.

It takes a long time to get these things right.

> I've built 12+ production AI agent systems across development, DevOps, and data operations

It's hard to make *one* good product (see startup failure rates). You couldn't make 12 (as seemingly a solo dev?) and you're surprised?

we've been working on Definite[0] for 2 years with a small team and it only started getting really good in the past 6 months.

0 - data stack + AI agent: https://www.definite.app/

not sure of windsurf's ToS, but Google could be after the usage data (e.g. did the user accept the suggested edit? if not, what did they change it to? etc.)

> Couldn't find one, so I built one.

there are no less than 100 of these.

meltano4life

if Project Hail Mary isn't a good sci-fi book, what is a good one?

the snippets are examples. You can ask hundreds of variations of similar, but different, complex questions and the LLM can adjust the example for that need.

I don't have a snippet for, "find all 500's for the meltano service for duckdb syntax errors", but it'd easily nail that given the existing examples.

> try completing a GitHub task with the GitHub MCP, then repeat it with the gh CLI tool. You'll almost certainly find the latter uses context far more efficiently and you get to your intended results quicker.

This is spot on. I have a "devops" folder with a CLAUDE.md with bash commands for common tasks (e.g. find prod / staging logs with this integration ID).

When I complete a novel task (e.g. count all the rows that were synced from stripe to duckdb) I tell Claude to update CLAUDE.md with the example. The next time I ask a similar question, Claude one-shots it.

This is the first few lines of the CLAUDE.md

    This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

    ## Purpose
    This devops folder is dedicated to Google Cloud Platform (GCP) operations, focusing on:
    - Google Cloud Composer (Airflow) DAG management and monitoring
    - Google Cloud Logging queries and analysis
    - Kubernetes cluster management (GKE)
    - Cloud Run service debugging

    ## Common DevOps Commands

    ### Google Cloud Composer
    ```bash
    # View Composer environment details
    gcloud composer environments describe meltano --location us-central1 --project definite-some-id

    # List DAGs in the environment
    gcloud composer environments storage dags list --environment meltano --location us-central1 --project definite-some-id

    # View DAG runs
    gcloud composer environments run meltano --location us-central1 dags list

    # Check Airflow logs
    gcloud logging read 'resource.type="cloud_composer_environment" AND resource.labels.environment_name="meltano"' --project definite-some-id --limit 50

we specialize in "don't ask engineering for SQL" at https://www.definite.app/.

we spin up a data lake, load all your data and educate an agent on your data.

it wasn't obvious to me how Double is significantly better than an ETF. It'd have to be MUCH better (e.g. at least 50bps to 100bps) to warrant taking a bet on an unproven company.

They had cute names for the indexes ("Founder Mode")... but do those actually make me better returns than an ETF? Probably not.

this[0] also scared me away

0 - https://news.ycombinator.com/item?id=42377934

I use this prompt to spin up demos for customers at https://www.definite.app/:

    @Web Do some research on https://somecompany.com and write up a detailed overview of what the company does. What might their database schema look like?

    I need you to build a mock database for them in duckdb for a demo

Then:

    Create a uv project and write a python script to add demo data. Use Faker.

    @Web research how many customers they have. Make the database to appropriate scale.

Only takes a few minutes in Cursor, should work just as well in Claude Code. It works really well for the companies core business, but I still need to create one to populate 3rd party sources (e.g. Stripe, Salesforce, Hubspot, etc.).

the score is easy to reverse engineer if you have the data and pretty much every big bank has the data.

source: I worked at a big bank and did this, it was easy.

Most of the stuff is obvious and intuitive (don't make late payments). One that's not terribly intuitive is credit line utilization. It has a big impact and most people don't think about it. For example, it's better to have 2k in credit card debt if you have 20k in credit lines vs. 1k in debt on 2k in credit lines.

this is the worst GCP outage I can remember

> It took up to ~2h 40 mins to fully resolve in us-central-1

this would have cost their customers tens of millions, maybe north of $100M.

not surprised they'd have an extreme write up like this.

> We've seen folks use Chonkie to chunk and embed AI chat threads

yep, that's what we're looking for. We'll give it a shot!

I think it's worth creating a guide for this use case. Seems like something many people would want to do and the input should be very similar across your users.

We (https://www.definite.app/) have a use case I'd imagine is common for people building agents.

When a user works with our agent, they may end up with a large conversation thread (e.g. 200k+ tokens) with many SQL snippets, query results and database metadata (e.g. table and column info).

For example, if they ask "show me any companies that were heavily engaged at one point, but I haven't talked to in the last 90 days". This will pull in their schema (e.g. Hubspot), run a bunch of SQL, show them results, etc.

I want to allow the agent to search previous threads for answers so they don't need to have the conversation again, but chunking up the existing thread is non-trivial (e.g. you don't want to separate the question and answer, you may want to remove errors while retaining the correction, etc.).

Do you have any plans to support "auto chunking" for AI message[0] threads?

0 - e.g. https://platform.openai.com/docs/api-reference/messages/crea...

* a small, focused team moves faster

* cursor has great taste and that's hard to replicate at MS scale

* Microsoft had allegiance to OpenAI early on which reduced their experimentation with other models

you're worried about ad targeting?

They show a Devin style slack app[0] in the video but there's not mention of it anywhere else. Does anyone have it installed?

0 - https://x.com/thisritchie/status/1930598413587959827

very cool you built something for yourself, but just a heads up, cursor is adding notebook support next week (one of the founders posted it earlier this week on twitter).

I don't want to sound like the infamous dropbox comment, but isn't Reducto just an LLM function call?

This was trickier 18 months ago, but every major LLM provider has solid support for this now. You can just drop an API call to Google, OpenAI, etc. your existing pipeline. What am I missing? Maybe the selling point was batch, but all LLM providers have a batch product now too.

    classification_response = requests.post(
        "https://platform.reducto.ai/extract",
        json={
            "document_url": f"jobid://{job_id}",
            "schema": {
                "type": "object",
                "properties": {
                    "document_type": {"type": "string", "enum": ["W2", "Passport", "Other"]}
                },
                "required": ["document_type"],
            },
        },
        headers=headers,
    )