ez_commit: A Rust CLI for AI-Powered Conventional Commits

This is a submission for the GitHub Copilot CLI Challenge

What I Built

ez_commit is an interactive Rust-based CLI designed to take the friction out of writing Conventional Commits. It combines a compact Terminal User Interface (TUI) for selecting and staging files with an AI-assisted generation engine.

The tool enforces a human-in-the-loop model: Copilot suggests a commit draft based on your staged changes, and you review or edit it before it ever touches your git history.

Why I built this: Maintaining a clean, consistent commit history is vital for changelogs and team collaboration, but it’s often the first thing to slide when developers are in a rush. ez_commit makes doing the "right thing" the fastest path.

Demo

You can find the full source code and installation instructions here:

Evgenii-Zinner / ez_commit

CLI tool for fast commiting using GitHub copilot

ez_commit

Interactive CLI tool for generating conventional commit messages with AI assistance.

A simple, fast, and human-in-the-loop commit workflow. Select files, let AI analyze your changes, review the message, and commit—all from the terminal.

Features

✨ Interactive file selection - TUI-based multi-select of changed files
🤖 AI-powered messages - GitHub Copilot integration for smart commit messages
📝 Conventional Commits - Automatically formats to type(scope): description
✏️ Manual review - Edit the generated message before committing
⚡ Fallback analyzer - Works without Copilot with built-in smart analysis
🔍 Verbose mode - Debug details with -v flag

Quick Start

# Build
cargo build --release

# Run
./target/release/ez_commit

# With verbose output
./target/release/ez_commit -v

Usage

1. Select files - Arrow keys to navigate, Space to toggle, Enter to confirm
2. Review message - AI generates a commit message with summary + bullet points
3. Edit (optional) - Your editor opens for final tweaks
4. Commit - Changes…

View on GitHub

Screenshots

My Experience with GitHub Copilot CLI

I developed this project using an agentic loop, where GitHub Copilot CLI handled much of the heavy lifting. My workflow looked like this:

• Initial Design: I started with a README.md acting as a design doc. I described the problem, the required features, and my choice of Rust.
• The Agentic Cycle: I used Copilot CLI to generate boilerplate and logic from prompts. It was a cycle of: Generate → Build → Copilot read Errors → Fix.
• Fast Prototyping: Copilot produced a working prototype remarkably fast. I spent roughly three hours total on this project—including thinking, waiting for builds, and reviewing results.
• The "Premium" Wall: I wasn't read docs too thoroughly, so didn't notice that any usage of Copilot CLI count as premium calls, so i spent prompt budget really fast.
• Granularity of Feedback: While Copilot is working on a file, it often reports the number of lines it is changing. However, it would be much more helpful to see the actual code diff directly in the dialogue rather than just numbers. Since it processes one file at a time, seeing the specific logic changes live would allow for much faster verification

Overall Impression: The speed of iteration is the killer feature here. Moving from a blank folder to a Rust CLI with TUI and AI integration in one afternoon felt like having a senior pair-programmer who never gets tired. And I used this tool after first iteration to create commit messages (so some errors are logged in history), it was fun experience.

---

How to Use

To get started with ez_commit locally:

# Build the project
cargo build --release

# Run the binary
.\target\release\ez_commit.exe

Key Features:

• -v, --verbose: See exactly what's being sent to the AI.
• -s, --skip-copilot: Use the local fallback analyzer if you're offline or out of credits.
• -d, --diff-limit: Control how much code context is sent to the model.