Why Every Textsmith Should Learn Git
Ishe Chinyoka
- 5 minutes readTable of Contents
There is a moment in almost every textsmith’s journey when Git appears.
Usually it arrives wearing a programmer’s uniform.
It speaks of repositories, commits, branches, merges, pull requests, remotes, and hashes. It seems to belong to software developers working on enormous code bases—not to someone writing articles, maintaining documentation, or collecting configuration files.
Many writers take one look and quietly walk away.
That is unfortunate, because Git may be one of the most valuable tools a textsmith can learn.
The secret is simple: Git does not really care whether the text it stores is source code, Markdown, HTML, LaTeX, Typst, configuration files, or a novel. To Git, they are all just text.
And that is precisely why every textsmith should understand it.
Git Is About History
One of the greatest frustrations in digital writing is deciding what to do with old versions.
Almost everyone has created files that look something like this:
- article-final.md
- article-final2.md
- article-final-revised.md
- article-final-revised-final.md
- article-final-real-final.md
The computer faithfully stores every copy.
The human eventually forgets which one is the correct version.
Git solves this problem by recording the history instead of creating endless copies.
Each meaningful change becomes a commit—a snapshot of your work accompanied by a short explanation of what changed.
Instead of asking yourself which file is the newest, you simply ask Git.
It remembers.
Writing Is Revision
Good writing is rarely produced in one sitting.
We remove paragraphs.
We rewrite introductions.
We experiment with different titles.
Sometimes we discover that yesterday’s version was actually better than today’s.
Without version control, those older ideas disappear.
With Git, they never truly vanish.
Every revision becomes part of the story of the document.
You gain the confidence to experiment because you know that nothing important is permanently lost.
Ironically, version control encourages creativity by making failure inexpensive.
Your Configuration Files Are Also Writing
In this post, we explored the joy of dotfiles.
Configuration files are simply another form of writing.
They describe how your computer should behave.
Whether it is your shell prompt, your Vim settings, your terminal emulator, your window manager, or your Git configuration itself, these files represent hundreds of small decisions accumulated over years.
Losing them often feels like losing a part of your workflow.
Git gives those decisions a memory.
Every improvement becomes documented.
Every mistake becomes reversible.
Every experiment becomes safe.
After enough years, your repository becomes a diary of how your computing environment evolved.
Git Makes Computers Reproducible
One of the great promises of plain text is reproducibility.
If your work lives in text files, then it can be copied, backed up, synchronized, searched, and understood almost anywhere.
Git extends this philosophy.
Instead of merely backing up your files, it preserves their evolution.
A new laptop no longer means beginning from scratch.
A system reinstall becomes far less intimidating.
You simply retrieve your repository and your carefully crafted environment begins to reappear.
Your computer starts to feel less like a collection of installed software and more like a project that you maintain.
Collaboration Without Chaos
Many textsmiths eventually collaborate.
Perhaps you write documentation.
Perhaps you maintain a knowledge base.
Perhaps several people edit the same website.
Without version control, collaboration often becomes an exchange of files through email or messaging applications.
Conflicts become difficult to resolve.
Nobody knows whose copy is authoritative.
Git provides a shared history.
Everyone contributes to the same project.
Changes are recorded.
Authors are identified.
Mistakes can be undone.
Even when working alone, these capabilities are surprisingly reassuring.
Git Rewards Small Improvements
One of Git’s most valuable lessons has little to do with software.
It teaches incremental progress.
Instead of waiting until everything is perfect, you save meaningful milestones along the way.
Each commit becomes a promise:
“This version works.”
Weeks later, you can retrace your thinking one step at a time.
The history tells the story of how an idea matured.
For a textsmith, that history is often as valuable as the finished document itself.
You Don’t Need to Become a Software Engineer
Learning Git does not require becoming a programmer.
Many textsmiths use only a surprisingly small collection of commands:
- initialize a repository;
- check what changed;
- save a snapshot;
- review history; and
- synchronize with a remote backup.
That modest knowledge already provides enormous value.
Everything else can be learned gradually as your projects become more sophisticated.
Git rewards curiosity rather than demanding mastery from the beginning.
A Tool Worth Carrying
Textsmiths already understand the value of plain text.
We trust it because it lasts.
We value it because it is portable.
We prefer it because it remains understandable decades later.
Git complements those same ideals.
It preserves not only our documents but also the journey that produced them.
If plain text is the foundation of digital craftsmanship, then Git is the archive that protects it.
Every textsmith should learn to write.
Every textsmith should learn to revise.
And every textsmith should learn to preserve that revision history.
Git makes all three part of the same craft.
The Textsmith’s Take
Plain text gives your work permanence.
Git gives your work memory.
Together, they transform a collection of files into a living record of your craft.