Local Git Repositories: The Baseline for AI-Era Writing

Jun 11, 2026

Setting the Stage: Context for the Curious Book Reader

Context for the Curious Book Reader

This entry explores the foundational step of establishing private, local Git version control. It represents an important methodology for securing your personal digital record and thinking out loud before committing work to public platforms or AI-driven agentic pipelines. By grounding your writing in simple, owned text files, you build a resilient baseline that remains compatible with emerging automated tools.

Technical Journal Entry Begins

MikeLev.in: Alright, let’s get down to business. We’re about to start a new Jekyll blog under Pipulate specifically for a work blog. Even with all the other places for data such as Confluence, Google Docs, Slack and generally spread throughout creation aggravating that left-hand / right-hand problem. So why yet another place? Because I “own” it. Because it’s my master place to record all things Botify-related in a reverse chronological blogging order just like I do now currently for each client, for myself, for my technical journal that feeds the public raw ore to be mined for my Future-proofing in the Age of AI book that’s really always a work-in-progress, never-finished, always-finished performance art piece that you can knit into your own book today.

Everything’s there. Just point something at AI_CONTEXT.md and say “Go make a book”. Everything is there for anyone who wants to pay the tokens for the rid. Today’s models are plenty smart to do this, but it’s going to be very expensive token-wise with lots of intermediary steps to “distill” long articles into things that will fit into context windows. I already made all these little JSON files-per-article that does that from my end, and the capacity to do that with any Jekyll blog is baked into Pipulate. This makes the ability to have really fabulous overarching “big story” context in-context a cinch.

As is the whole drill-down process to any part of that story you might be interested in. That’s the forest and trees aspect of context. You don’t always need the 40K-foot bird’s eye forest in context with every little code-patch you need to produce, but it does help. That first setting absolute positioning in a relative world is important. You need your anchors and that file provides at a relatively small token cost not only the overarching story anchor but the drill-down ability for anything further.

Establishing Your Own Context Anchor

Okay, I have to keep myself from rambling because I’m circling a new era of client-work performance right now where I use this vim/NeoVim mad scientist ability to document processes like John Henry in a race with a steam engine that’s learning how to do is job nipping at his heels. The Little Engine that Could document everything he ever did for the sake of thinking out loud first. It’s an idea-processing thing. If you can think it out loud in your mind to yourself, it can flow through your fingers and into a digital record without hardly thinking.

And the format that happens is is Markdown files with YAML front-matter, which is the exact same format of all the new Anthropic-spearheaded agentic framework conventions of AGENTS.md and SKILL.md. See? Old school Jekyll blogging like a hacker and making the configuration files for modern AI agentic frameworks is the exact same things. The details of what’s in the YAML-headers and in the markdown may change, but the muscle memory to manipulate either or any of these is precisely the same. Tastemasters as the future? Okay, maybe. But vim-masters, for sure. That’s the seat of power. Editing text-files like riding a bicycle.

The Power of Muscle Memory and Markdown

So I need to demonstrate that to Botify. This first one will be done out in public, but after that there’s a split-off blog; one of the many N-blogs you can manage under Pipulate. Let’s stamp out a template so that I can get started with today’s work…

No! There’s just not time for it. I’m going to sanitize the client work as I go and talk about it right here. I’ll start keeping it in a parallel file that will turn into the… okay. Alright. Minimal template. Just a place to store stuff. The identity will be very simple: ~/repos/botifyml/ standing for both a Botify ML system and Botify data in YML format. Okay, that’s a good, strong identity that if I allow other people to have live on their own machines won’t come across as just another mysterious /botify/ folder, which was first inclination. No branding for the thing. But we need that tiniest little amount.

Alright, wanna know why I call things around here the Grimoire. It’s because of patterns like this. Want a private git repo and you don’t know where you’re going to keep it yet, but you know that it’s not on GitHub? Here’s how:

(sys) repos $ mkdir botifyml
(sys) repos $ cd botifyml/
(sys) botifyml $ touch blog.txt
(sys) botifyml $ mkdir -p ~/git-repos/botifyml.git
(sys) botifyml $ cd ~/git-repos/botifyml.git/
(sys) botifyml.git $ git init --bare
Initialized empty Git repository in /home/mike/git-repos/botifyml.git/
(sys) botifyml.git $ cd ~/repos/botifyml/
(sys) botifyml $ git init
Initialized empty Git repository in /home/mike/repos/botifyml/.git/
(sys) botifyml $ git add blog.txt 
(sys) botifyml $ git commit -am "My first commit"
[main (root-commit) a8063db] My first commit
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 blog.txt
(sys) botifyml $ git remote add origin ~/git-repos/botifyml.git/
(sys) botifyml $ git push -u origin main
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 214 bytes | 214.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To /home/mike/git-repos/botifyml.git/
 * [new branch]      main -> main
branch 'main' set up to track 'origin/main'.
(sys) botifyml $ 

That gives me an amazing place to work. I get instant ability to have my work in 2 places on my machine and get all that infinite branching and undo of git. It doesn’t give you collaboration or an off-site backup like it being in GitHub would, but this is one of the greatest 80/20-rule solutions in all of tech, and should almost always be step number 1 when you’re doing anything that feels like “start a new repo” but you’re not willing to put any of it on GitHub or off-site in any other way either until you fully thought though the issues.

Setting Up a Bare Git Repository

But you still need Git, pronto!

And now I simply put the magic line over in that file:

(sys) botifyml $ vim blog.txt 
(sys) botifyml $ git status
On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   blog.txt

no changes added to commit (use "git add" and/or "git commit -a")
(sys) botifyml $ git diff
diff --git a/blog.txt b/blog.txt
index e69de29..5944078 100644
--- a/blog.txt
+++ b/blog.txt
@@ -0,0 +1 @@
+# Beginning of Notes
(sys) botifyml $ git commit -am "The anchor for the blogging macro added"
[main 2b08fa5] The anchor for the blogging macro added
 1 file changed, 1 insertion(+)
(sys) botifyml $ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 284 bytes | 284.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To /home/mike/git-repos/botifyml.git/
   a8063db..2b08fa5  main -> main
(sys) botifyml $ 

See how easy that was? These are the baseline git skills you want to have to make yourself future-proofed in the age of AI. This is table-stakes. And now I have a place to write freely, backed up with all the confidence I’ll be able to drop in the Jekyll blog templating and scaffolding to make it a real Jekyll blog and plant it somewhere with work’s Google Workspace login context.

And that’s where I cut this article so I can hop over there and start the work blog!

Book Analysis

Ai Editorial Take

What stands out is how the author frames basic text editing and local version control not as legacy technical debt, but as the ultimate power seat for steering complex AI workflows. It reframes standard terminal muscle memory as modern agency, proving that simple tools often provide the sturdiest anchors.

Own your writing workflow! Setting up a local bare Git repository is an important, easy way to anchor your thoughts and prepare your files for AI agents. Read the guide: https://mikelev.in/futureproof/local-git-baseline-ai-workflow/ #Git #Markdown #FutureOfWork

Title Brainstorm

Title Option: Local Git Repositories: The Baseline for AI-Era Writing
- Filename: local-git-baseline-ai-workflow.md
- Rationale: Highlights the practical aspect of using Git as a foundational skill for AI compatibility.
Title Option: Owning Your Text: The Git and Markdown Way
- Filename: owning-text-git-markdown-way.md
- Rationale: Focuses on the personal ownership of text files and the muscle memory of Jekyll and Markdown workflows.
Title Option: Before the Agent: Building Your Private Knowledge Base
- Filename: private-knowledge-base-before-agents.md
- Rationale: Pitches the local setup as an essential precursor to feeding modern agentic frameworks like AGENTS.md.

Content Potential And Polish

Core Strengths:
- Clear, hands-on demonstration of bare Git repository creation for immediate local backups.
- Relatable analogy of thinking out loud as a seamless, high-velocity idea-processing method.
- Insightful connection between old-school Jekyll blogging conventions and modern AI agentic configuration files.
Suggestions For Polish:
- Correct the typo ‘thought though the issues’ to ‘thought through the issues’ in the final paragraphs.
- Elaborate briefly on why a bare repository is preferred for local-only setups to assist version-control beginners.

Next Step Prompts

Draft a guide explaining how to hook this local git repository into an automated, encrypted remote backup workflow.
Create a sample template for AGENTS.md that mimics the structure of the Jekyll YAML front matter discussed in this article.