Data Visualization

Name: Data Visualization
Author: pluginagentmarketplace

pluginagentmarketplace/custom-plugin-ai-data-scientist

68 installs
4 repo stars
Updated January 5, 2026
pluginagentmarketplace/custom-plugin-ai-data-scientist

data-visualization is a Claude Code skill for ai & agent building.

About

data-visualization is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

data-visualization
AI & Agent Building
AI-coding skill

Data Visualization by the numbers

68 all-time installs (skills.sh)
Ranked #5,858 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 4, 2026 (Skillselion catalog sync)

npx skills add https://github.com/pluginagentmarketplace/custom-plugin-ai-data-scientist --skill data-visualization

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/pluginagentmarketplace/custom-plugin-ai-data-scientist/data-visualization.svg)](https://skillselion.com/skills/pluginagentmarketplace/custom-plugin-ai-data-scientist/data-visualization)

Installs	68
repo stars	★ 4
Last updated	January 5, 2026
Repository	pluginagentmarketplace/custom-plugin-ai-data-scientist ↗

How do I helps with ai & agent building tasks.?

Helps with ai & agent building tasks.

Who is it for?

Best when you're working on ai & agent building and need structured help with data visualization.

Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.

When should I use this skill?

When you need to helps with ai & agent building tasks., or when data-visualization is a claude code skill for ai & agent building.

What you get

Structured output aligned to data-visualization: data-visualization, AI & Agent Building.

Files

SKILL.mdMarkdownGitHub ↗

Data Visualization

Create compelling visualizations to explore and communicate data insights.

Quick Start

Matplotlib Basics

import matplotlib.pyplot as plt

# Line plot
plt.figure(figsize=(10, 6))
plt.plot(x, y, marker='o', linestyle='-', color='blue', label='Series 1')
plt.xlabel('X Label')
plt.ylabel('Y Label')
plt.title('Title')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# Bar chart
plt.bar(categories, values, color='skyblue', edgecolor='black')
plt.xlabel('Categories')
plt.ylabel('Values')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Seaborn for Statistical Plots

import seaborn as sns

# Set style
sns.set_style("whitegrid")

# Distribution
sns.histplot(data=df, x='value', kde=True, bins=30)

# Box plot
sns.boxplot(data=df, x='category', y='value')

# Violin plot
sns.violinplot(data=df, x='category', y='value')

# Heatmap
corr = df.corr()
sns.heatmap(corr, annot=True, cmap='coolwarm', center=0)

# Pairplot
sns.pairplot(df, hue='target', diag_kind='kde')

Exploratory Data Analysis

# Quick overview
df.info()
df.describe()

# Missing values
df.isnull().sum()

# Value counts
df['category'].value_counts().plot(kind='bar')

# Distribution
df.hist(figsize=(12, 10), bins=30)
plt.tight_layout()
plt.show()

# Correlation matrix
plt.figure(figsize=(10, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm',
            center=0, square=True)
plt.title('Correlation Matrix')
plt.show()

Interactive Visualizations with Plotly

import plotly.express as px
import plotly.graph_objects as go

# Interactive scatter
fig = px.scatter(df, x='feature1', y='target',
                 color='category', size='value',
                 hover_data=['name', 'date'],
                 title='Interactive Scatter Plot')
fig.show()

# Time series
fig = px.line(df, x='date', y='value', color='category',
              title='Time Series')
fig.update_xaxes(rangeslider_visible=True)
fig.show()

# 3D scatter
fig = px.scatter_3d(df, x='x', y='y', z='z',
                    color='category', size='value')
fig.show()

Dashboard with Plotly Dash

import dash
from dash import dcc, html
from dash.dependencies import Input, Output

app = dash.Dash(__name__)

app.layout = html.Div([
    html.H1('Sales Dashboard'),

    dcc.Dropdown(
        id='category-dropdown',
        options=[{'label': cat, 'value': cat}
                for cat in df['category'].unique()],
        value=df['category'].unique()[0]
    ),

    dcc.Graph(id='sales-graph'),

    dcc.RangeSlider(
        id='year-slider',
        min=df['year'].min(),
        max=df['year'].max(),
        value=[df['year'].min(), df['year'].max()],
        marks={str(year): str(year)
              for year in df['year'].unique()}
    )
])

@app.callback(
    Output('sales-graph', 'figure'),
    [Input('category-dropdown', 'value'),
     Input('year-slider', 'value')]
)
def update_graph(selected_category, year_range):
    filtered_df = df[
        (df['category'] == selected_category) &
        (df['year'] >= year_range[0]) &
        (df['year'] <= year_range[1])
    ]
    fig = px.line(filtered_df, x='date', y='sales')
    return fig

if __name__ == '__main__':
    app.run_server(debug=True)

Subplots

fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# Top left
axes[0, 0].hist(data1, bins=30)
axes[0, 0].set_title('Histogram')

# Top right
axes[0, 1].scatter(x, y)
axes[0, 1].set_title('Scatter')

# Bottom left
axes[1, 0].plot(x, y)
axes[1, 0].set_title('Line Plot')

# Bottom right
axes[1, 1].boxplot([data1, data2, data3])
axes[1, 1].set_title('Box Plot')

plt.tight_layout()
plt.show()

Visualization Best Practices

1. Choose the right chart type:

Comparison: Bar chart
Distribution: Histogram, box plot
Relationship: Scatter plot
Time series: Line chart
Composition: Pie chart, stacked bar

2. Design principles:

Clear labels and titles
Appropriate color schemes
Remove chart junk
Consistent formatting
Accessibility (color-blind friendly)

3. Common pitfalls to avoid:

Misleading axes (non-zero baseline)
Too many colors
3D charts (distort perception)
Pie charts with many categories
Dual y-axes (confusing)

Color Palettes

# Seaborn palettes
sns.color_palette("viridis", as_cmap=True)
sns.color_palette("coolwarm", as_cmap=True)
sns.color_palette("Set2")

# Custom colors
colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A']

Export Figures

# High-resolution PNG
plt.savefig('figure.png', dpi=300, bbox_inches='tight')

# Vector format (PDF, SVG)
plt.savefig('figure.pdf', bbox_inches='tight')
plt.savefig('figure.svg', bbox_inches='tight')

# Data Visualization Chart Styles Configuration
# Professional styling for data science visualizations

# Color Palettes
palettes:
  # Default palette - professional and accessible
  default:
    primary: ["#2563eb", "#3b82f6", "#60a5fa", "#93c5fd", "#bfdbfe"]
    secondary: ["#7c3aed", "#8b5cf6", "#a78bfa", "#c4b5fd", "#ddd6fe"]
    accent: ["#059669", "#10b981", "#34d399", "#6ee7b7", "#a7f3d0"]
    warning: ["#d97706", "#f59e0b", "#fbbf24", "#fcd34d", "#fde68a"]
    danger: ["#dc2626", "#ef4444", "#f87171", "#fca5a5", "#fecaca"]

  # Categorical palette (colorblind-friendly)
  categorical:
    - "#0077BB"  # Blue
    - "#EE7733"  # Orange
    - "#009988"  # Teal
    - "#CC3311"  # Red
    - "#33BBEE"  # Cyan
    - "#EE3377"  # Magenta
    - "#BBBBBB"  # Grey

  # Sequential palettes
  sequential:
    blues: ["#f7fbff", "#deebf7", "#c6dbef", "#9ecae1", "#6baed6", "#4292c6", "#2171b5", "#084594"]
    greens: ["#f7fcf5", "#e5f5e0", "#c7e9c0", "#a1d99b", "#74c476", "#41ab5d", "#238b45", "#005a32"]
    reds: ["#fff5f0", "#fee0d2", "#fcbba1", "#fc9272", "#fb6a4a", "#ef3b2c", "#cb181d", "#99000d"]

  # Diverging palettes
  diverging:
    red_blue: ["#d73027", "#f46d43", "#fdae61", "#fee090", "#e0f3f8", "#abd9e9", "#74add1", "#4575b4"]
    purple_green: ["#762a83", "#9970ab", "#c2a5cf", "#e7d4e8", "#d9f0d3", "#a6dba0", "#5aae61", "#1b7837"]

# Chart Type Configurations
chart_types:
  bar:
    orientation: "vertical"  # vertical, horizontal
    bar_width: 0.8
    show_values: true
    value_format: ".1f"
    edge_color: "white"
    edge_width: 0.5

  line:
    line_width: 2
    marker_size: 6
    marker_style: "o"
    show_markers: true
    alpha: 0.9
    interpolation: "linear"  # linear, spline, step

  scatter:
    marker_size: 50
    alpha: 0.7
    edge_color: "white"
    edge_width: 0.5

  histogram:
    bins: 30
    alpha: 0.7
    edge_color: "white"
    density: false
    show_kde: true

  heatmap:
    cmap: "coolwarm"
    center: 0
    annot: true
    fmt: ".2f"
    square: true
    linewidths: 0.5

  boxplot:
    show_outliers: true
    show_means: true
    width: 0.6
    notch: false

  pie:
    autopct: "%1.1f%%"
    startangle: 90
    explode_max: 0.05
    shadow: false

# Figure Settings
figure:
  # Size presets
  sizes:
    small: [6, 4]
    medium: [10, 6]
    large: [14, 8]
    wide: [16, 6]
    square: [8, 8]

  # DPI settings
  dpi:
    screen: 100
    publication: 300
    poster: 600

  # Background
  background:
    figure: "white"
    axes: "white"

  # Grid
  grid:
    show: true
    alpha: 0.3
    style: "-"
    which: "major"

# Typography
typography:
  font_family: "sans-serif"

  sizes:
    title: 16
    subtitle: 14
    axis_label: 12
    tick_label: 10
    legend: 10
    annotation: 9

  weights:
    title: "bold"
    axis_label: "normal"
    tick_label: "normal"

# Export Settings
export:
  formats: ["png", "pdf", "svg"]
  default_format: "png"
  dpi: 300
  transparent: false
  bbox_inches: "tight"
  pad_inches: 0.1

# Accessibility
accessibility:
  # Colorblind-friendly mode
  colorblind_safe: true

  # Minimum contrast ratio
  min_contrast: 4.5

  # Pattern fills for charts
  use_patterns: false

  # Large text mode
  large_text: false

Chart Selection Guide

Quick Selection Matrix

What do you want to show?
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ COMPARISON                                                               │
│   Few categories → Bar Chart                                             │
│   Many categories → Horizontal Bar                                       │
│   Over time → Line Chart                                                 │
├─────────────────────────────────────────────────────────────────────────┤
│ DISTRIBUTION                                                             │
│   Single variable → Histogram, Box Plot                                  │
│   Two variables → Scatter Plot                                           │
│   Multiple variables → Pair Plot, Violin Plot                            │
├─────────────────────────────────────────────────────────────────────────┤
│ RELATIONSHIP                                                             │
│   Correlation → Scatter Plot, Heatmap                                    │
│   Part-to-whole → Pie Chart, Stacked Bar                                 │
│   Hierarchy → Treemap, Sunburst                                          │
├─────────────────────────────────────────────────────────────────────────┤
│ TREND                                                                    │
│   Over time → Line Chart, Area Chart                                     │
│   With uncertainty → Line + Confidence Interval                          │
│   Multiple series → Multi-line Plot                                      │
├─────────────────────────────────────────────────────────────────────────┤
│ COMPOSITION                                                              │
│   Static → Pie Chart, Donut                                              │
│   Over time → Stacked Area                                               │
│   Nested → Treemap                                                       │
└─────────────────────────────────────────────────────────────────────────┘

Chart Types Quick Reference

Chart	Best For	Avoid When
Bar	Comparing categories	Too many categories (>15)
Line	Trends over time	Non-sequential data
Scatter	Relationships	Overlapping points
Histogram	Distributions	Small samples
Box Plot	Comparing distributions	Non-normal data
Heatmap	Correlations, matrices	Too many variables
Pie	Part-to-whole (2-6 parts)	Many categories
Area	Cumulative trends	Overlapping series

Color Guidelines

When to Use Color

Purpose	Strategy
Categorical	Different hue per category
Sequential	Light to dark gradient
Diverging	Two colors from center
Highlighting	One accent color
Grouping	Color families

Colorblind-Safe Palettes

# Recommended palettes
palettes = {
    'categorical': ['#0077BB', '#EE7733', '#009988', '#CC3311'],
    'sequential': 'viridis',  # or 'plasma', 'cividis'
    'diverging': 'coolwarm'
}

# Avoid: red-green combinations
# Prefer: blue-orange, purple-green

Chart Anatomy Best Practices

┌─────────────────────────────────────────────┐
│            TITLE (Descriptive)              │ ← Clear, informative
├─────────────────────────────────────────────┤
│  Y │                                        │
│    │         ╭────────╮                     │
│  L │    ╭────╯        ╰────╮               │
│  A │ ───╯                  ╰───             │
│  B │                                        │
│  E │                                        │
│  L │                                        │
│    └────────────────────────────────────────│
│            X AXIS LABEL                     │ ← Units included
│                                    LEGEND ──│ ← If needed
│            Source: XYZ Dataset              │ ← Optional
└─────────────────────────────────────────────┘

Common Mistakes to Avoid

1. Truncated Y-axis - Start at zero for bars 2. Too many colors - Limit to 5-7 max 3. 3D effects - Distort perception 4. Dual Y-axes - Confusing 5. Pie charts with many slices - Use bar instead 6. Missing labels - Always include axes labels 7. Small fonts - Ensure readability 8. No legend - Explain what colors mean

Python Quick Recipes

# Distribution
sns.histplot(df['col'], kde=True)

# Comparison
df.plot.bar(x='category', y='value')

# Relationship
sns.scatterplot(x='var1', y='var2', hue='group', data=df)

# Correlation
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')

# Time series
df.plot(x='date', y='value', figsize=(12, 6))

# Subplots
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

Export Settings

# Publication quality
plt.savefig('figure.png', dpi=300, bbox_inches='tight')
plt.savefig('figure.pdf', bbox_inches='tight')  # Vector
plt.savefig('figure.svg', bbox_inches='tight')  # Editable

#!/usr/bin/env python3
"""
Quick Plotting Utilities for Data Science
One-liner visualizations for rapid EDA
"""

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
from typing import Optional, List, Union, Tuple
from pathlib import Path


def set_style(style: str = 'professional'):
    """Set global plotting style."""
    styles = {
        'professional': {
            'style': 'whitegrid',
            'context': 'notebook',
            'palette': 'deep'
        },
        'minimal': {
            'style': 'white',
            'context': 'paper',
            'palette': 'muted'
        },
        'dark': {
            'style': 'darkgrid',
            'context': 'talk',
            'palette': 'bright'
        },
        'publication': {
            'style': 'ticks',
            'context': 'paper',
            'palette': 'colorblind'
        }
    }

    config = styles.get(style, styles['professional'])
    sns.set_style(config['style'])
    sns.set_context(config['context'])
    sns.set_palette(config['palette'])


def quick_hist(data: Union[pd.Series, np.ndarray, list],
               title: str = None,
               bins: int = 30,
               kde: bool = True,
               figsize: Tuple[int, int] = (10, 6),
               save: str = None) -> plt.Figure:
    """Quick histogram with optional KDE."""
    fig, ax = plt.subplots(figsize=figsize)
    sns.histplot(data, bins=bins, kde=kde, ax=ax)

    ax.set_title(title or 'Distribution', fontsize=14, fontweight='bold')
    ax.set_xlabel('Value')
    ax.set_ylabel('Frequency')

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_scatter(x: Union[pd.Series, np.ndarray],
                  y: Union[pd.Series, np.ndarray],
                  hue: Optional[Union[pd.Series, np.ndarray]] = None,
                  title: str = None,
                  xlabel: str = None,
                  ylabel: str = None,
                  figsize: Tuple[int, int] = (10, 6),
                  save: str = None) -> plt.Figure:
    """Quick scatter plot with optional coloring."""
    fig, ax = plt.subplots(figsize=figsize)

    scatter = ax.scatter(x, y, c=hue, alpha=0.7, cmap='viridis', edgecolors='white')

    if hue is not None:
        plt.colorbar(scatter, label='Value')

    ax.set_title(title or 'Scatter Plot', fontsize=14, fontweight='bold')
    ax.set_xlabel(xlabel or 'X')
    ax.set_ylabel(ylabel or 'Y')

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_bar(x: Union[pd.Series, list],
              y: Union[pd.Series, list],
              title: str = None,
              horizontal: bool = False,
              figsize: Tuple[int, int] = (10, 6),
              save: str = None) -> plt.Figure:
    """Quick bar chart."""
    fig, ax = plt.subplots(figsize=figsize)

    if horizontal:
        ax.barh(x, y, color=sns.color_palette()[0], edgecolor='white')
        ax.set_xlabel('Value')
    else:
        ax.bar(x, y, color=sns.color_palette()[0], edgecolor='white')
        ax.set_ylabel('Value')
        plt.xticks(rotation=45, ha='right')

    ax.set_title(title or 'Bar Chart', fontsize=14, fontweight='bold')

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_line(x: Union[pd.Series, np.ndarray],
               y: Union[pd.Series, np.ndarray, List],
               labels: List[str] = None,
               title: str = None,
               xlabel: str = None,
               ylabel: str = None,
               figsize: Tuple[int, int] = (12, 6),
               save: str = None) -> plt.Figure:
    """Quick line plot (supports multiple lines)."""
    fig, ax = plt.subplots(figsize=figsize)

    # Handle single or multiple lines
    if isinstance(y, list) and isinstance(y[0], (list, np.ndarray, pd.Series)):
        for i, line_y in enumerate(y):
            label = labels[i] if labels else f'Series {i+1}'
            ax.plot(x, line_y, marker='o', label=label, linewidth=2, markersize=4)
        ax.legend()
    else:
        ax.plot(x, y, marker='o', linewidth=2, markersize=4)

    ax.set_title(title or 'Line Plot', fontsize=14, fontweight='bold')
    ax.set_xlabel(xlabel or 'X')
    ax.set_ylabel(ylabel or 'Y')
    ax.grid(True, alpha=0.3)

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_box(df: pd.DataFrame,
              x: str = None,
              y: str = None,
              title: str = None,
              figsize: Tuple[int, int] = (10, 6),
              save: str = None) -> plt.Figure:
    """Quick box plot."""
    fig, ax = plt.subplots(figsize=figsize)

    if x and y:
        sns.boxplot(data=df, x=x, y=y, ax=ax)
        plt.xticks(rotation=45, ha='right')
    else:
        sns.boxplot(data=df, ax=ax)

    ax.set_title(title or 'Box Plot', fontsize=14, fontweight='bold')

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_heatmap(data: pd.DataFrame,
                  title: str = None,
                  annot: bool = True,
                  figsize: Tuple[int, int] = (10, 8),
                  save: str = None) -> plt.Figure:
    """Quick correlation heatmap."""
    fig, ax = plt.subplots(figsize=figsize)

    # If not already a correlation matrix, compute it
    if data.shape[0] != data.shape[1]:
        data = data.corr()

    mask = np.triu(np.ones_like(data, dtype=bool))
    sns.heatmap(data, mask=mask, annot=annot, cmap='coolwarm',
                center=0, square=True, linewidths=0.5,
                fmt='.2f', ax=ax)

    ax.set_title(title or 'Correlation Heatmap', fontsize=14, fontweight='bold')

    plt.tight_layout()
    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')
    return fig


def quick_pairplot(df: pd.DataFrame,
                   hue: str = None,
                   figsize: Tuple[int, int] = None,
                   save: str = None):
    """Quick pair plot for multivariate exploration."""
    g = sns.pairplot(df, hue=hue, diag_kind='kde',
                     plot_kws={'alpha': 0.6, 'edgecolor': 'white'},
                     height=2.5, aspect=1)

    g.fig.suptitle('Pair Plot', y=1.02, fontsize=14, fontweight='bold')

    if save:
        g.fig.savefig(save, dpi=300, bbox_inches='tight')
    return g


def quick_eda(df: pd.DataFrame,
              figsize: Tuple[int, int] = (16, 12),
              save: str = None) -> plt.Figure:
    """Quick EDA dashboard for a DataFrame."""
    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()

    if len(numeric_cols) == 0:
        print("No numeric columns found!")
        return None

    # Limit to first 6 numeric columns
    cols_to_plot = numeric_cols[:6]
    n_cols = len(cols_to_plot)

    fig, axes = plt.subplots(2, min(n_cols, 3), figsize=figsize)
    axes = axes.flatten()

    # Row 1: Distributions
    for i, col in enumerate(cols_to_plot[:3]):
        sns.histplot(df[col], kde=True, ax=axes[i])
        axes[i].set_title(f'{col} Distribution')

    # Row 2: Box plots
    for i, col in enumerate(cols_to_plot[:3]):
        sns.boxplot(data=df, y=col, ax=axes[i + 3])
        axes[i + 3].set_title(f'{col} Box Plot')

    # Hide unused axes
    for j in range(n_cols, len(axes)):
        axes[j].set_visible(False)

    plt.suptitle('Quick EDA Dashboard', fontsize=16, fontweight='bold')
    plt.tight_layout()

    if save:
        plt.savefig(save, dpi=300, bbox_inches='tight')

    return fig


def main():
    """Demo quick plotting utilities."""
    print("Quick Plotting Demo")
    print("=" * 50)

    # Set style
    set_style('professional')

    # Generate sample data
    np.random.seed(42)
    n = 100

    df = pd.DataFrame({
        'x': np.linspace(0, 10, n),
        'y1': np.sin(np.linspace(0, 10, n)) + np.random.normal(0, 0.1, n),
        'y2': np.cos(np.linspace(0, 10, n)) + np.random.normal(0, 0.1, n),
        'category': np.random.choice(['A', 'B', 'C'], n),
        'value': np.random.normal(50, 15, n)
    })

    print("Sample DataFrame created:")
    print(df.head())

    # Demo: Histogram
    quick_hist(df['value'], title='Value Distribution')
    plt.show()

    # Demo: Line plot with multiple series
    quick_line(df['x'], [df['y1'], df['y2']],
              labels=['Sin', 'Cos'],
              title='Multiple Line Plot')
    plt.show()

    # Demo: Correlation heatmap
    quick_heatmap(df[['y1', 'y2', 'value']], title='Correlation Matrix')
    plt.show()

    print("\n[SUCCESS] Quick plotting demo complete!")


if __name__ == '__main__':
    main()