Live data analyst
Drive a live AI analyst against real data.
Direct a Claude Code agent against a real BigQuery dataset to answer a business question. You decide what to chase, the agent runs the queries, and Hatch coaches every move until you land a finding that holds up.
How a session runs
One investigation, eight moves.
A real analyst loop from a cold dataset to a reproducible answer. Beginner sessions run a shorter version of the same path.
Connect the data tools
Spin up a sandbox, register the BigQuery tools, and start the agent. From there everything is plain language: you ask, it runs the queries.
See what data exists
List the tables, then read one table’s columns and grain before writing any analysis. Good analysis starts by looking, not guessing.
Understand the layout
Check the row count and partition column so queries stay fast and cheap on tables with millions of rows.
Find the overall drop
Measure step-by-step conversion and rank where the largest drop happens. Isolate the cause, do not restate the symptom.
Break it apart
Segment the worst step by a dimension like device or region. An aggregate hides the story; segmentation reveals it.
Land the answer
Write the finding: the cause, the number that proves it, a recommended change, and a guardrail metric. A finding without a number is an opinion.
Generate the report
Write the finding and the supporting queries to a report file. Capturing the queries makes the analysis reproducible.
Write a skill
Encode the analysis as a reusable skill so the next session starts smarter on any dataset. This is the move that compounds.
What it builds
Scored on the judgment, not the syntax.
Every session is graded across the moves a real analyst is measured on. You do not need to know SQL first, you direct the analysis in plain language.
Connection setup
Getting the tools and the session wired up so the agent can actually query the data.
Problem framing
Reading the schema and grain before querying, so the investigation is grounded.
Query rigor
Measuring the right thing and ranking the drop instead of restating the symptom.
Segmentation
Breaking an aggregate apart to find where the cause concentrates.
Communication
Stating the cause, the number that proves it, and a recommended change.
Evidence
Capturing the queries and numbers so the finding is reproducible.
Skill construction
Encoding the analysis as a reusable skill the next session inherits.
The proof
Walk away with an analyst scorecard.
Each finished session produces a graded report on live data: the finding, the queries that prove it, and a score across every analyst dimension. Keep it private or share it as proof of the work.
A finding backed by numbers
The cause, the metric that proves it, a recommended change, and the guardrail to watch.
Reproducible queries
The exact queries you ran, captured in a report file so anyone can retrace the analysis.
A shareable scorecard
A graded card across connection, framing, rigor, segmentation, communication, evidence, and skill.
Run your first investigation on real data.
No SQL required to start. Drive the agent, find the cause, and earn your first analyst scorecard.