Wardn HubTrusted MCP server directory.

Registry

  • MCP Servers
  • Skills
  • Categories

Resources

  • API docs
  • Score method

Contribute

  • Submit server
  • Advertise
© 2026 Wardn Hub
Wardn Hub
MCP ServersSkillsCategoriesAPI docsSubmit server
Submit server
skills/mohitagw15856/pm-claude-skills/dbt-model-spec

dbt-model-spec

1
mohitagw15856/pm-claude-skills·Audit passed·Snapshot 023eda719335

Summary

This source did not publish a separate summary. Review SKILL.md before using the skill.

SKILL.md

dbt Model Spec Skill

A dbt model is only trustworthy if its grain is unambiguous, its sources are declared, and it's tested. This skill specs a model the way a good analytics engineer would — naming the grain first, mapping lineage, defining each column, choosing the right materialization, and writing the dbt tests that keep it correct — so the model is reviewable before a line of SQL ships.

Required Inputs

Ask for these only if they aren't already provided:

  • What the model represents and its grain (one row per ___ — the single most important decision).
  • Layer — staging, intermediate, or mart (dimension/fact). Conventions differ per layer.
  • Sources / upstream refs — the raw tables or models it builds on.
  • The business logic — joins, filters, aggregations, and any business rules.

Output Format

dbt Model: [model_name]

1. Purpose & grain — what it is, and one row per [grain] stated explicitly. Layer (staging/intermediate/mart).

2. Lineage — source('…') / ref('…') upstreams → this model → likely downstream consumers.

3. Transformation logic — the joins, filters, aggregations, window functions, and business rules, in order. Flag fan-out risks (joins that break the grain).

4. Columns — a table: name · type · description · (key/measure/dimension). The schema contract.

columntypedescription

5. Tests (dbt) — unique + not_null on the grain key, relationships for FKs, accepted_values for enums, and any custom/dbt_utils tests the logic needs. Tests are the model's guarantees — don't skip them.

6. Materialization — view / table / incremental / ephemeral, with the reasoning (incremental needs a + an filter).

unique_key
is_incremental()

7. Skeleton — a starting model.sql (CTE-structured: imports → logic → final select) and the schema.yml with tests, ready to fill in.

Quality Checks

  • The grain is stated as "one row per ___" and the key is tested unique + not_null
  • Sources/refs use source()/ref(), not hard-coded table names
  • Every column has a type and description (the schema contract)
  • Tests cover the grain key, FKs (relationships), and enum columns
  • Materialization is justified; incremental models declare a unique_key and is_incremental() logic
  • Fan-out joins that could break the grain are flagged

Anti-Patterns

  • Do not leave the grain ambiguous — an untested, unclear grain is how duplicate rows and wrong metrics happen
  • Do not hard-code upstream table names — use ref()/source() so lineage and environments work
  • Do not ship a model with no tests — untested models silently rot; the grain key at minimum must be tested
  • Do not default everything to a table — pick the materialization the use justifies (views for light, incremental for large append-only)
  • Do not bury business logic without comments — the next analyst must understand the rules

Based On

dbt / analytics-engineering best practice — explicit grain, ref/source lineage, layered modelling (staging→intermediate→mart), schema tests.

Related skills

capacity-planningcompetitor-teardowncontext-engineering-reviewrunbook-writerreceipts-audit