snowpro-study

SnowPro Certification Study Skill — Router

This is the entry point for all SnowPro certification study activities. It handles certification discovery, user routing, and delegates to focused sub-skills for content generation.

Documentation Access Strategy

Before generating ANY content, determine the best documentation source available.

Step 1: Check for Snowflake Documentation Knowledge Extension

Run the following to detect if the connected Snowflake account has access to the Documentation Knowledge extension (either directly or through a Cortex Agent):

cortex search docs "Snowflake architecture overview"

If the command returns meaningful results (not an error or empty):

Use cortex search docs "<query>" as the PRIMARY documentation source for all content grounding
This is faster, more reliable, and avoids issues with dynamically rendered web pages
Supplement with web_fetch only when the search doesn't cover a specific topic

If the command fails or returns no results:

Prompt the user via ask_user_question to install the Cortex Knowledge Extension (CKE), which provides the best documentation grounding:

"The Snowflake Documentation Knowledge Extension isn't available on this connection. The CKE provides the most accurate and reliable documentation grounding for study content. Would you like to install it?"

Options:

Install on current connection — Install the CKE on the active Snowflake connection
Install on a different connection — Let the user pick another existing connection to install on
Install on a new connection — Guide the user through setting up a new connection and installing
Skip — use web fetch instead — Fall back to web_fetch against docs.snowflake.com (less reliable, slower)

If the user chooses to install (options 1-3):

Guide them through CKE installation on the selected connection
After installation, re-run cortex search docs "Snowflake architecture overview" to confirm it works
Proceed with cortex search docs as the primary documentation source

If the user declines (option 4):

Fall back to web_fetch against https://docs.snowflake.com/en/... URLs
Note in output: "Documentation sourced via web fetch (Knowledge extension not available)"

If web fetch also fails:

Mark all factual claims with [VERIFY]
Warn the user that content could not be grounded in live documentation

Step 2: Check for Cortex Agents with Documentation Access

cortex agents discover

If a Cortex Agent is available that has documentation tools configured, it can also be used as a grounding source. Prefer the Knowledge extension directly (cortex search docs) over an agent when both are available, as it's more targeted.

Important: Two Content Types, Distinct Fallback Sources

This skill uses two types of documentation. Both should attempt cortex search docs first, but their web fetch fallbacks differ:

Content Type	Primary Source	Web Fetch Fallback
Snowflake product docs (features, SQL syntax, architecture, behavior)	`cortex search docs` (CKE)	`https://docs.snowflake.com/en/...`
Exam information (certifications, exam guides, domains, weights, scheduling)	`cortex search docs` (CKE)	`https://learn.snowflake.com/en/certifications/...`

When cortex search docs does not return results for exam-specific queries (e.g., domain names, weights, question counts, prerequisites), fall back to web_fetch against learn.snowflake.com — NOT docs.snowflake.com.

Priority Order for Documentation Access

cortex search docs — Snowflake Documentation Knowledge extension (fastest, most reliable for both product docs and exam info)
Cortex Agent with documentation tools — if Knowledge extension is unavailable
Prompt user to install CKE (on current, different, or new connection)
web_fetch — only if user declines CKE installation:
- Product documentation → https://docs.snowflake.com/en/...
- Exam/certification information → https://learn.snowflake.com/en/certifications/...
LLM knowledge with [VERIFY] markers — last resort only

Anti-Hallucination Protocol

CRITICAL: This protocol applies to ALL content generated by this skill and its sub-skills.

Mandatory grounding: Before generating ANY study content, query documentation using the best available source (see Documentation Access Strategy above). Never generate technical content from memory alone.
Citation requirement: Every factual claim about Snowflake behavior (defaults, limits, syntax, feature availability) MUST be traceable to a documentation query or fetched page. Include the source (search query or URL) in the output.
Confidence flags: If a specific detail cannot be confirmed from documentation, mark it with [VERIFY] in the output so the user knows to double-check it.
No invention: Never invent function names, parameters, SQL syntax, or feature capabilities. If unsure whether something exists, query the docs or mark it [VERIFY].
Version awareness: Always note which documentation version/date was referenced. Snowflake features change frequently.
Separation of fact vs. interpretation: Clearly distinguish between "Snowflake documentation states X" and "based on this, the exam likely tests Y."

Dynamic Certification Discovery

Cache-First Strategy

Check for ~/.snowflake/cortex/skills/snowpro-study/cert_cache.json
If the cache exists and its fetched_at timestamp is less than 7 days old, use it
Otherwise, fetch the certification catalog and individual exam guides (see below)
If fetching fails, fall back to any existing cache (regardless of age) with a warning to the user

Discovery Process

Fetch https://learn.snowflake.com/en/certifications/ via web_fetch
Parse all certification entries: name, exam code, tier (Core/Specialty/Advanced), cost, and exam guide URL
For each certification, fetch its exam guide page to extract:
- Domain names and approximate weights
- Prerequisites
- Number of questions and time limit
- Any listed study resources
Save the complete parsed structure to cert_cache.json:

{
  "fetched_at": "2025-01-15T10:30:00Z",
  "certifications": [
    {
      "name": "SnowPro Core",
      "code": "COF-C03",
      "tier": "Core",
      "cost": "$175",
      "exam_guide_url": "https://learn.snowflake.com/en/certifications/snowpro-core/",
      "schedule_url": "https://learn.snowflake.com/en/certifications/",
      "question_count": 100,
      "time_minutes": 115,
      "passing_score": "750/1000",
      "prerequisites": [],
      "domains": [
        {
          "number": 1,
          "name": "Snowflake AI Data Cloud Features & Architecture",
          "weight": "20-25%",
          "topics": ["..."]
        }
      ]
    }
  ]
}

Handling Version Changes

If the fetched exam code differs from a previously cached version (e.g., GES-C01 → GES-C02):

Notify the user: "The exam has been updated from {old} to {new}. Generating content for the current version."
Update the cache
Regenerate any previously created study materials if asked

Invocation & Routing

Trigger Phrases

User Input	Routed To
`$snowpro-study`	Ask which cert + content type, then route
`$snowpro-study Gen AI`	Ask content type, then route
`$snowpro-study Gen AI Domain 3`	→ Sub-skill: snowpro-deepdive
`$snowpro-study Gen AI Domains 2-4`	→ Sub-skill: snowpro-deepdive
`$snowpro-study Core flashcards`	→ Sub-skill: snowpro-flashcards
`$snowpro-study Core flashcards Domain 1`	→ Sub-skill: snowpro-flashcards
`$snowpro-study Architect practice exam`	→ Sub-skill: snowpro-exam
`$snowpro-study Gen AI exam`	→ Sub-skill: snowpro-exam (interactive)
`$snowpro-study Gen AI progress`	→ Sub-skill: snowpro-exam (trend report)
`$snowpro-study Gen AI all`	Generate study plan here, then route to each sub-skill

Routing Logic

Run certification discovery (cache-first)
Identify which certification the user wants (match by name, abbreviation, or exam code)
If ambiguous, ask using ask_user_question with the discovered cert list as options
Identify what content type(s) to generate
If ambiguous, ask using ask_user_question:
- Study Plan (handled here)
- Domain Deep-Dive(s) → read and follow DEEPDIVE.md
- Flashcards → read and follow FLASHCARDS.md
- Practice Exam / Quiz → read and follow EXAM.md
Read the appropriate sub-skill file and follow its instructions
Show a confirmation plan (file names, scope, format) before generating

Content Generation: Study Plan

Study plans are generated directly by this router skill (they are lightweight and primarily structural).

Output File

SnowPro_{CertName}_Study_Plan.md in the current working directory (or user-specified path).

Structure

# SnowPro {Tier}: {Cert Name} ({Exam Code}) — Study Plan

**Exam Details:**
- Cost: {cost}
- Questions: {count} | Time: {minutes} minutes
- Passing Score: {score}
- Prerequisites: {list or "None"}
- Schedule your exam: {schedule_url}
- Official Exam Guide: {exam_guide_url}

---

## Exam Domain Breakdown

| # | Domain | Weight |
|---|--------|--------|
| 1 | {Domain Name} | {weight} |
| ... | ... | ... |

---

## Domain {N}: {Domain Name}

### Key Topics
- {topic 1}
- {topic 2}
- ...

### Study Resources
- [{Resource title}]({url})
- ...

---
...

## Additional Resources

- [Snowflake Documentation](https://docs.snowflake.com)
- [Snowflake Community](https://community.snowflake.com)
- [Snowflake Hands-On Labs](https://learn.snowflake.com)
- [Schedule an Exam](https://learn.snowflake.com/en/certifications/)
- [Certification FAQ](https://learn.snowflake.com/en/certifications/)
- [Exam Policies & Retake Rules](https://learn.snowflake.com/en/certifications/)

## How to Study

Use `$snowpro-study` for any of the following:
1. **Deep-dive on a domain** — `$snowpro-study {cert} Domain {N}`
2. **Flashcards** — `$snowpro-study {cert} flashcards`
3. **Practice exam** — `$snowpro-study {cert} practice exam`
4. **Interactive quiz** — `$snowpro-study {cert} exam`
5. **Score history** — `$snowpro-study {cert} progress`
6. **Full study package** — `$snowpro-study {cert} all`

"How to Study" Section — Expanded Template

The study plan's "How to Study" section must include ALL of the following content (replacing {cert} with the actual cert name):

## How to Study

### Available Commands

| Command | What It Does |
|---------|--------------|
| `$snowpro-study {cert} Domain 1` | Generate a deep-dive markdown file for a single domain |
| `$snowpro-study {cert} Domains 1-3` | Generate deep-dives for multiple domains at once |
| `$snowpro-study {cert} flashcards` | Generate flashcards for all domains (choose format when prompted) |
| `$snowpro-study {cert} flashcards Domain 2` | Generate flashcards for a specific domain only |
| `$snowpro-study {cert} practice exam` | Generate a full-length mock exam (written to file or interactive) |
| `$snowpro-study {cert} Domain 3 questions` | Generate practice questions for a single domain only |
| `$snowpro-study {cert} exam` | Take an interactive quiz in-session (choose mode when prompted) |
| `$snowpro-study {cert} Domain 4 quiz` | Interactive quiz for a single domain |
| `$snowpro-study {cert} progress` | View your score history and trend analysis |
| `$snowpro-study {cert} all` | Generate the full package: study plan + all deep-dives |

### Domain Deep-Dives

Deep-dives are detailed study guides for each domain, written to markdown files in your current directory. Each includes:
- Concept explanations grounded in Snowflake documentation
- Runnable SQL examples
- Comparison tables and decision frameworks
- Exam traps (common misconceptions that appear as distractors)
- Reference links to source documentation

Generate one at a time (`$snowpro-study {cert} Domain 1`) or a range (`$snowpro-study {cert} Domains 1-3`).

### Flashcards

When you request flashcards, you'll be asked to choose a format:

- **Markdown Q/A** — A `.md` file with question/answer pairs, readable in any text editor or markdown viewer. Good for on-screen review.
- **Anki CSV** — A tab-separated `.csv` file ready to import into Anki for spaced repetition study.
- **Both** — Generates both files side by side.

Each domain produces 15-25 cards targeting the facts most likely to differentiate correct from incorrect answers on the exam.

#### Importing the Anki CSV

The generated `.csv` file is tab-separated with three columns (front, back, tags) and can be imported directly into [Anki](https://apps.ankiweb.net/). Cards are tagged with a hierarchy like `snowpro::{cert}::domain1::{topic}`, allowing you to study by domain using filtered decks.

**Anki study tips:**
- Use Anki's default spaced repetition algorithm — don't cram all cards in one session
- Study new cards in domain order (Domain 1 first, since it's the foundation)
- Use the tag hierarchy to create filtered decks for weak domains identified in your score history
- Set a daily new card limit of 15-20 to avoid burnout
- Review cards daily, even for just 10 minutes — consistency beats volume

### Practice Exams

You have two options when requesting practice questions:

**Write to file** — Generates a markdown file with all questions followed by a separate answer key with detailed explanations. Good for simulating exam conditions (answer all questions, then check).

**Interactive (in-session)** — The skill administers the exam live. You'll choose one of three modes:
- **Instant feedback** — See if you're right/wrong immediately after each question, with full explanation
- **Results at end** — Answer all questions first, see results only after finishing (closest to real exam)
- **Batched** — Answer 5-10 questions at a time, get batch feedback, then continue

During interactive exams you can:
- Type your answer as A/B/C/D (or the full option text)
- Type `skip` to pass on a question
- Type `flag` to mark a question for review
- Type `score` to see your running tally
- Type `quit` to end early and see results for answered questions

### Score Tracking & Trends

After completing any practice exam (interactive or self-scored from a file), the skill offers to record your results to a persistent CSV file (`SnowPro_{CertName}_Score_History.csv`).

Once you have 2+ recorded attempts, the skill generates a trend report showing:
- Overall score progression across attempts
- Per-domain score trends (improving, plateau, or declining)
- Strengths and weaknesses analysis
- Readiness assessment with a suggested next action

View your history anytime with `$snowpro-study {cert} progress`.

### Recommended Study Workflow

1. **Read** the study resources linked in each domain section above
2. **Deep-dive** each domain in order: `$snowpro-study {cert} Domain 1`, then 2, etc.
3. **Generate flashcards** for each domain after completing its deep-dive
4. **Study flashcards daily** in Anki using spaced repetition
5. **Take domain quizzes** as you complete each domain to identify gaps
6. **Take a full mock exam** after covering all domains
7. **Review your trend report** to identify weak domains
8. **Re-study weak domains** using deep-dives and targeted flashcards
9. **Retake the mock exam** and compare scores until consistently above 80%
10. **Schedule the exam** when your trend report shows readiness

**Priority domains:** Identify the two highest-weighted domains and master these first — they typically account for over half the exam.

Content Sourcing for Study Plans

Use the topics extracted from the exam guide page (already in cache)
Fetch 1-2 relevant Snowflake documentation pages per domain via web_fetch to find accurate resource links
Prefer official docs over third-party sources

Output & Confirmation Workflow

Before generating ANY files (applies to all sub-skills):

Display a plan to the user:

I'll generate the following files in {current directory}:

| # | File | Content |
|---|------|---------|
| 1 | SnowPro_GenAI_Study_Plan.md | Study plan with all 7 domains |
| 2 | SnowPro_GenAI_Domain2_DeepDive.md | ~200 lines, Cortex AI Functions |

Proceed? (or specify a different output path)

Wait for confirmation
Generate and write files
Display summary with next-step suggestions

Error Handling

Scenario	Action
Cannot fetch certification catalog	Use cached data with age warning; if no cache exists, inform user and ask them to specify cert name manually
Cannot fetch exam guide for specific cert	Generate content from domain names only; note in output that topics may be incomplete
Cannot fetch documentation pages	Mark claims with `[VERIFY]`; note in output that links may need verification
User specifies a cert that doesn't exist	Show available certs from cache/discovery and ask them to choose
User specifies a domain number that doesn't exist	Show available domains for that cert and ask them to choose
Cache file is corrupted	Delete and re-fetch