Technical Writing Needs Attention

Source: Dev.to

Introduction

Programming tutorials and research papers are often difficult to understand—not because the code is complex, but because the reader’s attention shifts between the text and its explanation. An author knows which line matters at each moment, but readers may not. We typically rely on static artifacts—diagrams, images, screenshots—to explain concepts in blog posts, research documentation, and code snippets.

However, programming is not static. When a function runs, data flows and state changes. To explain these ideas, we freeze everything into a screenshot. A typical blog explanation might:

1. Paste a block of code.
2. Refer to parts of that code in the surrounding text.

The reader then has to scroll, remember previous lines, and mentally simulate execution. Authors often repeat code blocks, shrink snippets, or split explanations, which is hard work for both writers and readers.

The Gap

Code execution is a sequence, but static documentation provides only a snapshot. This mismatch creates friction for readers.

Experiment: A Timeline for Documentation

What if documentation were not a page but a timeline? Instead of describing what the program does, we could render the explanation as a guided sequence.

I built a CLI tool that generates a video directly from a text script—no screen recording, no video editor. The tool, called Rustimate, is an animation engine written in Rust.

Example Script

scene "example" {
  mode: editor
  editor: neovim
  animation: typewriter
  code {
    file: "main.rs"
    lines: 8..12
    highlight: [10]
  }
}

In a traditional explanation, the reader must manually connect the text and the execution. With Rustimate, the same concept is rendered as a short guided sequence that:

• Renders the editor itself.
• Guides attention to the exact line that matters at the exact moment.
• Keeps the information unchanged while changing the medium.

The video does not replace the article; it synchronizes the reader’s attention. After watching a guided explanation, the code feels familiar.

How Rustimate Works

• Not an AI tool – it does not generate code.
• Guides attention – you describe how understanding should unfold, and the engine turns it into a video.

Potential Use Cases

• Educators explaining code and algorithms.
• Developers writing tutorials and blogs.
• Scientists and researchers presenting ideas.
• Technical YouTube creators.

Rustimate is intended to complement writing with motion, not replace it.

Conclusion

Programming sits between logic and explanation. While we have powerful languages for building software, most teaching still relies on static pages and screenshots. Rustimate explores the missing gap—a medium between code and storytelling.

The project is in early stages; it is presented as an idea under testing. If it resonates with you, I would genuinely like to hear your thoughts.

Website: Rustimate
Documentation: Doc2Quarto