Skip to content
Skillpedia
Deploy & cloud (DevOps)41k · #4836

airflow-dag-patterns

Has your agent create automated workflows for data processing. It uses Airflow to organize tasks, like scheduling jobs or running important data processes.

What it does

This tool helps you build automated workflows (called DAGs) for Apache Airflow. It teaches best practices for organizing tasks, ensuring they run correctly, and making them easy to manage.

When to use it

  • ✓When creating an automated process to move or process data.
  • ✓When you need a set of tasks to run in a specific order.
  • ✓When setting up tasks that need to repeat at scheduled times.

Example of what to ask your AI

“How can I create a workflow that downloads a file every day at 6 AM and then processes it?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/wshobson/agents/blob/main/plugins/data-engineering/skills/airflow-dag-patterns/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/wshobson/agents/blob/main/plugins/data-engineering/skills/airflow-dag-patterns/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool provides templates and code examples showing how to define tasks, their dependencies, and important settings. It follows principles like ensuring a task can be run multiple times without issues (idempotence) and that each task has a clear outcome (atomic).

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add wshobson/agents --skill airflow-dag-patterns

Or download just the file:

curl -L https://raw.githubusercontent.com/wshobson/agents/main/plugins/data-engineering/skills/airflow-dag-patterns/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Apache Airflow DAG Patterns

Production-ready patterns for Apache Airflow including DAG design, operators, sensors, testing, and deployment strategies.

When to Use This Skill

  • Creating data pipeline orchestration with Airflow
  • Designing DAG structures and dependencies
  • Implementing custom operators and sensors
  • Testing Airflow DAGs locally
  • Setting up Airflow in production
  • Debugging failed DAG runs

Core Concepts

1. DAG Design Principles

Principle Description
Idempotent Running twice produces same result
Atomic Tasks succeed or fail completely
Incremental Process only new/changed data
Observable Logs, metrics, alerts at every step

2. Task Dependencies

# Linear
task1 >> task2 >> task3

# Fan-out
task1 >> [task2, task3, task4]

# Fan-in
[task1, task2, task3] >> task4

# Complex
task1 >> task2 >> task4
task1 >> task3 >> task4

Quick Start

# dags/example_dag.py
from datetime import datetime, timedelta
from airflow import DAG
from airflow.operators.python import PythonOperator
from airflow.operators.empty import EmptyOperator

default_args = {
    'owner': 'data-team',
    'depends_on_past': False,
    'email_on_failure': True,
    'email_on_retry': False,
    'retries': 3,
    'retry_delay': timedelta(minutes=5),
    'retry_exponential_backoff': True,
    'max_retry_delay': timedelta(hours=1),
}

with DAG(
    dag_id='example_etl',
    default_args=default_args,
    description='Example ETL pipeline',
    schedule='0 6 * * *',  # Daily at 6 AM
    start_date=datetime(2024, 1, 1),
    catchup=False,
    tags=['etl', 'example'],
    max_active_runs=1,
) as dag:

    start = EmptyOperator(task_id='start')

    def extract_data(**context):
        execution_date = context['ds']
        # Extract logic here
        return {'records': 1000}

    extract = PythonOperator(
        task_id='extract',
        python_callable=extract_data,
    )

    end = EmptyOperator(task_id='end')

    start >> extract >> end

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Best Practices

Do's

  • Use TaskFlow API - Cleaner code, automatic XCom
  • Set timeouts - Prevent zombie tasks
  • Use mode='reschedule' - For sensors, free up workers
  • Test DAGs - Unit tests and integration tests
  • Idempotent tasks - Safe to retry

Don'ts

  • Don't use depends_on_past=True - Creates bottlenecks
  • Don't hardcode dates - Use {{ ds }} macros
  • Don't use global state - Tasks should be stateless
  • Don't skip catchup blindly - Understand implications
  • Don't put heavy logic in DAG file - Import from modules
FAQ

What is a DAG?

DAG stands for Directed Acyclic Graph. Think of it as a map showing the tasks that need to be done and the order they should happen, without creating loops (meaning, you don't go back to the start).

Why is it important for tasks to be 'idempotent'?

Being idempotent means running a task multiple times in a row has the same result as running it just once. This is crucial for reliability because if a task fails and needs to be restarted, you're guaranteed the final outcome won't be altered.

What are 'operators' and 'sensors'?

Operators are the basic building blocks of a DAG, representing an action to be performed (like running a Python script). Sensors are a special type of operator that waits for something to happen before continuing (like waiting for a file to arrive).

Details

Original description by the author

Build production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating workflows, or scheduling batch jobs.

repo: wshobson/agents

Popularity

GitHub stars
41k
Ranking position
#4836
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills