Data & Analytics

Data Analysis as an Agent-Run Workflow

Opulent turns messy questions into sourced analysis, executable work, and reusable decision records, with an evidence trail and a business readout.

Skills

AuthorOpulent

CategoryData & Analytics

FeaturesSkills

start it with one message

Run a sourced analysis on [business question]. Pull data from Snowflake or Databricks, scope the question into testable sub-questions, run the analysis with named queries, and deliver a business readout with the evidence trail attached.

Run this in OpulentCopy it, swap the names for your own, and send it.

connected systems

SnowflakeQuery structured and unstructured data in Snowflake using natural language

DatabricksQuery lakehouse data and AI tools with Databricks

MetabaseAccess Metabase data analytics with caching and response optimization

AmplitudeAnalyze product data, experiments, and user behavior

step 1

Connect the warehouse and write the analysis playbook

Connect Snowflake or Databricks as the source of truth; add Metabase or Amplitude when the answer lives in a cached model or product events. Opulent queries the data directly, so the analysis is live and verifiable.

The judgment lives in a playbook, a reusable, named set of steps Opulent follows every run. It defines how to scope a messy question, what counts as evidence, and the format of the readout, so every analysis follows the same standard.

Playbook: !sourced-analysis

For any business question:
1. Intake: restate the question in plain terms and list the
   decisions it will inform.
2. Scope: break it into 2-4 testable sub-questions. Name the
   tables, metrics, and time window each one needs.
3. Query: run the SQL against Snowflake/Databricks; save every
   query to the evidence trail with a human-readable label.
4. Validate: check for nulls, duplicates, and off-by-one date
   windows before interpreting.
5. Readout: answer each sub-question, cite the query that backs
   it, and state the confidence level (high/medium/low).
6. Package: produce a decision record, summary, evidence links,
   and recommended next action.

Tip

Start each playbook with a 'definition of done' clause, like 'the readout is done when a non-technical reviewer can trace every claim to a labeled query.' That prevents analysis that is interesting but not actionable.

step 2

Start the run from a single message

Send the initial prompt with the business question filled in. Opulent runs the intake-to-readout loop and returns a decision record, not just a chart.

For recurring questions (weekly growth, churn cohorts, funnel health) schedule the playbook to run automatically and post the readout to a channel or email list.

The sharp edge: a question that is too broad ('tell me about users') produces a report that answers nothing. The playbook forces sub-questions before queries, so the run stays focused.

step 3

Watch a messy question become a decision record

Take the question: 'Why did signups drop two weeks ago?' Opulent scopes it into three sub-questions: did traffic drop, did conversion drop, or did a segment drop?

It runs labeled queries against Snowflake: traffic by channel, landing-page conversion, and signup-to-activation by plan tier. It finds that traffic was flat but the new pricing-page conversion fell from 12% to 7%.

The readout names the likely cause, attaches the query IDs, and recommends a follow-up experiment. The decision record lives in a shared doc or thread so the next reviewer starts with evidence, not a hunch.

Question: Why did signups drop two weeks ago?

Run actions:
- Scoped into traffic, conversion, and segment sub-questions.
- Ran query "traffic_by_channel_last_30d", traffic flat.
- Ran query "pricing_page_conversion", dropped from 12% to 7%.
- Ran query "activation_by_plan_tier", activation flat.
- Readout: pricing page is the dominant cause (high confidence).
- Recommendation: A/B the headline against the prior winner.

step 4

What exists when the run finishes

A real run produces a decision record you can audit, not a one-off answer: a scoped question list with the decisions each one informs; labeled SQL queries with timestamps and the warehouse they ran against; a business readout that cites evidence and states confidence; and a recommended next action with an owner and deadline.

The evidence trail is the proof-of-work: anyone can re-run the labeled queries and reach the same conclusion, which makes the readout safe to share with executives or customers.

step 5

Sharpen the analysis practice

When a recurring question needs the same footnote every time (a definition, a filter, a timezone) add it to memory (the notes a run recalls next time) so the next run starts with the right context.

Turn questions that repeat weekly into a dedicated skill with a schedule and a fixed readout format, so the team stops reinventing the analysis and starts debating the action.

The natural chain: when the analysis identifies a cohort or segment worth tracking, hand it to Reason Over Entire Datasets with Async Spawns for a deeper, full-dataset investigation.