AutoGineer
Generated banner for Data Designer
Generated logo for Data Designer

Data Designer

NVIDIAOfficialPublished by NVIDIA

  • Skill
  • Workflow
  • Data and AI
  • Apache-2.0
  • Medium risk
  • Has scripts
Download ZIP

From the author

Use when the user wants to create a dataset, generate synthetic data, or build a data generation pipeline. The argument is the description of the dataset to generate.
— the description by NVIDIA

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The data-designer skill provides a structured workflow for creating synthetic datasets or building data generation pipelines. It guides users through defining dataset requirements, configuring column samplers, and implementing custom generation logic. The skill supports both interactive and automated modes, ensuring that users can either collaborate on the design or allow the agent to make opinionated decisions. It includes specific references for handling person-related data and validating generated content, ensuring the output is statistically sound and aligned with user specifications.

What it does

  • Generates synthetic datasets based on user-provided descriptions.
  • Builds data generation pipelines using the Data Designer library.
  • Supports custom column generators for complex data logic.
  • Provides guidance on sampling person data, including demographics and personas.
  • Offers an automated mode for opinionated, hands-off dataset creation.
  • Includes a structured output template using Python and Pydantic.

When to use it

  • When you need to create a synthetic dataset for testing or training purposes.
  • When you require a repeatable data generation pipeline.
  • When you need to generate realistic person data with specific demographic or persona traits.
  • When you want to define complex data relationships that require custom generation logic.

Advantages

  • Ensures consistent data generation through a standardized configuration builder.
  • Provides flexible sampling options, including census-grounded person data.
  • Allows for easy integration of custom logic via Python decorators.
  • Supports structured output schemas using Pydantic models.
  • Reduces manual effort by offering an automated generation mode.

Usage examples

“Create a synthetic dataset of 100 customer reviews for a coffee shop, including ratings and sentiment scores.”
The agent will generate a Python script using Data Designer to produce a parquet file containing the requested customer review data.
“I need a dataset of user profiles with realistic names, addresses, and personality traits. Just build it for me.”
The agent will use Autopilot mode to configure a dataset with person samplers and synthetic personas, outputting the configuration file.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/nvidia/data-designer/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip data-designer.zip -d .agents/skills

Documentation by NVIDIA

Before You Start

Do not explore the workspace first. The workflow's Learn step gives you everything you need.

Goal

Build a synthetic dataset using the Data Designer library that matches this description:

$ARGUMENTS

Workflow

Use Autopilot mode if the user implies they don't want to answer questions — e.g., they say something like "be opinionated", "you decide", "make reasonable assumptions", "just build it", "surprise me", etc. Otherwise, use Interactive mode (default).

Read only the workflow file that matches the selected mode, then follow it:

  • Interactive → read workflows/interactive.md

  • Autopilot → read workflows/autopilot.md

Rules

  • Keep all columns in the output by default. The only exceptions for dropping a column are: (1) the user explicitly asks, or (2) it is a helper column that exists solely to derive other columns (e.g., a sampled person object used to extract name, city, etc.). When in doubt, keep the column.

  • Do not suggest or ask about seed datasets. Only use one when the user explicitly provides seed data or asks to build from existing records. When using a seed, read references/seed-datasets.md.

  • When the dataset requires person data (names, demographics, addresses), read references/person-sampling.md.

  • If a dataset script that matches the dataset description already exists, ask the user whether to edit it or create a new one.

Usage Tips and Common Pitfalls

  • Sampler and validation columns need both a type and params. E.g., sampler_type="category" with params=dd.CategorySamplerParams(...).

  • Jinja2 templates in prompt, system_prompt, and expr fields: reference columns with {{ column_name }}, nested fields with {{ column_name.field }}.

  • SamplerColumnConfig: Takes params, not sampler_params.

  • LLM judge score access: LLMJudgeColumnConfig produces a nested dict where each score name maps to {reasoning: str, score: int}. To get the numeric score, use the .score attribute. For example, for a judge column named quality with a score named correctness, use {{ quality.correctness.score }}. Using {{ quality.correctness }} returns the full dict, not the numeric score.

Troubleshooting

  • data-designer CLI not found: Tell the user that data-designer is not installed in this environment (requires Python >= 3.11). Ask if they would like you to create a virtual environment and install it, or if they prefer to do it themselves. Do not install anything without the user's permission.

  • Network errors during preview: A sandbox environment may be blocking outbound requests. Ask the user for permission to retry the command with the sandbox disabled. Only as a last resort, if retrying outside the sandbox also fails, tell the user to run the command themselves.

Output Template

Write a Python file to the current directory with a load_config_builder() function returning a DataDesignerConfigBuilder. Name the file descriptively (e.g., customer_reviews.py). Use PEP 723 inline metadata for dependencies.

# /// script
# dependencies = [
#   "data-designer", # always required
#   "pydantic", # only if this script imports from pydantic
#   # add additional dependencies here
# ]
# ///
import data_designer.config as dd
from pydantic import BaseModel, Field


# Use Pydantic models when the output needs to conform to a specific schema
class MyStructuredOutput(BaseModel):
    field_one: str = Field(description="...")
    field_two: int = Field(description="...")


# Use custom generators when built-in column types aren't enough
@dd.custom_column_generator(
    required_columns=["col_a"],
    side_effect_columns=["extra_col"],
)
def generator_function(row: dict) -> dict:
    # add custom logic here that depends on "col_a" and update row in place
    row["name_in_custom_column_config"] = "custom value"
    row["extra_col"] = "extra value"
    return row


def load_config_builder() -> dd.DataDesignerConfigBuilder:
    config_builder = dd.DataDesignerConfigBuilder()

    # Seed dataset (only if the user explicitly mentions a seed dataset path)
    # config_builder.with_seed_dataset(dd.LocalFileSeedSource(path="path/to/seed.parquet"))

    # config_builder.add_column(...)
    # config_builder.add_processor(...)

    return config_builder

Only include Pydantic models, custom generators, seed datasets, and extra dependencies when the task requires them.

Files

workflows/interactive.md

Interactive Workflow

This is an interactive, iterative design process. Do not disengage from the loop unless the user says they are satisfied.

  1. Resolve CLI command — Run command -v data-designer 2>/dev/null || (test -x .venv/bin/data-designer && realpath .venv/bin/data-designer) || echo CLI_NOT_FOUND.

  • If the output is a path, use it as the data-designer executable for all commands in this workflow.

  • If the output is CLI_NOT_FOUND, STOP and follow the Troubleshooting section in SKILL.md. Do not continue to the next step.

  1. Learn — Run data-designer agent context.

  • If no model aliases are configured, stop and tell the user to run data-designer config to set them up before proceeding.

  • Inspect schemas for every column, sampler type, validator, and processor you plan to use.

  • Never guess types or parameters — read the relevant config files first.

  • Always read base.py for inherited fields shared by all config objects.

  1. Clarify — Ask the user clarifying questions to narrow down precisely what they want.

  • Optimize for a great user experience: prefer a structured question tool over plain text if one is available, batch related questions together, keep the set short, provide concrete options/examples/defaults where possible, and use structured inputs (single-select, multi-select, free text, etc.) when they make answering easier.

  • If multiple model aliases are available, ask which one(s) to use (or default to an alias with the appropriate generation_type for each column).

  • Common things to make precise:

    • What the "axes of diversity" are — what should be well represented and diverse in the resulting dataset.

    • The kind and nature of any input data.

    • What variables should be randomized.

    • The schema of the final dataset.

    • The structure of any required structured output columns.

    • What facets of the output dataset are important to capture.

  1. Plan — Determine columns, samplers, processors, validators, and other dataset features needed. Present the plan to the user and ask if they want any changes before generating a preview.

  2. Build — Write the Python script with load_config_builder() (see Output Template in SKILL.md).

  3. Validate — Run data-designer validate <path>. Address any warnings or errors and re-validate until it passes.

  4. Preview — Run data-designer preview <path> --save-results to generate sample records as HTML files.

  • Note the sample records directory printed by the data-designer preview command

  • Give the user a clickable link: file://<sample-records-dir>/sample_records_browser.html

  1. Iterate

    • Ask the user for feedback.

    • Offer to review the records yourself and suggest improvements. If the user accepts, read references/preview-review.md for guidance.

    • Apply changes, re-validate, and re-preview. Repeat until the user is satisfied.

  2. Finalize — Once the user is happy, tell them they can run the following command to create the dataset:

  • data-designer create <path> --num-records <N> --dataset-name <name>.

  • Caution the user that generation speed depends heavily on the dataset configuration and their inference setup.

  • Do not run this command yourself — the user should control when it runs.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
NVIDIA
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/data-designer · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download data-designer.zip