Build an AI Git commit message generator with Conventional Commits

Automating repetitive tasks in software development isn’t just about saving time—it’s about improving consistency and reducing cognitive load. One of the most overlooked yet critical aspects of this automation is commit message generation. Writing clear, structured commit messages manually is tedious, but with the right tool, you can offload this responsibility to an AI model that follows best practices automatically.

That’s where an AI-powered commit message generator comes in. By analyzing a summary of your code changes, this tool produces standardized Git commit messages that adhere to the Conventional Commits specification—ensuring your version control history remains readable, searchable, and machine-readable. Whether you're working solo or in a large team, integrating such a system can streamline your workflow and improve collaboration across codebases.

How the AI Commit Generator Works

The solution is built as a lightweight Python script that leverages the OpenAI API to analyze a natural language description of your code changes and return a properly formatted Conventional Commit message. The core idea is simple: instead of manually typing feat: add user authentication or fix: resolve null pointer crash, the AI does it for you—consistently and correctly.

The script follows a structured process:

• It accepts a plain-text summary of code changes as input.
• It constructs a detailed prompt that instructs the AI to select the appropriate commit type—feat, fix, or docs—based on the nature of the changes.
• It sends this prompt to the OpenAI model using a strict configuration (e.g., temperature=0.0, max_tokens=30) to ensure predictable and minimal output.
• It extracts only the generated commit message and prints it to the console, ready for use.

This approach ensures that every commit message is concise, standardized, and aligned with team conventions—without requiring manual effort.

Step-by-Step Setup and Execution

To deploy this commit generator, you’ll need a Python environment and access to the OpenAI API. Begin by navigating to your project directory:

cd /root/openaiproject

Next, create and activate a virtual environment to isolate dependencies:

python3 -m venv venv
source venv/bin/activate

Install the OpenAI Python SDK to enable API communication:

pip install openai

With the environment ready, open the designated Python file for editing:

vi commit_generator.py

Replace the file contents with the following code, which encapsulates all the logic for generating commit messages:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url=os.environ.get("OPENAI_BASE_URL")
)

def generate_commit(changes: str) -> str:
    prompt = f"""
    Analyze the following code changes and generate a Conventional Commit message.
    Rules:
    - Choose only one commit type from: feat, fix, docs
    - Format must be exactly: <type>: <subject>
    - Subject must be concise and under 50 characters
    - Output only the commit message
    - Do not include quotes or extra text
    Changes: {changes}
    """
    response = client.chat.completions.create(
        model="openai/gpt-4.1-mini",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        max_tokens=30,
        temperature=0.0
    )
    return response.choices[0].message.content.strip()

if __name__ == "__main__":
    changes = (
        "Added a new user registration endpoint and "
        "fixed a typo in the README file."
    )
    commit_message = generate_commit(changes)
    print(commit_message)

Before running the script, ensure your OpenAI API credentials are loaded. If stored in .bash_profile, activate them:

source /root/.bash_profile

Finally, execute the script to generate your commit message:

python commit_generator.py

The expected output will be a single line in the format:

feat: add user registration endpoint

This output is clean, standardized, and immediately usable in your Git workflow.

Why Use Conventional Commits with AI?

Adopting Conventional Commits brings multiple long-term benefits to both individuals and teams:

• Clarity in git history: Each commit starts with a type (feat, fix, docs, etc.), making it easier to scan changes at a glance.
• Automated changelog generation: Tools can parse commit messages to build release notes automatically.
• Better collaboration: Developers instantly recognize the purpose of changes without reading diffs.
• Consistency across projects: Teams can enforce standards without manual enforcement.

With an AI-powered generator, you eliminate the guesswork in message formatting and reduce the cognitive burden of writing good commits—especially during late-night coding sessions or tight deadlines.

Looking Ahead: Integrating Into Your Workflow

This generator is just the beginning. Once operational, consider extending it to parse Git diffs directly, support custom commit types, or integrate with CI/CD pipelines to auto-populate messages in pull requests. The modular design of the script makes it easy to adapt for larger workflows.

As AI models become more accurate and accessible, tools like this will evolve from convenience utilities to essential components of modern software engineering. Start small, automate consistently, and watch your Git history transform from cluttered notes into a documented, navigable timeline of development progress.