self-serve-analysis

name	self-serve-analysis
description	Adds the analyst layer (segmentation framing, filter/KPI surfacing, LTX-specific definitions, contextual follow-ups) on top of any Data MasterMind data interaction for LTX stakeholders (PMs, marketers, design, leadership). Wraps `get-data` / `validate-data` / `understand-data` / `visualize-data` — dialing intensity from a full guided session (for "look into X", "investigate Y", "do an analysis of …") down to a compressed wrap (for "what's MRR?", "is this number right?"). Output mode (chat-only or HTML artifact) is chosen up front for session-style asks. Always asks about Enterprise / paid non-Enterprise / Free segmentation and Studio-feature tier-gating when relevant. Do NOT use only when the user explicitly opts out ("just give me the number, no extras") or for templated feature dashboards (that's the Hex-based `dashboard-builder`).
tags	["analysis","stakeholder","mastermind","self-serve"]

Self-Serve Analysis

A session-oriented skill that frames an LTX analysis the way a human analyst would: clarify the question, fix the segmentation, route each step through Data MasterMind, surface what the agent actually computed, and propose follow-ups. The competitive advantage over a vanilla MasterMind session is the LTX context layer (segmentation logic, canonical metrics, event registry) layered onto MasterMind's governed BI access.

When to Use

This skill is a wrapper on top of MasterMind's workflows — it adds the analyst mindset (segmentation framing, filter/KPI surfacing, contextual follow-ups, LTX-specific definitions) to whatever MasterMind would otherwise do.

Use it whenever an LTX stakeholder is asking about data — regardless of the size of the ask:

• Stakeholder-voice analysis prompts ("look into X", "investigate Y", "what's happening with Z", "do an analysis of …", "help me understand …") — full session with all phases.
• One-shot data pulls ("what's MRR this month?", "how many active users yesterday?") — compressed session: still apply the segmentation question if relevant, still surface what MasterMind actually filtered on, still offer 1–2 follow-ups before exiting. The analyst layer is light but present.
• Validating an existing number ("the dashboard shows X, is that right?") — wrap validate-data with the same segmentation/filter surfacing, then propose follow-ups if the validation reveals something interesting.
• KPI definition questions ("what is PQL?") — wrap understand-data, then offer "want me to pull the actual numbers for this?" as a natural follow-up.

The skill should dial its own intensity to the prompt: a chatty "look into …" gets the full Phase 0–3 arc; a terse "what's MRR?" gets a compressed version that skips topic-framing but still surfaces filter choices and offers segmentation + follow-ups.

When NOT to Use

• Building a templated feature dashboard with the full Usage/Funnel/Retention/Segmentation grid → that's dashboard-builder (Hex-based, in agents/dashboard-builder/SKILL.md).
• The user explicitly says "just give me the number, no extras" → drop straight to MasterMind's get-data and respect the request. The analyst layer is opt-out, not mandatory.

Workflow

The skill is four short phases. Each phase is a conversation move, not a multi-step protocol. Stay in business language at all times.

Intensity dial. Before starting, judge whether the prompt is exploratory ("look into …", "investigate …", "help me understand …") or terse ("what's MRR?", "is this number right?"). For exploratory prompts run the full Phase 0–3 arc. For terse prompts compress: skip the multi-angle framing in Phase 0 (the question is already concrete), but always keep (a) the segmentation question if data would differ across segments, (b) the post-answer filter/KPI surfacing in Phase 1, and (c) 1–2 contextual follow-ups in Phase 2. The analyst layer should feel like a helpful colleague reviewing the result with you, not a process gate.

Phase 0 — Frame, segment, mode (STOP gate)

Six things up front, then stop and wait for the user.

1. Frame the topic. Restate the user's topic in plain language and name what they're likely trying to learn. If the topic involves a Studio product, feature, or model, read shared/product-context.md (and shared/product-features.md if it adds context) so the framing is product-accurate. Offer 2–3 angles the user might mean (adoption / who's using it / trend / etc.) and let them pick.

2. Detect the methodology. The audience is non-analysts — they often don't know what a rigorous answer looks like. Match the question shape to one of four pre-built templates and read the matching file:

Question shape	Methodology file
New feature ("how is the new X doing", recent launch, "since we shipped Y")	methodologies/new-feature.md
A/B test (names a test/variant/treatment, "did the test work")	methodologies/ab-test.md
Health check on an established feature ("how is X doing", "is X getting worse")	methodologies/health-check.md
Anomaly ("why did X drop", "something looks wrong with Y")	methodologies/anomaly.md

If a template matches, tell the user in plain language what shape you're using and confirm:

"This looks like a new-feature analysis — I'll structure it as pre-launch baseline + first-30-days post launch, plus a comparison to a similar feature if you want one. Sound right, or different approach?"

The user can override (e.g. "actually treat this as an A/B test", or "skip the template, just answer the question"). If no template clearly matches, run without one — but say so: "I don't have a pre-built methodology for this shape; I'll answer the question directly and flag if it gets into territory where an analyst would help."

For terse / compressed-mode prompts ("what's MRR?"), skip this step — templates are for interpretation-shaped questions, not one-shot pulls.

3. Always ask about segmentation. Data looks dramatically different across LTX segments. Ask explicitly:

"Should we look at this across all users, or focus on a segment — Enterprise, paid non-Enterprise, Free, or a specific tier (e.g. Standard / Pro)?"

Default if user says "all users": present the result broken down by the three big segments (Enterprise / paid non-Enterprise / Free) — never collapsed to a single line. The segmentation logic comes from shared/bq-schema.md (Enterprise / Heavy / Paid / Free CTEs around lines 441–516).

4. Tier-relevance gate (Studio feature/model only). If the topic is a specific Studio feature or model, ask:

"Is this feature available for all tiers, or is it gated (Pro-only, Enterprise-only, etc.)?"

Tier-gated features need their denominator restricted to eligible users — otherwise adoption looks artificially low. The answer here directly shapes how the first data call is framed.

5. LTX Model impact gate (Studio question only). Studio activity drives LTX Model usage — every generation consumes tokens, and video generations especially are tied to LTX Model business outcomes. For any Studio-related question, ask:

"Should we also look at how this affects LTX Model usage — for example, tokens consumed through video generations, or across all generations (image, video, etc.)?"

Three plausible answers, all valid:

• No, just the feature itself → keep the analysis scoped to the Studio metric.
• Yes, video generations → add a parallel view of video-generation tokens tied to the same users/window.
• Yes, all generations → add a view of total tokens (image + video + etc.) tied to the same users/window.

If yes, this becomes a second concrete question in Phase 1 (or a parallel section in artifact mode).

6. Output mode. Ask once:

"Do you want answers in chat as we go, or should I build an HTML analysis doc you can save and share?"

Default chat-only. If artifact: confirm save path (default ~/{topic-slug}-analysis.html).

STOP here. Do not call any data tool until the user has answered (1)–(6). Probes against MasterMind showed the BI agent silently maps "Image Editor" to a page-based filter and collapses results to a single tier without warning — Phase 0 is what prevents the stakeholder from acting on a number that means something different than they thought.

Phase 1 — First question

1. Translate the stakeholder's initial curiosity into one concrete question, applying Phase-0 segmentation and tier-eligibility filters.
   • For metric formulas, lean on shared/metric-standards.md so "DAU", "retention", "funnel conversion" mean what the analytics team means — not whatever MasterMind's nearest-neighbor KPI happens to be.
   • For event-level questions, lean on shared/event-registry.yaml to name the right action_name / action_name_detailed.
2. Present the concrete question back to the user in business language. Confirm before proceeding.
3. Route to the appropriate MasterMind workflow:
   • Numbers / metrics → get-data (load /skills/get-data/SKILL.md via the MasterMind get_docs tool, follow its full workflow including the dispatch and S&V gate)
   • Definitions / lineage → understand-data
   • Verifying a value → validate-data
   • Wants a chart → visualize-data (it will orchestrate get-data itself if data isn't in context)
4. When the answer comes back, always surface what MasterMind actually computed:
   • Translate the response's "Filters applied on data :" and "Parameters used in data :" header lines plus the sage_query / tml_tokens into business language.
   • If the agent picked a filter that doesn't match the user's mental model (especially Page Name = … for features that have a dedicated event), cross-reference shared/event-registry.yaml and offer the canonical event-level filter as an alternative. Let the user pick.
   • If the filter header contains Select a Measure or any other unresolved parameter, the data CSV body will be empty — treat this as a parameter-miss, not a zero result. Ask the user to pin the parameter (e.g. "D1, D7, or D30?") and re-query.
   • If MasterMind's KPI definition differs from shared/metric-standards.md, show both and let the user choose. Never silently override.
5. Carry forward MasterMind's confidence label (HIGH / MEDIUM / LOW) into the answer to the user — translated, see Business language gate below.

Phase 2 — Guided follow-ups

After each answer, propose 2–3 follow-ups that are specific to this result, not generic. Heuristics:

• If the metric was segmented one way, offer the next natural cut. ("You saw it by tier — want to see it by platform, or compare Enterprise vs Free?")
• If the time window was the default (30d, 90d), offer a relevant alternative tied to the topic. ("Want to compare against the 30 days before the feature launched?")
• If the number was surprising (extremely small, exactly zero, suspiciously round), offer a sanity-check via validate-data or a re-query with a different filter.
• If a segment looked anomalous, drill into it. ("Enterprise dropped off sharply in week 3 — want to see which orgs?")
• If artifact mode is on, offer "add this section to the analysis doc" alongside the follow-ups.
• If any escalation trigger has fired (see "Escalate to analyst" below), include "ask an analyst to take a look" as one of the 2–3 follow-ups — alongside the data follow-ups, not instead of them. Let the user choose.

Follow-ups are suggestions — the user can also ask their own next question. Continue the session until the user says they're done.

Phase 3 — Wrap

Chat-only mode: Summarize each question and answer with its source model + (translated) confidence label. Suggest a next step if obvious.

Artifact mode: Write the HTML file to the path confirmed in Phase 0. Each section = one Phase-1/2 question with:

• Chart rendered by visualize-data (it will pick the chart type and surface-appropriate format)
• Business-language methodology note: what was measured, which segment, which filter, which time window
• Translated confidence label
• Which-segment-was-used note (always explicit)

Footer: list every MasterMind model touched (by business name, not GUID), timestamp, and the topic slug. Keep a collapsible "technical provenance" section for sage queries / SQL — but business language stays in the main body.

Write incrementally. After each Phase-1/2 question is answered in artifact mode, append its section to the HTML file before asking the next question. This way a mid-session auth failure doesn't lose prior work.

LTX context layer (read on demand)

These files are referenced — not pre-loaded. Read each only when the current phase needs its content:

Shared file	Read when
shared/product-context.md	Phase 0 framing, if the topic involves an LTX product/feature
shared/product-features.md	Phase 0 framing, if the topic is a specific feature and product-context.md alone is insufficient
shared/metric-standards.md	Phase 1, when translating curiosity to a concrete metric
shared/bq-schema.md (segmentation CTEs, ~lines 441-516)	Phase 0 segmentation choice + any tier-segmented question
shared/event-registry.yaml	Whenever MasterMind's auto-filter picks the wrong dimension and you need the canonical action_name for a feature

Override priority. If a canonical LTX definition (from shared/) differs from what MasterMind's KPI gives, show both and let the user choose. Never silently override either side. The point is to surface the gap, not paper over it.

MasterMind compliance

• Workflow-first. Every data interaction routes through a MasterMind workflow skill (get-data / understand-data / validate-data / visualize-data). This skill never calls ask_data, run_sql, or search_models directly.
• Confidence labels carried forward on every answer — but translate them: HIGH = "this comes from our governed metrics catalog", MEDIUM = "I'm computing this directly, with sanity checks", LOW = "I'm computing this directly, treat as a rough estimate". Never write "HIGH/MEDIUM/LOW" as bare labels at stakeholders.

Business language gate (CRITICAL)

The audience is PMs, designers, marketers, and leadership. They don't know what a CTE is, don't know which BigQuery table holds what, don't care whether MasterMind ran ask_data or run_sql, and have never heard of "V3 base tables". Any technical jargon leaking into the chat surface breaks trust and makes them tune out.

Before sending any chat message, scan it for the following and rewrite:

Don't write	Write instead
"canonical segmentation CTEs", "the CTE for Enterprise"	"the standard way we slice users by tier"
"page_workspace_name", "action_name = …", any raw column or event name	"by workspace name", "based on which feature was used"
"V3 events", "V3 base tables", "the mart", "the dbt model"	Just describe the data: "user actions since April", "our usage data". Drop the schema-version detail unless directly asked.
"I'll let MasterMind decide whether this is an ask_data or a run_sql job"	(delete entirely — internal routing is not the user's problem)
"Routing through get-data now"	"Pulling the numbers now" or just stay silent and produce the result
"model_guid", "session_identifier", "sage_query", "tml_tokens"	(never surface — these live only in the HTML artifact's collapsible technical footer)
"HIGH confidence" / "MEDIUM confidence" as bare labels	"from our governed metrics" / "computed directly with sanity checks"
"Path A" / "Path B"	(delete — internal routing)
"ThoughtSpot", "Spotter", "BigQuery", "ltxstudio_user_all_actions"	"our analytics data" / "our usage data" — name the concept the data represents, not the system
"lt_id", "anonymous_id", "is_lt_team"	"users", "people on the team"

Two further rules:

1. Never list four+ technical concepts in one sentence. If you find yourself writing "Genspace/Storyboard via page_workspace_name, Flows via V3 node events since 2026-04-23, Canvas via canvas-specific events" — stop and rewrite as one plain sentence: "Each workspace is detected slightly differently in the data, but I'll handle that — you don't need to worry about it."
2. When in doubt, hide the mechanism. The stakeholder cares about the answer and what filter was used to get it. They do not care which tool ran or which table was read. If a technical detail isn't load-bearing for their decision, omit it.

This gate applies to the chat surface only. The HTML artifact's collapsible "technical provenance" section is the right place for model_guid, sage_query, SQL, etc.

Escalate to analyst

The audience is non-analysts. This skill is good at the structured, well-shaped 80% of questions — but some questions need a human analyst, and pretending otherwise produces polished answers that are quietly wrong. Recommend escalation when any of the following fires.

Trigger signals:

1. Causal questions. "Did X cause Y?", "what's driving this?", "if we did Z, would it work?". Causal inference needs methodology this skill doesn't have. Surface the correlations the data shows, then recommend escalation for the causal claim.
2. Methodology forks with material impact. Two valid baseline/window/segmentation choices that would lead to different conclusions. Lay out the fork in plain language and recommend escalation rather than picking one.
3. Anomaly investigations beyond the first cut. The dedicated anomaly methodology localizes the issue; multi-step root cause work (chasing it across joins, time, behavior) is analyst territory.
4. Data caveats meeting a high-stakes decision. If the answer would change a real business call (rollback, pricing change, headcount, roadmap) AND the underlying data has known limits (short window, small N, partial instrumentation, recent KPI definition change), escalate. The skill says "the data suggests X, but for a decision of this size I'd loop in an analyst."
5. Cross-source joins not in the catalog. Question requires combining things MasterMind can't combine on its own (e.g. product usage × a Salesforce custom field × marketing campaign metadata).
6. Loop / pushback signal. User rejects the result twice, or rephrases the same question three different ways. Something deeper is going on — pause and recommend a human pair of eyes.
7. Forecasting / projection. "Where will this be in 6 months?" Projection involves assumption-building this skill should not improvise.

How to phrase the escalation:

"This is getting into territory where an analyst would catch nuance I'll miss — {one-line reason from the trigger above}. Want me to keep going with what I can give you, or pause here so you can loop in the analytics team?"

Phrasing rules:

• Never say "I can't help" — the skill keeps offering data. Escalation is additional, not instead of.
• Always include the specific reason, not "this is complicated". The reason helps the analyst know what to pick up.
• Do not name a specific person or channel — the user knows who to reach.
• After escalating, summarize what's already in the session (questions asked, answers found, what's unresolved) so the user has something concrete to hand off.

This section's job is to keep the skill honest about its own limits. False rigor is worse than no rigor.

Auth resilience

• On any requires re-authorization / 401 / UNAUTHENTICATED signal from a MasterMind tool, immediately route to MasterMind's recovering-mcp-connection skill (load via get_docs("/skills/recovering-mcp-connection/SKILL.md")). Do not retry. Do not paste sign-in URLs into chat.
• In artifact mode, append each completed section to the HTML file before asking the next question.

What this skill explicitly does NOT do

• No metric-set prescription. A stakeholder analysis answers the questions the stakeholder asks; it isn't a templated Usage/Funnel/Retention/Segmentation grid.
• No SQL writing by Claude. Path A (ask_data) is the default. If a question genuinely needs Path B (run_sql), that's get-data's decision.
• No Hex / dashboard-builder cross-references. Standalone.

Triggers and routing

When a user message arrives that matches the description's trigger phrases ("look into X", "investigate", "what's happening with", "help me understand", "do an analysis of"), activate this skill and start Phase 0. If the user later says "actually, just give me the number" mid-session, drop the session framing and route directly to MasterMind's get-data.

If at any point intent becomes ambiguous (e.g. user pivots to a definition question), route to MasterMind's discover-user-intent.

Setup prerequisite

This skill requires the Data MasterMind plugin (and its MCP connection). See the MasterMind setup guide for installation and Google SSO. Without MasterMind connected, the skill cannot run — it falls back to telling the user to install/connect MasterMind first.