# git-catchup CLI Tool > Source: > Published: 2026-10-26 06:39:05+00:00 *This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady](https://dev.to/challenges/hacktoberfest-week3-2026-10-19)* **git-catchup** is a command-line tool that gives you a short briefing on a git repository so you can pick up where you left off. When you return to a project after some time away, it takes effort to remember where you stopped. You typically have to read through recent commits, check what is uncommitted, and look for the TODO comments you left, just to rebuild the context before you can continue. `git catchup` reduces that to a single command. Run it inside any repo and it prints a short briefing on the project and where you left off, so you can start working without reviewing the history first. It shows: It is useful for anyone who works on side projects, open-source contributions, or several repos at once, and who would rather run one command than reread the history. Summary of the repo state. `git catchup --dry-run` prints exactly what the model receives. **Catch up on where you left off.** Come back to any repo, finished or not, and one command tells you what the project is, what's done, what's still open, and what you'd planned next. It reads your commits, uncommitted work, TODO/FIXME comments, README and notes files (`TODO.md`, `NOTES.md`, `ROADMAP.md`...), and a local open-weight model writes the briefing. Nothing leaves your machine. ``` bash $ git catchup git catchup | branch: feature/discount-codes (base: main) Last commit: 10 days ago | uncommitted edits: 2 days ago Uncommitted files: 3 | secrets redacted: 1 **Where you left off** ... **State of the work** ... **Next step** ... ``` Dates, counts and branch names come straight from git. The model only writes the narrative, because small models are bad at facts they can simply look up. `ollama pull gemma3:4b` `pip`… **Open-source AI used** `gemma3:4b` by default. I also tested `qwen2.5:3b` and `llama3.2:3b`.`--model`. **How the project is built around the model** The model has a deliberately small job, and everything that can be checked is handled by plain code: `[line omitted]`, and `.env`, `.pem` and key files are dropped from diffs. This is regex-based and best-effort.`project`, `left_off` and `next_step`. The prompt is built conditionally, so the model only sees instructions that apply to the repo. `git catchup --dry-run` prints exactly what the model would see, so the prompt can be audited. **Comparing models** Same branch, three models, one flag. Everything above the divider is identical because plain code writes it from git. Gemma's briefing was cleanest, Llama's accurate but vague, and Qwen said a discount code had been added when it was already committed. Model quality also varies from run to run, which is why facts never come from the model. In all three runs the guard log was empty, so no guard fired. `git catchup` runs on unpushed, half-finished work, which is the code you are least likely to want to send to a third party. Open-weight models run through Ollama made that possible: `--dry-run` prints exactly what the model receives, so nothing is hidden between the repo and the model. Closed APIs can also do this task, and many support structured output. For a command you run often on private code, local open-weight models were the better fit. On the demo branch I last touched 15 days ago, the manual route to get back into context is: read four commits, check `git status`, search for TODOs and open the notes file. `git catchup` gives all of that in one screen, plus a suggested starting point (`discounts.py`, the TODO about unknown codes). The cost of running it is a single command. **Best Use of Gemma.** `git catchup` uses `gemma3:4b` as its default model, run locally through Ollama. In my three-model comparison on the same branch, Gemma's briefing was the cleanest: accurate, with a concrete next step taken from the TODO in the code.