I've been experimenting with a small skill called visual-flow-gif.

It does one thing: takes a complex article, process description, or architecture sketch, and turns it into an animated GIF system diagram.

For this demo I used Jason's Loop Engineering article. It describes a support loop that fires every 30 minutes, processes support tickets, logs friction, generates signals, triggers PRs and tasks, then feeds results back into the next cycle.

Reading the text alone, the concept takes a while to click.

But once you render it as an animated diagram, you see directly:

  • How data flows
  • Which components participate
  • How the loop connects
  • Where signals originate
  • Where shared artifacts live
  • How results feed back into the next iteration

That's the problem this skill solves: extract the hidden system structure inside an article and make it visible as an animated flow.

It doesn't just ask the AI to draw a picture.

The pipeline looks like this:

article
-> extract system structure
-> write JSON spec
-> render with Python + Pillow
-> add animation overlay
-> export GIF

First the AI extracts structure from the article:

  • nodes
  • arrows
  • labels
  • colors
  • animation paths
  • feedback loops

Then it generates a JSON spec.

The JSON spec is the blueprint for the diagram. It describes which nodes exist, their positions, how arrows connect them, and which paths get animated.

A local Python renderer handles the actual drawing.

The renderer uses Pillow to draw:

  • Blackboard-style background
  • Node boxes
  • Arrows
  • Titles
  • Section dividers
  • Text labels
  • Rounded connector lines

A final animation overlay gets composited on top.

This overlay moves green light particles along the arrows. Some modules get a subtle pulse effect.

Static frames explain the structure. Animation explains the flow.

I think this pattern works well for explaining:

  • Agent loops
  • Memory systems
  • Data pipelines
  • Eval pipelines

Most articles aren't hard to read because the writing is bad. They're hard because a system is hiding inside the text.

If you can extract that system structure and show how it runs as a GIF, comprehension gets much faster.

This version is still experimental, but it can run the full demo end-to-end.

Usage

In your agent session, type:

visual-flow-gif <paste your article or process description here>

The skill reads the content, extracts the system structure, generates the JSON spec, renders the diagram, and exports the GIF. You get the output file path when it finishes.

Install

Once you have the skill package:

mkdir -p "$HOME/.agents/skills"
unzip visual-flow-gif.zip -d "$HOME/.agents/skills/"
pip install Pillow

Test

python "$HOME/.agents/skills/visual-flow-gif/scripts/render_animated_gif.py" \
  --spec "$HOME/.agents/skills/visual-flow-gif/assets/default-spec.json" \
  --outdir /tmp/visual-flow-gif-test \
  --basename sample \
  --verify \
  --check

You see "ok": true, you're good to go.