best-practices-check
Verify skills-for-fabric against Microsoft Fabric best practices from the internet. Searches for current best practices, compares them against skill content, and identifies gaps or improvements. Use when the user wants to: (1) validate a skill covers industry best practices, (2) find missing guidance, (3) improve skill quality with current recommendations. Triggers: "check best practices", "validate best practices", "best practices for", "compare against best practices", "skill coverage".
Best use case
best-practices-check is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Verify skills-for-fabric against Microsoft Fabric best practices from the internet. Searches for current best practices, compares them against skill content, and identifies gaps or improvements. Use when the user wants to: (1) validate a skill covers industry best practices, (2) find missing guidance, (3) improve skill quality with current recommendations. Triggers: "check best practices", "validate best practices", "best practices for", "compare against best practices", "skill coverage".
Teams using best-practices-check should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/best-practices-check/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How best-practices-check Compares
| Feature / Agent | best-practices-check | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Verify skills-for-fabric against Microsoft Fabric best practices from the internet. Searches for current best practices, compares them against skill content, and identifies gaps or improvements. Use when the user wants to: (1) validate a skill covers industry best practices, (2) find missing guidance, (3) improve skill quality with current recommendations. Triggers: "check best practices", "validate best practices", "best practices for", "compare against best practices", "skill coverage".
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Best Practices Verification
Verify that skills in this repository align with current Microsoft Fabric best practices from official documentation and community sources.
## When to Use
- After creating or updating a skill
- To ensure a skill covers recommended patterns
- To identify gaps in guidance
- Before major releases to validate content currency
## Workflow
### Step 1: Identify Target Skill
Parse the user's request to identify which skill to verify:
| User Request | Target Skill |
|--------------|--------------|
| "check best practices for spark consumption" | `spark-consumption-cli` |
| "validate best practices for sqldw authoring" | `sqldw-authoring-cli` |
| "best practices for medallion" | `skills/e2e-medallion-architecture/SKILL.md` |
| "check best practices for SQL endpoint" | `sqldw-consumption-cli` |
**Skill name normalization:**
- "spark" → `spark-authoring-cli` or `spark-consumption-cli` (ask if ambiguous)
- "sqldw", "warehouse", "SQL endpoint" → `sqldw-authoring-cli` or `sqldw-consumption-cli`
- "medallion", "bronze/silver/gold" → `skills/e2e-medallion-architecture/SKILL.md`
- "data engineering" → `spark-authoring-cli`
### Step 2: Read Skill Content
Load the target skill's SKILL.md and any referenced resources:
```bash
# Example: Read skill content
cat skills/spark-consumption-cli/SKILL.md
# If skill has resources folder, read those too
ls skills/spark-consumption-cli/resources/ 2>/dev/null && \
cat skills/spark-consumption-cli/resources/*.md
```
Extract key topics covered:
- Must/Prefer/Avoid guidance
- Specific patterns mentioned
- Technologies referenced
- Example scenarios
### Step 3: Search for Current Best Practices
Use web search to find current Microsoft Fabric best practices. **Always include "Microsoft Fabric" in search queries** to ensure results are Fabric-specific.
**Search queries to execute** (adjust based on skill topic):
| Skill Type | Search Queries |
|------------|----------------|
| Spark/Data Engineering | "Microsoft Fabric Spark best practices 2025", "Fabric Lakehouse optimization", "Fabric notebook development best practices" |
| SQL Endpoint/Warehouse | "Microsoft Fabric Data Warehouse best practices", "Fabric T-SQL performance optimization", "Fabric SQL endpoint security best practices" |
| Medallion Architecture | "Microsoft Fabric medallion architecture best practices", "Fabric Bronze Silver Gold layer design", "Fabric lakehouse data modeling" |
| General | "Microsoft Fabric {topic} best practices", "Fabric {topic} performance tuning", "Fabric {topic} security" |
**Priority sources** (weight these higher):
1. `learn.microsoft.com/en-us/fabric/` — Official Microsoft documentation
2. `blog.fabric.microsoft.com/` — Official Fabric blog
3. `techcommunity.microsoft.com/` — Microsoft Tech Community
4. Recent conference talks (Ignite, Build) transcripts
5. Fabric CAT team blogs and whitepapers
### Step 4: Compare and Analyze
Create a comparison matrix:
```markdown
| Best Practice | Source | Covered in Skill? | Notes |
|---------------|--------|-------------------|-------|
| Use starter pools for Livy sessions | MS Docs | ✅ Yes | Session Management |
| Enable adaptive query execution | Tech Community | ⚠️ Partial | Mentioned but no config example |
| Avoid SELECT * on large tables | MS Docs | ✅ Yes | Avoid section |
| Use V-Order for read-heavy workloads | Fabric Blog | ❌ No | Gap - should add |
```
### Step 5: Generate Report
Produce a structured report:
```markdown
## Best Practices Verification Report
**Skill:** spark-consumption-cli
**Date:** {current_date}
**Sources Consulted:** {list_of_sources}
### Summary
| Category | Count |
|----------|-------|
| ✅ Covered | X |
| ⚠️ Partial | Y |
| ❌ Gap | Z |
### Fully Covered Best Practices
1. **{Practice Name}** — {brief description}
- Source: {URL}
- Skill location: {section reference}
### Partially Covered (Needs Enhancement)
1. **{Practice Name}** — {what's missing}
- Source: {URL}
- Current coverage: {what exists}
- Recommendation: {specific improvement}
### Gaps (Not Covered)
1. **{Practice Name}** — {description}
- Source: {URL}
- Why important: {impact}
- Suggested addition: {where to add and what content}
### Recommendations
1. {Priority 1 recommendation}
2. {Priority 2 recommendation}
3. {Priority 3 recommendation}
```
## Must
- **Always search with "Microsoft Fabric"** in query — generic Spark/SQL results may not apply
- **Cite sources** for every best practice identified
- **Read the actual skill content** before comparing — don't assume
- **Distinguish between authoring and consumption** — best practices differ
- **Check publication dates** — prefer content from 2024-2025; flag older sources
- **Focus on actionable gaps** — prioritize high-impact missing guidance
## Prefer
- Official Microsoft documentation over community posts
- Recent content (last 12 months) over older articles
- Fabric-specific guidance over generic Spark/SQL advice
- Concrete, implementable recommendations over vague suggestions
- Linking to common/ documents for foundational patterns
- Grouping related gaps into single recommendations
## Avoid
- Generic cloud data platform advice not specific to Fabric
- Outdated patterns (pre-GA Fabric guidance may be obsolete)
- Nitpicking minor omissions — focus on material gaps
- Recommending changes that duplicate content in common/ files
- Suggesting additions that would exceed skill token budget (15K warning threshold)
## Example Usage
### User Prompt
> "Check best practices for spark consumption"
### Expected Response
```markdown
## Best Practices Verification: spark-consumption-cli
**Sources consulted:**
- Microsoft Learn: Fabric Spark development best practices
- Fabric Blog: Optimizing Livy sessions
- Tech Community: Fabric Lakehouse query patterns
### Summary: 8 covered, 2 partial, 3 gaps
### ✅ Fully Covered
1. **Session reuse over creation** — Skill explicitly checks for idle sessions (Must section)
2. **Use starter pools** — Configured in session creation (Must section)
3. **Avoid large result sets without LIMIT** — In Avoid section
### ⚠️ Partial Coverage
1. **Adaptive query execution** — Mentioned in config but no explanation of when to enable/disable
- Recommendation: Add brief guidance on AQE tuning for different workload types
### ❌ Gaps
1. **Caching strategies for repeated queries**
- Source: [MS Learn - Spark caching](https://learn.microsoft.com/...)
- Recommendation: Add section on `.cache()` and `.persist()` for iterative analysis
2. **Cross-workspace query patterns**
- Source: [Fabric Blog - Multi-workspace analytics](https://blog.fabric.microsoft.com/...)
- Recommendation: Add example of querying across workspaces with proper shortcuts
### Priority Recommendations
1. Add caching guidance to Prefer / Data Exploration section
2. Expand AQE documentation with workload-specific configs
3. Add cross-workspace query example
```
## Integration with Quality Check
Run this skill **after** the `quality-check` skill:
1. `quality-check` validates structure and compliance
2. `best-practices-check` validates content quality and completeness
Together they ensure skills are both well-formed and comprehensive.
## Limitations
- Web search results may vary; re-run periodically
- Some best practices are context-dependent — use judgment
- New Fabric features may not have documented best practices yet
- Enterprise-specific guidance (security, compliance) may require internal sourcesRelated Skills
check-updates
Check for skills-for-fabric marketplace updates at session start. Compares local version against GitHub releases and shows changelog if updates are available. Use when the user wants to: (1) check for skill updates, (2) see what's new in skills-for-fabric, (3) verify current version. Triggers: "check for updates", "am I up to date", "what version", "update skills", "show changelog".
quality-check
Run local quality checks on skills-for-fabric before committing. Validates all skills in the skills/ folder for structural compliance, semantic disambiguation, broken references, and content quality. Use before submitting a PR to catch issues early. Triggers: "check my skills", "run quality check", "validate skills", "pre-commit check", "lint skills".
sqldw-consumption-cli
Execute read-only T-SQL queries against Fabric Data Warehouse, Lakehouse SQL Endpoints, and Mirrored Databases via CLI. Default skill for any lakehouse data query (row counts, SELECT, filtering, aggregation) unless the user explicitly requests PySpark or Spark DataFrames. Use when the user wants to: (1) query warehouse/lakehouse data, (2) count rows or explore lakehouse tables, (3) discover schemas/columns, (4) generate T-SQL scripts, (5) monitor SQL performance, (6) export results to CSV/JSON. Triggers: "warehouse", "SQL query", "T-SQL", "query warehouse", "show warehouse tables", "show lakehouse tables", "query lakehouse", "lakehouse table", "how many rows", "count rows", "SQL endpoint", "describe warehouse schema", "generate T-SQL script", "warehouse performance", "export SQL data", "connect to warehouse", "lakehouse data", "explore lakehouse".
sqldw-authoring-cli
Execute authoring T-SQL (DDL, DML, data ingestion, transactions, schema changes) against Microsoft Fabric Data Warehouse and SQL endpoints from agentic CLI environments. Use when the user wants to: (1) create/alter/drop tables from terminal, (2) insert/update/delete/merge data via CLI, (3) run COPY INTO or OPENROWSET ingestion, (4) manage transactions or stored procedures, (5) perform schema evolution, (6) use time travel or snapshots, (7) generate ETL/ELT shell scripts, (8) create views/functions/procedures on Lakehouse SQLEP. Triggers: "create table in warehouse", "insert data via T-SQL", "load from ADLS", "COPY INTO", "run ETL with T-SQL", "alter warehouse table", "upsert with T-SQL", "merge into warehouse", "create T-SQL procedure", "warehouse time travel", "recover deleted warehouse data", "create warehouse schema", "deploy warehouse", "transaction conflict", "snapshot isolation error".
spark-consumption-cli
Analyze lakehouse data interactively using Fabric Livy sessions and PySpark/Spark SQL for advanced analytics, DataFrames, cross-lakehouse joins, Delta time-travel, and unstructured/JSON data. Use when the user explicitly asks for PySpark, Spark DataFrames, Livy sessions, or Python-based analysis — NOT for simple SQL queries. Triggers: "PySpark", "Spark SQL", "analyze with PySpark", "Spark DataFrame", "Livy session", "lakehouse with Python", "PySpark analysis", "PySpark data quality", "Delta time-travel with Spark".
spark-authoring-cli
Develop Microsoft Fabric Spark/data engineering workflows with intelligent routing to specialized resources. Provides core workspace/lakehouse management and routes to: data engineering patterns, development workflow, or infrastructure orchestration. Use when the user wants to: (1) manage Fabric workspaces and resources, (2) develop notebooks and PySpark applications, (3) design data pipelines and orchestration, (4) provision infrastructure as code. Triggers: "develop notebook", "data engineering", "workspace setup", "pipeline design", "infrastructure provisioning", "Delta Lake patterns", "Spark development", "lakehouse configuration", "organize lakehouse tables", "create Livy session", "notebook deployment".
powerbi-consumption-cli
The ONLY supported path for read-only Microsoft Fabric Power BI semantic model (formerly "Power BI dataset") query interactions. Execute DAX queries via the MCP server ExecuteQuery tool to: (1) discover semantic model metadata (tables, columns, measures, relationships, hierarchies, etc.) and their properties, (2) retrieve data from a semantic model. Triggers: "DAX query", "semantic model metadata", "list semantic model tables", "run EVALUATE", "get measure expression".
powerbi-authoring-cli
Create, manage, and deploy Power BI semantic models inside Microsoft Fabric workspaces via `az rest` CLI against Fabric and Power BI REST APIs. Use when the user wants to: (1) create a semantic model from TMDL definition files, (2) retrieve or download semantic model definitions, (3) update a semantic model definition with modified TMDL, (4) trigger or manage dataset refresh operations, (5) configure data sources, parameters, or permissions, (6) deploy semantic models between pipeline stages. Covers Fabric Items API (CRUD) and Power BI Datasets API (refresh, data sources, permissions). For read-only DAX queries, use `powerbi-consumption-cli`. For fine-grained modeling changes, route to `powerbi-modeling-mcp`. Triggers: "create semantic model", "upload TMDL", "download semantic model TMDL", "refresh dataset", "semantic model deployment pipeline", "dataset permissions", "list dataset users", "semantic model authoring".
eventhouse-consumption-cli
Run KQL queries against Fabric Eventhouse for real-time intelligence and time-series analytics using `az rest` against the Kusto REST API. Covers KQL operators (where, summarize, join, render), Eventhouse schema discovery (.show tables), time-series patterns with bin(), and ingestion monitoring. Use when the user wants to: 1. Run read-only KQL queries against an Eventhouse or KQL Database 2. Discover Eventhouse table schema and metadata 3. Analyse real-time or time-series data with KQL operators 4. Monitor ingestion health and active KQL queries 5. Export KQL results to JSON Triggers: "kql query", "kusto query", "eventhouse query", "kql database", "real-time intelligence", "time-series kql", "query eventhouse", "explore eventhouse", "show tables kql"
eventhouse-authoring-cli
Execute KQL management commands (table management, ingestion, policies, functions, materialized views) against Fabric Eventhouse and KQL Databases via CLI. Use when the user wants to: 1. Create or alter KQL tables, columns, or functions 2. Ingest data into an Eventhouse (inline, from storage, streaming) 3. Configure retention, caching, or partitioning policies 4. Create or manage materialized views and update policies 5. Manage data mappings for ingestion pipelines 6. Deploy KQL schema via scripts Triggers: "create kql table", "kql ingestion", "ingest into eventhouse", "kql function", "materialized view", "kql retention policy", "eventhouse schema", "kql authoring", "create eventhouse table", "kql mapping"
e2e-medallion-architecture
Implement end-to-end Medallion Architecture (Bronze/Silver/Gold) lakehouse patterns in Microsoft Fabric using PySpark, Delta Lake, and Fabric Pipelines. Use when the user wants to: (1) design a Bronze/Silver/Gold data lakehouse, (2) set up multi-layer workspace with lakehouses for each tier, (3) build ingestion-to-analytics pipelines with data quality enforcement, (4) optimize Spark configurations per medallion layer, (5) orchestrate Bronze-to-Silver-to-Gold flows via notebooks. Triggers: "medallion architecture", "bronze silver gold", "lakehouse layers", "e2e data pipeline", "end-to-end lakehouse", "data lakehouse pattern", "multi-layer lakehouse", "build medallion", "setup medallion".
skill-test
Manage the skills-for-fabric evaluation framework: add eval plans for new or existing skills, list available tests and their results, generate eval datasets, review metrics, and check test coverage. Directs test execution to the tests/ folder. Triggers: "add tests", "add evals", "list tests", "show eval results", "run tests", "generate eval data", "eval metrics", "test coverage", "missing tests". "show tests"