Building gwatch, a Realtime Git Terminal UI
Disclosure: This project was almost completely made with AI. This was my first time using Rust, and I’m in no way proficient in it yet, but it was a great way to learn while shipping something useful.
gwatch is a read-only realtime terminal UI for monitoring Git working-tree changes. It monitors a repository as files change, displays live file status, renders diffs in the terminal, supports hunk navigation, and is designed to handle large diffs without making the interface difficult to use.
Source code: github.com/connorcarro/gwatch
Why I wanted it
When I am working on code, I usually have a few terminal panes open: one for the dev server, one for commands, and one for checking Git status or diffs. The problem is that git status and git diff are snapshots. They are useful, but I still have to keep rerunning them while I work.
I wanted something that felt more like a live dashboard for the working tree. Not a Git client that edits history, stages files, or performs risky actions. Just a focused terminal UI that keeps showing what changed as I work.
That became gwatch.
What it does
The main idea is simple: monitor a Git repository and keep the terminal view updated in real time.
The interface shows the changed files in the working tree, lets me move through them, and displays the selected file’s diff. From there, I can navigate between hunks and inspect exactly what changed without repeatedly typing Git commands.
The project is intentionally read-only. It does not stage, commit, discard, checkout, or rewrite anything. That was important because the tool is meant to sit next to normal development work without becoming another place where destructive Git operations can happen by accident.
Large diffs
One part I cared about was large-diff support. A terminal UI can feel good with small changes and then completely fall apart when a generated file, lockfile, or big refactor appears.
gwatch is built around the idea that large diffs should stay navigable. Instead of making the whole interface unusable, the tool keeps the file list, status view, and hunk navigation useful so I can still understand what is happening in the repository.
Building it with AI
This is the unusual part of the project for me: I did not really build it from Rust knowledge.
I wanted a fast terminal tool, and Rust made sense for that kind of program, but I do not know Rust in any serious way. Most of the implementation was produced with AI assistance, with me steering the behavior, testing the output, reading the structure, and pushing it toward the tool I wanted.
That makes this project different from most of my others. It is less a demonstration of my Rust skills and more a demonstration of using AI as a development tool to create something practical that I personally wanted.
There’s something to be said about Artificial Intelligence. If you have technical knowledge and programming experience, and still understand the code at some level, AI can be an incredibly powerful tool for building software. I believe AI is just that: a tool. It isn’t going anywhere either; it’s something we need to learn to use, because when used correctly, it can help us achieve remarkable things at a much faster pace.
It’s worth emphasizing that you still need to understand the code at some level. You can’t just ask AI to build something and use it blindly without knowing how it works. You should be able to read the code, understand its structure, and test it. AI can generate code, run commands, and interact with systems, but you’re still responsible for understanding it and making sure it behaves the way you intend.
Result
The result is a small terminal program that gives me a live view of my Git working tree without getting in the way. It is useful when I want to keep an eye on changes while editing, especially when I am moving between files and want to quickly see what actually changed.
The repository is public here: github.com/connorcarro/gwatch