Technical Writing Needs Attention

Rakesh — Fri, 20 Feb 2026 06:39:04 +0000

Introduction

Usually, programming tutorials and research papers have been a bit difficult to understand.

Not because the code is complicated, but because the attention shifts between the text and its explanation.

When someone presents a technical article, the author knows which line matters at each moment but readers might not.

We use static artefacts, diagrams, images or even screenshots to explain. This includes:

Blog Posts
Research & Documentation
Code Snippets

But programming is not static.

When a function is executed, the data flows and state keeps changing.

So when we explain these ideas, we freeze everything into a screenshot.

Real Problem

Consider a simple explanation in a blog.

We paste a block of code, then the explanation refers to parts of it.

Now the reader has to

scroll up/down
remember previous lines
mentally simulate execution

To avoid this, authors often repeat code blocks, shrink snippets and/or split explanations.

This is hard work for both writers and readers.

Code execution is a SEQUENCE
Documentation is a SNAPSHOT

This gap is where the friction lives.

Experiment

So I tried a small experiment. What if documentation was a not a page but a timeline?

Instead of describing what the program does, what if we rendered the explanation?

I built a CLI tool that generates a video directly from text script.

No Screen Recording
No Video Editor

Just a script

I called it Rustimate - an animation engine written in Rust.

DSL

Here's how the script looks like

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

Comparison

This is how a traditional explanation looks like:
There is absolutely nothing wrong with this format and this is how all of us learn programming or consume technical content.

But in this format, the reader needs to manually connect explanation and execution.

Here's the same concept rendered as a short guided sequence:

This is not a recording. Rustimate renders the editor itself and guides attention, showing exactly which line matters, and at the moment at which it matters.

The information did not change, only the medium/format did.

The video does not replace the article, it syncs the reader's attention. After watching a guided explanation, the code is no longer unfamiliar.

What Rustimate is (and is not)

Rustimate is not an AI tool.

It does not generate any code
It does not summarize documentation.

It helps guide attention. You describe how understanding should unfold and the engine will turn it into a video.

Who is this for

This could help -

Educators explaining code and algorithm
Developers writing tutorials and blogs
Scientists and Researchers presenting ideas
Technical YouTube creators

Not to replace writing but to complement it with motion.

Philosophy

Programming sits between logic and explanations. We have powerful languages for building software, but most of our teaching still relies on static pages and screenshots.

Rustimate is my attempt to explore this missing gap - A medium between code and storytelling.

Conclusion

This is still in early stages. I am not presenting it as a finished product but as an idea I am testing.

If it resonates with you then I would genuinely like to hear your thoughts. Thank you!

References

Website: Rustimate
Original Article: Doc2Quarto

DEV Community: Rakesh