#Why Your Agent Sucks at Data Warehousing: data-engineering-pro

3:47 AM. The coffee is gone. The silence in my apartment is heavy, broken only by the aggressive whir of my laptop’s fan. On the screen, a cursor blinks, mocking me. I am currently supervising—if "supervising" means watching a train wreck in slow motion—an AI agent trying to migrate our primary production database to a new Snowflake warehouse.

We’re not just moving tables. We’re re-architecting. Moving from a messy, monolithic relational structure to a clean, performant star schema. Fact tables. Dimension tables. The whole nine yards.

The agent, powered by the standard data-ai-skills pack, was supposed to handle this. It has 12 skills. "Data cleansing." "Basic SQL querying." "Data visualization." Sounds impressive, right? Like hiring a junior analyst fresh out of a three-month bootcamp.

And that’s exactly the problem.

I watched a man once spend forty-five minutes trying to parallel park a boat trailer. He’d get it almost straight, then turn the wheel the wrong way and jackknife the whole setup. He did this seventeen times. The frustration was palpable, a physical thing you could almost touch. That’s how I feel right now.

#The Freshman SQL Problem

For the last two hours, I’ve been watching this agent generate SQL that is technically valid but practically useless. It’s writing queries that join fifteen tables without any thought for performance. It’s creating wide, flat tables that will cost us a fortune to query. It’s treating our data warehouse like it’s a Microsoft Access database from 1998.

I just asked it to create a new fact table for sales transactions. Here’s what it gave me:

-- Agent-generated "fact table"
CREATE TABLE fact_sales (     sale_id INT,     customer_name VARCHAR(255),     customer_address VARCHAR(255),     product_name VARCHAR(255),     product_category VARCHAR(255),     sale_date DATE,     sale_amount DECIMAL(10, 2) );

I stared at this for a full minute. My eye started twitching. This isn’t a fact table. This is a monster. It’s got customer names and addresses embedded directly in the sales record. Every time a customer makes a purchase, we’re duplicating their entire profile. This is database normalization 101, and the agent is failing it hard.

The agent isn’t thinking about dbt refs. It doesn’t understand incremental builds. It doesn't know what a slowly changing dimension is. It’s just... writing queries. It’s using the basic-sql-querying skill from its pack, and it’s doing it with all the nuance of a sledgehammer.

#The Problem is the Pack, Not the Agent

This isn’t the agent’s fault. It’s doing exactly what its skill pack enables it to do. The data-ai-skills pack is fantastic for ad-hoc analysis, for cleaning up a messy CSV, for generating quick visualizations. It is not for data engineering.

It’s like trying to use the personal-finance-skills pack to manage a multi-national corporate merger. Or using the relationship-dating-skills pack to negotiate a hostage situation. (Wait, maybe that last one might work...). The point is, specificity matters.

An AI agent without the right skills is just a powerful engine without a steering wheel.

A true data engineering agent needs a different vocabulary. It needs to understand the concepts that make modern data warehousing work. It needs to know why we model data, not just how to query it.

Skill	`data-ai-skills` (Freshman)	`data-engineering-pro` (The Pro)
**SQL**	Valid syntax, poor performance.	Optimized for warehouse execution.
**Modeling**	Flat tables, joins everywhere.	Star schema, Snowflake schema, Data Vault.
**ETL/ELT**	One-off scripts.	dbt models, incremental builds, materializations.
**Data Quality**	Basic null checks.	Schema validation, data contracts, testing.
**Architecture**	"Just put it all in one table."	Modular, scalable, maintainable pipelines.

#Injecting the Expertise

This is where SkillDB shines. It’s not about building a smarter agent from scratch. It’s about giving the agent you already have the specific, professional skills it needs for the task at hand.

I need this migration done before the sun comes up. I can’t spend the next four hours hand-holding a junior SQL writer. So, I’m going to load the data-engineering-pro pack into the agent.

This pack isn't just a collection of SQL commands. It’s a repository of engineering principles. It includes skills for:

• dbt-model-generation: Automatically creating and managing dbt models, with full support for ref(), source(), and config().
• dimensional-data-modeling: Designing and implementing star schemas, including surrogate key generation and SCD (Slowly Changing Dimension) management.
• data-pipeline-orchestration: Understanding dependencies and scheduling for complex ETL/ELT workflows.
• performance-tuning-for-warehouses: Writing SQL optimized for columnar stores like Snowflake and BigQuery.

I’m literally watching the agent’s configuration update. It's like watching a friend finally get the joke after you’ve explained it to them for twenty minutes. The confusion clears. The realization sets in.

// Agent config update (SkillDB integration)
{   "agent_id": "migration-agent-v1",   "name": "Data Migration Specialist",   "packs": [     "data-ai-skills", // Keep the basics     "data-engineering-pro" // THIS IS WHAT WE NEED   ] }

The difference is immediate. The next query the agent generates isn’t a monstrosity. It’s a clean, modular dbt model. It uses dbt_utils.surrogate_key to generate keys for the fact table. It references a dim_customers table that it already created because it understood the data model.

-- New, optimized dbt model generated by the agent
{{ config(materialized='incremental', unique_key='sale_id') }}
WITH customers AS (     SELECT  FROM {{ ref('dim_customers') }} ), products AS (     SELECT  FROM {{ ref('dim_products') }} ), source_sales AS (     SELECT * FROM {{ source('raw_data', 'sales') }}     {% if is_incremental() %}         WHERE sale_date > (SELECT max(sale_date) FROM {{ this }})     {% endif %} )
SELECT     {{ dbt_utils.surrogate_key(['src.sale_id', 'src.sale_date']) }} as sale_key,     src.sale_id,     c.customer_key,     p.product_key,     src.sale_date,     src.sale_amount FROM source_sales src JOIN customers c ON src.customer_id = c.customer_id JOIN products p ON src.product_id = p.product_id

I can breathe again. The agent isn’t just writing code anymore; it’s engineering a solution.

#The Anchor Sentence

Your agent is only as good as the skills you give it.

If you are asking your agent to do professional-grade work with amateur-grade skills, you are the problem, not the machine. Stop treating Technology & Engineering like a single monolith. SkillDB has 37 categories for a reason. Go deeper.

I’m going to finish this coffee, watch this agent complete the migration, and maybe, just maybe, get an hour of sleep before the rest of the world wakes up.

Don't let your agent suck. Get the data-engineering-pro pack at SkillDB.dev and give it the professional skills it deserves.