Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Dbt Data Warehouse Modeler

    1

    Architect and author modular dbt models with automated schema tests for Snowflake, BigQuery, and Databricks.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Dbt Data Warehouse Modeler

    Dbt Data Warehouse Modeler

    Example session with this skill installed

    Create a staging model for the 'orders' table in the 'shopify' source, including unique and not_null tests for the order_id. Target is Snowflake.

    • Read your context and instructions
    • Compiled the dbt data warehouse

    I have generated the staging model and the corresponding schema configuration for the Shopify orders data. This includes a modular SQL file using Jinja macros and a YAML file with the requested data quality tests. ## dbt Model Deliverables **File: `models/staging/shopify/stg_shopify__orders.sql`** ```sql with source as ( select * from {{ source('shopify', 'orders') }} ), renamed as ( select id as order_id, customer_id, order_number, total_price, created_at as order_timestamp, _fivetran_synced from source ) select * from renamed ``` **File: `models/staging/shopify/src_shopify.yml`** ```yaml version: 2 sources: - name: shopify database: raw schema: shopify tables: - name: orders description: Raw order data from Shopify. models: - name: stg_shopify__orders description: Staged Shopify orders with cleaned column names. columns: - name: order_id description: The primary key for this table. tests: - unique - not_null - name: order_timestamp description: The timestamp when the order was placed. ``` **Next steps** 1. Run `dbt compile` to verify the Jinja syntax is correct for your Snowflake environment. 2. Execute `dbt test --select stg_shopify__orders` to validate the unique and not_null constraints. 3. Update the `database` and `schema` fields in the YAML file to match your raw data location.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building a modern data stack requires more than just writing SQL queries. This skill automates the creation of modular dbt architectures, ensuring your models follow industry standard staging, intermediate, and marts layering. ## What it does - **Layered Modeling** builds structured directory hierarchies for staging, intermediate, and marts layers to keep logic separated. - **Macro Implementation** authors SQL models using Jinja `ref` and `source` macros for proper dependency tracking. - **Materialization Control** configures table, view, and incremental strategies including merge keys for optimized performance. - **Automated Testing** generates `schema.yml` files containing unique, not-null, accepted-values, and relationship tests. - **Documentation Scaffolding** creates YAML documentation blocks to ensure data lineage and column descriptions are captured. ## How it works 1. **Analyze Source Data** by identifying the raw tables and required transformations for the target warehouse. 2. **Scaffold Directory Structure** to align with modular dbt patterns across the project workspace. 3. **Generate SQL Models** using Jinja templating to handle dependencies and materialization logic. 4. **Produce Schema YAMLs** to define tests and documentation for every new model created. ## Frameworks & tools This skill is built for dbt Core and dbt Cloud. It generates optimized SQL and configuration for Snowflake, BigQuery, and Databricks environments. ## Why this beats prompting it yourself Generic LLMs often mix logic layers or forget to include essential Jinja macros, leading to broken DAGs. This skill enforces a deterministic workflow that ensures every model has the correct materialization strategy and accompanying test suite from the start. ## Use cases - Scaffold a new dbt project with standard staging and marts directories. - Convert raw SQL scripts into modular dbt models with proper `ref` tags. - Generate comprehensive schema tests for existing data warehouse tables. - Implement incremental loading logic for large-scale Snowflake or BigQuery datasets. ## Known limitations This skill focuses on SQL and YAML generation within the active workspace. It does not execute dbt commands, manage warehouse infrastructure, or handle secret management beyond env placeholders.

    Restricted to active project workspace. Does not execute dbt run/test commands or manage cloud infrastructure. Requires pre-existing warehouse credentials via environment variables.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.

    Permissions

    Read Files
    Write Files

    Target Use Cases: - Write an incremental dbt model for data warehouse. - Structure dbt staging and mart models with schema tests. - Create dbt YAML documentation with unique and not_null tests.

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    The skill is designed for dbt Core and dbt Cloud, generating warehouse-specific SQL and YAML for Snowflake, BigQuery, and Databricks. It works within AI agents that support file-system access or code generation environments.

    No, this skill focuses on architecting and authoring the code. It generates the SQL models, Jinja macros, and YAML configurations, which you then execute using your own dbt CLI or dbt Cloud environment.

    Yes, the skill automatically builds the staging, intermediate, and marts layers. It ensures each model uses proper Jinja ref functions to create a clean, traceable Directed Acyclic Graph (DAG).

    The skill generates comprehensive schema.yml files that include unique, not-null, and relationship tests for every model it creates. It can also be used to generate test suites for your existing models.

    Unlike generic prompts, this skill enforces a strict architectural framework. It prevents "spaghetti SQL" by forcing modularity and ensuring materialization strategies like incremental loading are configured correctly for your specific warehouse.

    New in Data & Databases