# Snowpro Study > Generate SnowPro certification study materials including study plans, domain deep-dives, flashcards, and practice exam questions for any SnowPro exam. Dynamically discovers current certifications and exam versions from Snowflake. Use when asked to study, prep for, or generate content for SnowPro certifications. - Skill: `snowflake-labs/snowpro-study` (Agent Skill, multi-file: 5 files) - Install (CLI): `npx skillmds@latest add snowflake-labs/snowpro-study` - Raw SKILL.md: https://api.skillmd.com/api/skills/snowflake-labs/snowpro-study/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: snowflake-labs (https://skillmd.com/u/snowflake-labs) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/snowflake-labs/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): ```bash cortex search docs "Snowflake architecture overview" ``` **If the command returns meaningful results** (not an error or empty): - Use `cortex search docs ""` 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: 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 ```bash 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 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/...` 5. 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 4. Save the complete parsed structure to `cert_cache.json`: ```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 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 `ask_user_question` with the discovered cert list as options 4. Identify what content type(s) to generate 5. 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` 6. Read the appropriate sub-skill file and follow its instructions 7. 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 ```markdown # 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): ```markdown ## 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}: | # | 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) ``` 2. Wait for confirmation 3. Generate and write files 4. 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 |