I have been working in the industry for a few years now, and if there is one tool that has been universally helpful across every role—from my time at NASDAQ to my current work as a Distribution Engineer at GitLab—it’s Git.
It’s elegant, it’s distributed, and to be honest, it’s practically perfect!
But things are changing.
With the AI era kicking into full gear, the number of commits a team makes today has scaled to a level we never imagined. Tools like Claude and OpenAI are helping us ship code and products at an incredible rate. It’s an exciting time to be in the IT industry, but this hyperspeed delivery brings a massive, often unspoken problem: Context Amnesia.
The Problem 😵💫
Imagine this: You're working on a complex feature—maybe deploying an API gateway or upgrading a critical package. You grind it out on a Friday, commit your code, and take the weekend off. When you come back, or take a five-day vacation, both you and your brain have completely lost the context of what you were doing.
Your only source of truth is the code. You have to sift through multiple git diffs and read through commit messages just to remember why you made a specific change.
When you scale this up to a team environment, it gets worse:
The Reviewer Burden: It is incredibly difficult to explain every line of change to a reviewer. Making the "perfect" git commit message takes time that developers frankly don't want to spend.
The Documentation Gap: Writing release notes and documentation is not a task most developers enjoy.
The Business Disconnect: There is a massive wall between Git and the business side of a product. The business folks don’t understand code (nor should they), but they struggle to understand what features are getting shipped, what is delayed, and what is happening on the engineering floor.
I wanted to shatter this glass wall. I wanted a system that prevents developers from losing context, makes reviews a breeze, and allows the business to see exactly what is being built in plain English.
Enter Git-Chacha 🦸♂️
To solve this, I built Git-Chacha.
It's an LLM-powered storyteller for your Git commits. It is a lightweight Golang binary that sits on your Git pre-hooks. You do your work normally, and as soon as you hit git push, Git-Chacha intercepts it and does the heavy lifting.
You can check out the complete repository: Here.
The Architecture 🏗️
Privacy and security are my top priorities. You shouldn't have to send your proprietary company code to a public API. Because of this, Git-Chacha is designed to run entirely locally using Ollama (you can plug in Mistral, Llama 3, or any open-source model of your choice).
Here is the step-by-step execution path:
Local Pre-Hook:
Once you install the Go binary, it triggers automatically on a git push.AI Summarization:
The CLI extracts all the git diffs from your recent commits and sends them to your local Ollama service. It asks the LLM to act as a senior software developer and to summarize exactly what changes were made and, more importantly, WHY.Developer Intent Branch:
Before the push completes, my CLI opens a terminal editor (like Vim or Nano) showing you the AI's generated intent.
Example: "This commit upgrades the PostgreSQL version from 17.9 to 18.3 to maintain compatibility in the build environment..."
You can edit this summary or approve it as-is.
Once approved, Git-Chacha saves this summary as a JSON file and pushes it to a completely separate, isolated branch named after you (e.g., kitarp29_intent). Your actual code files are never touched. This intent branch strictly tracks the metadata and rationale behind your code.
- CI/CD Master Narrative: This is where the magic happens for the entire team. Suppose 10 developers are merging their feature branches into main. I created a Python-based CI pipeline that triggers on merge.
It dives into the developer-intent branches, gathers context from commit SHAs, and uses an LLM in the CI runner to compile a "Master Intent." Suddenly, every change on your master branch has a human-readable story attached to it.
The business side can simply query this Master Intent branch with an LLM to generate an instant 30-day report of what the engineering team has accomplished, linking back to specific work items.
Seeing it in Action 🚀
If you like you can watch my session from Foss-in-the-north on Youtube : Here
Using it feels completely natural. During my testing with a CNG project, I simulated a routine PostgreSQL upgrade.
I made my changes to the config files and typed:
git commit -m "upgrading PG version"
Normally, that's where the context ends. But with Git-Chacha, when I hit git push, the CLI pops up. The local LLM had already read my diffs and produced a brilliant summary explaining not just the version bump, but the potential compatibility effects on third-party extensions. I hit save, and within seconds, a kitarp29_intent branch was updated on GitLab with a clean JSON file documenting my exact mindset at that moment.
Note: I have set a default 90-day retention policy for these intent files so your repository doesn't bloat over time!
The Future Scope 🌱
I built this to be as flexible and open-source as possible. Any team can integrate OpenAI, Claude, or Gemini if they already have enterprise agreements. Moving forward, I am looking to:
Embed Issue Tracking: Automatically linking Jira or GitLab issues directly inside the generated intent JSON.
Smart Redundancy: Bypassing the AI summarization for trivial changes like simple README.md formatting to save compute time.
Token Optimization: Refining the prompts to reduce token usage, keeping costs down when running the CI pipeline models.
Master Intent Monitoring: Ensuring hallucinations or weird formatting don't make their way into the final master narrative.
If you are tired of losing track of your own code or spending hours justifying diffs in code reviews, give it a spin.
If you liked this content, you can follow me or DM me on Twitter at kitarp29 for more!
Thanks for reading my article :)