Preface¶

Sending an animated GIF in Slack often conveys emotion far better than long blocks of text—whether you’re celebrating a launch, complaining about a bug, or replying with “got it.” But when you set out to make your own GIF, questions quickly arise: What dimensions should I use? Will a high frame rate make the file too large? Will Slack compress it into a blurry mess once uploaded?

Scattered Slack GIF guidelines exist online, but few have been packaged into a reusable workflow. Anthropic’s official Skills repository offers an Agent Skill called slack-gif-creator: it encapsulates Slack’s dimensional and frame rate constraints, Python plotting toolchains, and common animation concepts into SKILL.md. This lets AI coding assistants follow a consistent standard when you ask them to “make me a GIF for Slack,” rather than figuring it out from scratch every time.

This article, based on verified materials from the official repository, explains what this Skill is, how to install it, and its typical use cases.

What It Is¶

slack-gif-creator is an Agent Skill maintained by Anthropic, with its source code located in the skills/slack-gif-creator/ directory of the anthropics/skills repository.

Its positioning is clear: it provides knowledge and tools for creating animated GIFs optimized for Slack, rather than being a closed template library that lets you generate images with a single click. The Skill documents Slack’s recommended dimensions and parameters, includes Python modules like GIFBuilder for assembling frames, validators for validating output, easing for easing functions, and frame_composer for frame helpers, and guides Agents to draw animations frame by frame using PIL (Pillow) primitives.

The frontmatter of the official SKILL.md reads: “Knowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts.” When a user makes a request like “make me a GIF of X doing Y for Slack,” the Agent should automatically match and enable this Skill.

Key Slack GIF Constraints¶

One of the Skill’s core values is organizing Slack’s common requirements into a directly referenceable parameter table:

Dimensions:
- Custom Emoji GIF: Recommended 128×128 pixels
- In-message GIF: Recommended 480×480 pixels

Parameter Recommendations:
- Frame rate (FPS): 10–30 (lower values typically result in smaller file sizes)
- Number of colors: 48–128 (fewer colors reduce file size)
- Duration: Emoji GIFs should be kept under 3 seconds

The repository’s core/validators.py also implements validation logic: Emoji mode checks if the image is square and if its side length is between 64–128 (with 128×128 being optimal); message GIF mode checks the aspect ratio and side length range. A compression prompt is given when the file exceeds approximately 5 MB.

Core Features and Highlights¶

1. GIFBuilder: Assemble and Optimize per Slack Standards¶

core/gif_builder.py provides the GIFBuilder class, which handles frame-by-frame collection, global palette quantization, optional deduplication, and final GIF export. A typical initialization pattern:

from core.gif_builder import GIFBuilder
from PIL import Image, ImageDraw

builder = GIFBuilder(width=128, height=128, fps=10)

for i in range(12):
    frame = Image.new('RGB', (128, 128), (240, 248, 255))
    draw = ImageDraw.Draw(frame)
    # Draw each frame using PIL primitives
    builder.add_frame(frame)

builder.save('output.gif', num_colors=48, optimize_for_emoji=True)

The save() method supports several practical switches:
- optimize_for_emoji=True: Automatically resizes to 128×128, limits the number of colors, and drops frames when necessary
- remove_duplicates=True: Removes nearly identical consecutive frames to reduce file size
- num_colors: Controls the number of colors after quantization

2. Validators: Self-Check Before Export¶

from core.validators import validate_gif, is_slack_ready

passes, info = validate_gif('my.gif', is_emoji=True, verbose=True)

if is_slack_ready('my.gif'):
    print("Ready for Slack!")

The validation outputs information including dimensions, file size, frame count, duration, and FPS, helping you avoid non-compliance issues only after uploading.

3. Easing and Frame Composer: Make Animations More Natural¶

core/easing.py provides interpolate(), which supports easing functions like linear, ease_in, ease_out, ease_in_out, bounce_out, elastic_out, and back_out for non-linear changes such as displacement and scaling.

core/frame_composer.py encapsulates common drawing helpers for blank frames, gradient backgrounds, circles, text, pentagrams, and more, reducing repetitive boilerplate code.

4. Animation Concept Guide¶

The Skill documentation systematically organizes implementation ideas for common effects including Shake, Pulse, Bounce, Spin, Fade, Slide, Zoom, and Explode, and emphasizes improving visual appeal using thicker lines (width=2 and above), gradient backgrounds, layered overlays, and other techniques.

5. Design Philosophy: Flexible, Not Template-Based¶

The official documentation explicitly states that this Skill does not provide:
- Fixed animation templates or pre-built graphic libraries
- Unreliable cross-platform Emoji font rendering
- Built-in asset packs

What it provides is knowledge + tools + freedom to draw with PIL. If a user uploads an image, the Agent should determine whether to use it directly for the animation or only use it as a style reference, then load and process it with PIL.

Installation and Activation¶

slack-gif-creator follows the universal Agent Skills format (SKILL.md + resource directory) and can be used in a variety of AI coding tools. The following methods come directly from the official documentation; choose one based on your chosen tool.

Dependency Installation¶

The Skill directory includes a requirements.txt file, with the main dependencies being:

pip install pillow imageio numpy
# Or navigate to the skill directory first:
pip install -r requirements.txt

requirements.txt also lists imageio-ffmpeg>=0.4.9 for imageio to handle related media formats.

Use in Cursor¶

Cursor automatically discovers Skills in the project or user directory. Copy the official directory to your project:

git clone https://github.com/anthropics/skills.git
cp -r skills/skills/slack-gif-creator .cursor/skills/slack-gif-creator

You can also place it in ~/.cursor/skills/ for a global Skill. Ensure the directory name matches name: slack-gif-creator in the SKILL.md frontmatter. Afterwards, describe your Slack GIF request in an Agent conversation, or explicitly call /slack-gif-creator, and the Agent will load the corresponding instructions and core/ tool code.

Use in Claude Code¶

Anthropic’s official README provides Plugin-based installation steps for the sample Skills collection:

/plugin marketplace add anthropics/skills
/plugin install example-skills@anthropic-agent-skills

slack-gif-creator is part of the sample Skill collection covered by the example-skills plugin. After installation, you can directly describe your needs in Claude Code, for example: “Use the slack-gif-creator skill to make a bouncing checkmark GIF for Slack emoji.”

Use in Claude.ai and Claude API¶

According to the anthropics/skills repository, some sample Skills are now available for Claude.ai paid plans; refer to Using skills in Claude for how to upload and enable custom Skills. When using the Claude API, refer to the Skills API Quickstart to upload or reference the Skill.

Typical Usage Examples¶

Scenario 1: Have the Agent generate an Emoji GIF using natural language¶

After enabling the Skill, you can directly provide a prompt like:

Make me a 128×128 Slack Emoji GIF: a green checkmark bounces in from the top and shakes slightly, with a duration of about 1.5 seconds. Use the validators to check compliance with Slack requirements before exporting.

The Agent will follow the constraints in the Skill to select dimensions and FPS, draw frame-by-frame using PIL, call GIFBuilder.save(..., optimize_for_emoji=True), and finally output a validation report using validate_gif().

Scenario 2: Create a frame animation based on a user-uploaded image¶

The Skill guides the Agent to load the user’s image using PIL first:

from PIL import Image

uploaded = Image.open('file.png')
# Use directly for animation, or extract colors/styles as a reference

Then, based on the user’s intent, decide whether to “split this image into a frame animation” or “redraw in its style.”

Scenario 3: Optimization strategies when file size reduction is required¶

When a user explicitly asks to reduce the file size, the Skill recommends trying the following steps in order:

Lower the FPS or shorten the duration
Reduce the number of colors (e.g., num_colors=48)
Shrink the dimensions (128×128 is preferred for Emojis)
Enable remove_duplicates=True
Use optimize_for_emoji=True for Emoji scenarios

builder.save(
    'emoji.gif',
    num_colors=48,
    optimize_for_emoji=True,
    remove_duplicates=True
)

Applicable Scenarios and Notes¶

Who This Is For:
- Developers who communicate regularly on Slack and need to quickly create team Emojis or reaction GIFs
- Teams looking to standardize “Slack GIF specifications + Python plotting workflows” into their AI workflows
- Scenarios where GIFs need to be batch-generated, validated, and then uploaded to Slack in CI or scripts

Important Notes:
- This is a Skill (instructions + tools), not a standalone GUI application; the actual drawing logic is still written by the Agent using PIL code, and the result depends on the clarity of your prompt
- The official README notes that the Skills in this repository are for demonstration and educational purposes only; thoroughly test them before using in production environments
- The Skill does not include pre-made assets; complex visual effects require more detailed visual descriptions or reference images
- The validator primarily checks dimensions and basic metadata; actual uploads to Slack may still be affected by workspace policies or network conditions. It is recommended to test the exported GIF in your target Slack workspace first.

Summary¶

slack-gif-creator is a niche but extremely practical Agent Skill: it packages Slack’s GIF constraints for dimensions, frame rate, color count, and duration, along with Python toolchains and animation concepts, into a repeatable playbook for AI assistants. You no longer need to look up “128 or 480” in documentation every time, or manually trial-and-error file sizes—let the Agent generate, validate, and optimize according to the Skill.

Official address: https://github.com/anthropics/skills/tree/main/skills/slack-gif-creator

# Slack-GIF-Creator: Let AI Help You Make GIFs Compliant with Slack Specifications