Slack GIF Creator Skill

Overview

Create custom animated GIFs for Slack workspaces, including celebration GIFs, reaction GIFs, and custom emoji animations. These add personality and fun to team communications.

When to Use

• Celebrating team wins and milestones

• Creating custom emoji reactions

• Building "Ship it!" or "LGTM" animations

• Designing status indicators

• Adding personality to team channels

• Inside jokes and team culture building

Quick Start

• Choose GIF type (celebration, reaction, status)

• Select method (PIL/Pillow for simple, moviepy for video)

• Create frames with animation loop

• Optimize for Slack (128x128px emoji, <200KB)

• Upload to workspace

from PIL import Image, ImageDraw, ImageFont

def create_shipped_gif(output_path): frames = [] size = (128, 128)

for i in range(10):
    img = Image.new('RGBA', size, (255, 255, 255, 0))
    draw = ImageDraw.Draw(img)

    # Pulsing effect
    scale = 0.8 + 0.2 * abs(i - 5) / 5
    font_size = int(20 * scale)

    draw.text((20, 50), "SHIPPED!", fill=(255, 100, 100))
    frames.append(img)

frames[0].save(output_path, save_all=True, append_images=frames[1:],
               duration=100, loop=0, transparency=0, disposal=2)

create_shipped_gif("shipped.gif")

GIF Types

1. Celebration GIFs

• Team wins

• Project completions

• Work anniversaries

• Promotions

• Goal achievements

2. Reaction GIFs

• Approval/thumbs up variations

• "Ship it!"

• "LGTM" (Looks Good To Me)

• "Deploying..."

• Custom team expressions

3. Status GIFs

• "In a meeting"

• "Deep work mode"

• "Coffee break"

• "Reviewing PR"

Creation Methods

Method 1: Python with Pillow (Simple Animations)

from PIL import Image, ImageDraw, ImageFont import os

def create_text_gif(text, output_path, frames=10, size=(128, 128)): """ Create simple animated text GIF.

Args:
    text: Text to animate
    output_path: Where to save the GIF
    frames: Number of animation frames
    size: GIF dimensions (width, height)
"""
images = []

for i in range(frames):
    # Create frame
    img = Image.new('RGBA', size, (255, 255, 255, 0))
    draw = ImageDraw.Draw(img)

    # Animation effect: pulse/scale
    scale = 0.8 + 0.2 * abs(i - frames//2) / (frames//2)
    font_size = int(24 * scale)

    try:
        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
    except:
        font = ImageFont.load_default()

    # Center text
    bbox = draw.textbbox((0, 0), text, font=font)
    text_width = bbox[2] - bbox[0]
    text_height = bbox[3] - bbox[1]
    x = (size[0] - text_width) // 2
    y = (size[1] - text_height) // 2

    # Draw with color variation
    hue_shift = int(255 * i / frames)
    color = (255, hue_shift, 100)
    draw.text((x, y), text, font=font, fill=color)

    images.append(img)

# Save as GIF
images[0].save(
    output_path,
    save_all=True,
    append_images=images[1:],
    duration=100,
    loop=0,
    transparency=0,
    disposal=2
)

Usage

create_text_gif("SHIPPED!", "shipped.gif") create_text_gif("LGTM", "lgtm.gif")

Method 2: Python with moviepy (Video-to-GIF)

from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip import moviepy.video.fx.all as vfx

def video_to_slack_gif(video_path, output_path, start=0, duration=3, text=None): """ Convert video clip to Slack-optimized GIF.

Args:
    video_path: Source video file
    output_path: Output GIF path
    start: Start time in seconds
    duration: Duration in seconds
    text: Optional text overlay
"""
# Load and trim video
clip = VideoFileClip(video_path).subclip(start, start + duration)

# Resize for Slack (max 128px for emoji, larger for messages)
clip = clip.resize(height=128)

# Add text overlay if provided
if text:
    txt_clip = TextClip(
        text,
        fontsize=20,
        color='white',
        stroke_color='black',
        stroke_width=1,
        font='DejaVu-Sans-Bold'
    ).set_position('bottom').set_duration(clip.duration)

    clip = CompositeVideoClip([clip, txt_clip])

# Optimize for file size
clip.write_gif(
    output_path,
    fps=10,
    program='ffmpeg',
    opt='nq'  # Optimize quality
)

Usage

video_to_slack_gif("celebration.mp4", "party.gif", text="SHIPPED!")

Method 3: Frame-by-Frame Animation

from PIL import Image, ImageDraw import math

def create_spinner_gif(output_path, size=64, frames=12): """Create loading spinner GIF.""" images = []

for frame in range(frames):
    img = Image.new('RGBA', (size, size), (255, 255, 255, 0))
    draw = ImageDraw.Draw(img)

    center = size // 2
    radius = size // 3

    for i in range(8):
        angle = (i / 8) * 2 * math.pi - math.pi / 2
        angle += (frame / frames) * 2 * math.pi

        x = center + int(radius * math.cos(angle))
        y = center + int(radius * math.sin(angle))

        # Fade based on position
        alpha = int(255 * (1 - i / 8))
        dot_radius = 4 - i // 3

        draw.ellipse(
            [x - dot_radius, y - dot_radius, x + dot_radius, y + dot_radius],
            fill=(100, 100, 255, alpha)
        )

    images.append(img)

images[0].save(
    output_path,
    save_all=True,
    append_images=images[1:],
    duration=80,
    loop=0,
    transparency=0,
    disposal=2
)

def create_confetti_gif(output_path, size=(128, 128), frames=20): """Create confetti celebration GIF.""" import random

# Generate confetti particles
particles = []
colors = [(255, 107, 107), (78, 205, 196), (255, 230, 109), (170, 111, 255)]

for _ in range(30):
    particles.append({
        'x': random.randint(0, size[0]),
        'y': random.randint(-size[1], 0),
        'speed': random.uniform(3, 8),
        'color': random.choice(colors),
        'size': random.randint(3, 6),
        'wobble': random.uniform(0, math.pi * 2)
    })

images = []

for frame in range(frames):
    img = Image.new('RGBA', size, (255, 255, 255, 0))
    draw = ImageDraw.Draw(img)

    for p in particles:
        # Update position
        p['y'] += p['speed']
        p['wobble'] += 0.3
        x_offset = math.sin(p['wobble']) * 10

        # Reset if off screen
        if p['y'] > size[1]:
            p['y'] = -10
            p['x'] = random.randint(0, size[0])

        # Draw particle
        x = int(p['x'] + x_offset)
        y = int(p['y'])
        s = p['size']

        draw.rectangle([x, y, x + s, y + s], fill=p['color'])

    images.append(img)

images[0].save(
    output_path,
    save_all=True,
    append_images=images[1:],
    duration=50,
    loop=0,
    transparency=0,
    disposal=2
)

Usage

create_spinner_gif("loading.gif") create_confetti_gif("celebration.gif")

Slack-Specific Optimization

Size Requirements

Use Case Max Size Recommended

Custom emoji 128x128 px 64x64 px

Message GIF 500 KB Under 200 KB

Profile image 512x512 px 256x256 px

Optimization Script

from PIL import Image import subprocess

def optimize_for_slack(input_path, output_path, max_size_kb=200): """ Optimize GIF for Slack file size limits.

Args:
    input_path: Source GIF
    output_path: Optimized output
    max_size_kb: Target max file size
"""
# Use gifsicle for optimization
subprocess.run([
    'gifsicle',
    '--optimize=3',
    '--colors', '64',
    '--lossy=80',
    '-o', output_path,
    input_path
])

# Check size and reduce further if needed
import os
size_kb = os.path.getsize(output_path) / 1024

if size_kb > max_size_kb:
    # Reduce colors further
    subprocess.run([
        'gifsicle',
        '--colors', '32',
        '--lossy=100',
        '-o', output_path,
        output_path
    ])

def resize_for_emoji(input_path, output_path, size=64): """Resize GIF for Slack emoji (maintaining animation).""" subprocess.run([ 'gifsicle', '--resize', f'{size}x{size}', '--optimize=3', '-o', output_path, input_path ])

Execution Checklist

• Identified GIF type (celebration, reaction, status)

• Selected appropriate creation method

• Created animation frames

• Verified smooth loop transition

• Optimized file size (< 200KB for messages, < 128KB for emoji)

• Tested visibility in light and dark modes

• Ensured work-appropriate content

• Uploaded to Slack workspace

Error Handling

Common Issues

Issue: GIF not animating in Slack

• Cause: Only one frame or corrupted file

• Solution: Verify multiple frames saved with save_all=True

Issue: File too large for emoji

• Cause: Too many frames or high resolution

• Solution: Reduce to 64x64, limit to 10-15 frames, use gifsicle

Issue: Transparency not working

• Cause: Missing transparency and disposal settings

• Solution: Add transparency=0, disposal=2 to save()

Issue: Colors look wrong

• Cause: Palette reduction too aggressive

• Solution: Increase color count in gifsicle or use dithering

Metrics

Metric Target How to Measure

File Size (emoji) < 128 KB File properties

File Size (message) < 200 KB File properties

Dimensions (emoji) 128x128 max Image properties

Frame Rate 10-15 FPS frame_count / duration

Loop Smoothness Seamless Visual inspection

Dependencies

Required packages

pip install Pillow moviepy

Optional for optimization

macOS

brew install gifsicle

Ubuntu/Debian

sudo apt-get install gifsicle

For video conversion

pip install ffmpeg-python

Best Practices

Design Guidelines

• Keep it simple: Slack GIFs are small, avoid complex details

• High contrast: Ensure visibility in both light and dark mode

• Smooth loops: End frame should transition to start frame

• Appropriate length: 1-3 seconds for reactions, up to 5 for celebrations

Technical Guidelines

• Frame rate: 10-15 FPS is sufficient

• Colors: Limit to 64-128 for smaller files

• Transparency: Use for irregular shapes

• Disposal: Use disposal=2 for transparency

Content Guidelines

• Work-appropriate: Keep it professional

• Inclusive: Avoid content that could exclude

• On-brand: Match company culture

• Clear meaning: The GIF's purpose should be obvious

Related Skills

• internal-comms - Team communications

• canvas-design - Static visual art

• algorithmic-art - Generative animations

Version History

• 2.0.0 (2026-01-02): Upgraded to v2 template - added Quick Start, When to Use, Execution Checklist, Error Handling, Metrics sections

• 1.0.0 (2024-10-15): Initial release with PIL/Pillow, moviepy methods, Slack optimization, celebration GIF templates