Every Draft You've Ever Written

In the era of AI-generated writing, proving that a piece of work is yours — that it evolved, that it grew, that it has a history — is becoming an unfortunate reality. Publishers, editors, and even legal disputes may one day hinge on whether you can demonstrate that your writing is yours, and that it changed over time the way real writing does. One way to do this is git, a version-control tool software developers have used for years.

What You Need

• A folder of writing files (plain text or Markdown works best, more on this below)
• Git installed on your computer (free)
• Optionally: a GitHub account (also free) to store your history in the cloud

Before we install git, a quick detour to explain what it is and what it does. If you’re already familiar, skip ahead to the next section.

Think of git as a logbook that sits invisibly alongside your writing folder. Every time you tell it to, it takes a complete snapshot of every file in that folder and stamps it with the date, the time, and a note you write describing what changed. These snapshots are called commits.

Unlike a backup, git does not just save the latest version. It saves every version you have ever committed, in sequence, forever — or for as long as you keep the folder. You can scroll back through the entire history of a manuscript like rewinding a film. You can see exactly what a chapter looked like six weeks ago. You can recover a paragraph you deleted in last year.

This is called version control. You may have jury-rigged a version of this for years — folders full of files named essay_FINAL_v2_REAL_THIS_TIME.docx (I use semantic versioning, with patch numbers for daily drafts, like screenplay title 1-1-1.fdx). Git does the same thing, but cleanly, automatically, and with timestamps.
For generative-AI-era writing specifically, git gives you something valuable: a dated, sequential paper trail of your creative process. A file that materializes fully-formed with no history might look like AI output. A file with fifty commits spanning months or weeks, showing a messy first draft evolving into a polished piece, looks like a human wrote it.

Do remember that git timestamps your history when you commit, not when you save the draft or do the actual work. So if you write all day but only commit once, you’ll only have a timestamped version as the file existed at commit.
And a note on file formats: git works with any file, but it works best with plain text.

If you work with .doc or .docx files, git will still track that the file changed, but it won’t be able to show you specific lines that changed the way it can with plain text (.txt) or a Markdown (.md) file. If you haven’t switched to writing in Markdown, now might be the time. Apps like iA Writer (the one I use personally), Ulysses, Obsidian, Highland Pro (which uses a screenplay-specific version of Markdown called Fountain) all use Markdown natively. If you’re committed (no pun intended) to Word or Pages, git still works — you just get less detail in your history.

Easiest Method: Github Desktop

Github Desktop is a free application that gives git a visual interface — no typing commands into a command line. This is the best starting point for most writers.

Setup

• Download and install GitHub Desktop
• Create a free account at github.com if you do not have one
• Open GitHub Desktop and sign in with your GitHub account

Creating a repository

In git, a tracked folder is called a repository, or repo for short. This is your writing project’s logbook.

1. In GitHub Desktop, click File > New Repository
2. Give it a name (e.g. my-novel or essays-2025)
3. For "Local Path," choose where on your computer to store it — or point it to a folder you already have
4. Leave everything else as default and click Create Repository

Your folder is now being watched by git, but nothing has been saved to history yet. For that, you need to make your first commit.

Making your first commit

1. Add your files to the folder you just created, or start a new file in it
2. Open GitHub Desktop and you’ll see your changed files listed on the left under Changes
3. At the bottom left, there is a text box that says “Summary (required)” — this is a commit message, and it’s stored with the version history you’re about to save
4. Write a short note describing the changes you’ve made: e.g., first draft of chapter one, opening graf, rough notes only, etc. You can provide a more detailed description if you like, but it’s not necessary.
5. Click Commit to main (main is the branch of your repository you’re using — branches are an advanced topic you can dig into here)

That’s all there is to it. Git has taken a snapshot of your file, and the date and time are recorded along with your commit message automatically.

Daily work with git

From here, your daily workflow shouldn’t be too difficult.

1. Write!
2. Open GitHub Desktop when you’re ready to make a commit
3. Review the changes shown (click on any file to see what’s changed)
4. Write a brief commit message
5. Click Commit to main

At a minimum, you should do this every time you finish a writing session. I commit anytime I get up from my chair, which is roughly every two minutes and 30 seconds — probably overkill for most of us. Just remember, the file snapshots are timestamped when you commit to git, not when you save the file and not continuously. If one of your goals is to create an evidence trail, a more balanced approach to committing — say every time you finish a major section — will probably be more helpful.

Another Method: Git via the Command Line

If you’ve never used the command line, it can feel intimidating. For our purposes, we only need five short commands and once they’re learned, they’re faster than using GitHub Desktop. The first step is to make sure git is installed.

Installing git

• Mac: Open Terminal and type git --version. If git is not installed, macOS will prompt you to install it automatically.
• Windows: Download Git for Windows, which installs both git and a terminal called Git Bash.
• Linux: Run sudo apt install git or the equivalent for your distribution.

Setting Up Your Identity

Git stamps every commit with a name and email so there’s a record of who made (git repositories are often shared by teams, who checkout and checkin the files they’re working on.) Run the following commands, filling in your personal details.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Creating a repository

Navigate to your writing folder in thermal. Example on a Mac or Linux machine:

cd ~/Documents/my-writing

Tip: drag the folder from Finder into the terminal window to auto-populate the correct folder path.

Then, initialize git:

git init

That’s it. Git is now watching this folder.

Two important git commands

When you’re ready to make a commit, run the following three commands one after the other.

git add .

This tells git to pay attention to everything that changed. The period means “all files” in the repository.

git commit -m "revised the ending of chapter one"

This takes the snapshot. The text inside the quotes is your commit message — write whatever is useful to help you identify the commit in the future.

Optional: pushing to GitHub

Everything so far lives only on your computer. You can push the files, along with the version history, to GitHub for an off-site archive. GitHub stores your git repository in the cloud, giving you a timestamped, off-site record of every commit. A commit on GitHub has a timestamp that GitHub's servers generate and cannot be retroactively altered.

From GitHub Desktop

1. After making at least one commit, click Publish repository in the top right
2. Give it a name and choose whether it should be public (anyone can see it) or private (only you) — private is likely the option you want
3. Click Publish Repository

From then on, after each commit, a button will appear in GitHub Desktop that says Push origin. Click it to sync your local commits to GitHub. Make this part of the habit: write, commit, push.

From the command line

Before you can push to GitHub via the command line, you need to create an empty repository on GitHub.com — don’t add any files to it to avoid merge conflicts. GitHub will show you a setup page — copy the commands under “push an existing repository.” They’ll look something like this:

git remote add origin https://github.com/yourusername/my-novel.git
git branch -M main
git push -u origin main

You only have to run those commands once. From then on, after you’ve used git add and git commit all you need is git push to send your changes to GitHub.

Some Suggestions

• Git and GitHub are not backup solutions. Yes, GitHub stores your files and version history in the cloud, but its primary purpose is version control. Still follow backup best-practices: keep a second local copy (using something like Time Machine) and a third, off-site copy via a dedicated backup service like Backblaze.
• Write commit messages that will be meaningful in the future: drafted final scene between Ryan and Jane will probably be more useful than updates
• Commit often. Certainly don’t wait until a draft is “good enough” to commit — the point is to establish an evidence trail that shows an evolving piece of work.

There’s no foolproof way to prove your writing is yours — even version-control histories can be faked or generated by large language models. But, combined with other forms of evidence, having a history of your work as it progressed can go a long way toward successfully fending off false accusations.

Ideally, the apps we use will start to build version control into their interfaces — many coding apps already do, and if you’re a screenwriter Arc Studio Pro has a robust version control and branching system. Until then, git is an easy, free solution.