How I Automated My Standup Reports Using Local AI So I Never Have to Read `git log` Again

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

---

What I Built

Git Standup Sloth is a command-line tool that writes your daily standup update for you.

Instead of opening your terminal, scrolling through git log, and trying to remember what you did yesterday, you just run one command. The tool reads your recent git commits, hands them to a local AI model, and spits out a ready-to-paste update organized into "Yesterday," "Today," and "Blockers."

What effort does it save?
It saves 5 to 10 minutes of morning friction every single day. It takes the mental load out of trying to remember what you worked on and formatting it nicely.

Who gets to be lazier?
Developers! Specifically, anyone who hates writing standup updates or has to summarize their work for a manager, a team chat, or a daily meeting.

---

Demo

---

Code

mauryasagar / git-standup-sloth

Git Standup Sloth

A local CLI that reads your recent git commits and writes your standup using an open-weight model running entirely on your machine.

Why

Standup is 5-10 minutes of staring at git log every morning. A standup also describes private work — client repos, internal paths, unreleased features. This tool sends nothing over the network: the model is open-weight and runs locally via Ollama.

Setup

1. Install Ollama
2. ollama pull qwen2.5:1.5b
3. pip install -r requirements.txt

Usage

python app.py                          # last 24h in current repo
python app.py --repo ../other-project  # specific repo
python app.py --since "1 week ago"     # weekly recap
python app.py --output standup.md      # save to file

Output is printed to the terminal and copied to your clipboard.

How it works

git log --stat → strict prompt → qwen2.5:1.5b via Ollama → standup.

No API keys. No cloud. No data leaves your machine.

Limitations

• 1.5B model…

View on GitHub

---

How I Built It

Git Standup Sloth is a Python-based CLI tool built entirely around local, open-weight AI inference. No cloud services, no external APIs, and no data leaves the machine.

Here is the open-source stack that powers it:

• Local Inference: Ollama handles running the model locally on my laptop.
• Open-Weight Model: Qwen2.5-1.5B (Apache 2.0 licensed). I chose this specific model because it is small enough (~1GB quantized) to run fast on standard laptop hardware while still being highly capable of text summarization and instruction-following.
• Language: Python 3, using the official ollama Python library.

The project is split into three simple modules that form a direct pipeline:

1. Data Extraction (gitdata.py)
   The tool uses Python's subprocess to run git log --since="24 hours ago" --pretty=format:"%h | %s" --stat --no-merges. Because small models (1.5B parameters) have limited context windows and can get distracted, I deliberately cap the git output at 2,500 characters. This ensures the model only focuses on the most recent and relevant commits.

2. Prompt Engineering (llm.py)
   This is where the open-source AI does the heavy lifting. I send the extracted git log to Qwen2.5 via Ollama. The system prompt is highly constrained to ensure a consistent output format (Yesterday, Today, Blockers).
   I also tuned the inference parameters specifically for this task:

   • temperature: 0.2 to keep the output deterministic and grounded in the actual commits.
   • num_predict: 200 to prevent the model from rambling. The prompt explicitly forbids the model from inventing work, forcing it to rely only on the provided commit history.

3. CLI & Output (app.py)
   The main script uses argparse to allow flags like --repo and --since. After the model generates the standup, the text is printed to the terminal and piped to the system clipboard (using pbcopy on macOS, xclip on Linux, or clip on Windows).

By building it this way, the open-weight model acts as the core reasoning engine, transforming raw, messy git commit messages into human-readable status updates instantly and privately.

---

Why Does Open Innovation Matter?

For a tool that reads your git history, open innovation isn't just a nice-to-have—it's an absolute requirement.

A daily standup is a description of private work. Commit messages often contain sensitive information: client names, internal module paths, unreleased feature names, and sometimes even bug details or sensitive URLs. If I built this using a closed API (like OpenAI or Anthropic), I would have to send my private commit history to a third-party server every single morning. For many developers and companies, that is a massive security and compliance risk, making a hosted standup bot a non-starter.

Running an open-weight model locally via Ollama completely solves this. Because the model runs on my laptop, my git history never leaves my machine. There is no data retention policy to worry about, no vendor lock-in, and no privacy trade-off.

Furthermore, this project simply wouldn't exist in this exact form without open-source AI. It relies on the fact that Qwen2.5-1.5B is open and incredibly small (~1GB). It is lightweight enough to run offline on standard laptop hardware without a dedicated GPU, requiring zero API keys, zero billing setups, and zero internet connection.

Open innovation made it possible to build a zero-cost, fully private, instantly accessible tool for a daily developer problem.

---

The Lazy Payoff

The entire goal of this project was to channel my inner sloth.

Before: Every morning, I would open my terminal, run git log, scroll through the output, try to remember what half-finished branch I was on, and manually type out a formatted message for my team. It took 5 to 10 minutes of pure morning friction.

After: I type one command: python app.py. In about 15 seconds, the local model reads my commits, formats them perfectly into "Yesterday," "Today," and "Blockers," copies the result to my clipboard, and I paste it into Slack.

I've used it every morning this week. It hasn't just saved time; it has completely removed the mental load of trying to summarize my own work. The sloth doesn't remember—the sloth just runs the script.

A note on limitations: Because I am using a tiny 1.5B model to keep it fast and local, it occasionally duplicates a bullet point or paraphrases a bit loosely. It also only reads commit subjects and diff stats, not the actual code changes. But for a 3-hour build, this is the right trade-off: a tool I actually run every day beats a perfect tool I never finish.

---

Built with an open-weight model for the Hacktoberfest Open-Source AI Challenge: Week 3.