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 askuserquestion 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:

1. Install on current connection — Install the CKE on the active Snowflake connection
2. Install on a different connection — Let the user pick another existing connection to install on
3. Install on a new connection — Guide the user through setting up a new connection and installing
4. 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:

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

1. cortex search docs — Snowflake Documentation Knowledge extension (fastest, most reliable for both product docs and exam info)
2. Cortex Agent with documentation tools — if Knowledge extension is unavailable
3. Prompt user to install CKE (on current, different, or new connection)
4. web_fetch — only if user declines CKE installation:

- Product documentation → https://docs.snowflake.com/en/... - Exam/certification information → https://learn.snowflake.com/en/certifications/...

1. 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.

1. 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.
2. 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.
3. 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.
4. No invention: Never invent function names, parameters, SQL syntax, or feature capabilities. If unsure whether something exists, query the docs or mark it [VERIFY].
5. Version awareness: Always note which documentation version/date was referenced. Snowflake features change frequently.
6. 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

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

Discovery Process

1. Fetch https://learn.snowflake.com/en/certifications/ via web_fetch
2. Parse all certification entries: name, exam code, tier (Core/Specialty/Advanced), cost, and exam guide URL
3. 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

1. 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

Routing Logic

1. Run certification discovery (cache-first)
2. Identify which certification the user wants (match by name, abbreviation, or exam code)
3. If ambiguous, ask using askuserquestion with the discovered cert list as options
4. Identify what content type(s) to generate
5. If ambiguous, ask using askuserquestion:

- 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

1. Read the appropriate sub-skill file and follow its instructions
2. 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

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

Output & Confirmation Workflow

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

1. Display a plan to the user:

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

Proceed? (or specify a different output path) ```

1. Wait for confirmation
2. Generate and write files
3. Display summary with next-step suggestions

Error Handling