You're not wrong though, even 1GB is quite lot for writing commit messages, I gave it a quick go, and it takes around 15-30s to analyse a very small diff. Kinda silly for git messages.

Oh cool, it's malware too.

he KillSwitch interpreter can detect when it is run on code generated by an LLM. This detection is proprietary and it is accurate. If the interpreter detects a non-human editing the code, it will delete the code. As such, any edits you make to the code will break the code, the original script will be unrecoverable. So do not risk modifying the code, or you risk accidentally removing your user's code!

And it won't have a clue if you consider "asbestos" an unwanted word. I mean that's all highly subjective and an AI will (most likely) just do whatever.

Gotcha. Sorry for being snarky.

I have a feeling this is actually a llm benchmarking fan in disguise.

Burn the witch!

Using complex, power-hungry matrix algebra to get words that could come from an indexed array in constant time is just about the worst solution of which I can think.

Worth noting, it may be that you meant to generate a list as a one-time operation. That is maybe sensible. I originally interpreted you to mean on the fly generation.

then write them.

You and your team will have to decide, but in my experience generating commit messages is not particularly useful.

Because you really just want a short (ideally one-line) summary of the changes. If someone's interested in the details, they can look at the diff (and hell, have that then summarized by an LLM, if needed). Adding a bullet point list for each concrete change adds a ton of noise to the commit log, which is IMHO not worth it.

Where long commit messages are actually useful is for documenting things that aren't written into the code, mainly why you made the change. But since they're not in the code, the LLM can't generate that part for you.

oh god, screw that.

but that's your job. document the rationale of your changes for others.

Its small in the sense it'll run on basically any GPU from the last decade, rather than high end or specialised GPUs. And there is a 1GB gemma4 model, which is meant for CPU/phones.

Alternative headline: Claude scores 70% on benchmark in esoteric language it hasn't been trained on. That's basically an ad for Claude Code..

https://victorzhou.com/blog/better-profanity-detection-with-scikit-learn/

That might be of interest to you then? Its a small model trained for profanity detection, might work for your use case. Dunno if it can be used for generation though.

Otherwise, there were 1GB gemma models, you can run them on CPU.

How the hell is 8GB a small amount for a side utility? Are you using LLMs to count to 50?

I've once worked on a project where your commits to your dev branch were supposed to be helpful to colleagues for reviews, but they had to be squashed for the feature branch, with comments adhering to the conventional commit "standard". On the other side of it, there was a horrible pedant of a middle manager, who was rejecting merges based on (debatable) "misformats".

This affected billing. They supposedly had some scripts evaluating merge requests, and they'd shrug and say "the script rejected it". This was before LLMs. Come to think of it, they're probably replaced by an LLM now, prompted by the customer to "try to defraud and fuck with the workforce on every commit".

So to sum up, maybe OP's in some sort of corporate hell, or maybe they want a bit more than going git commit -m every time.

This seems like a problem that can be approached entirely in embedding space. Find embeddings for words that you want to avoid, then filter your dictionary to remove anything too close to those.

No need to go through full text gen or anything, though if you want to go that route, a classifier like Jev (or OpenJev/etc) would be best.

Not aware of such a thing. For the commit message to mean anything, it needs to understand what you did. And that requires some level of "intelligence". Do it yourself, reference a user story or issue report or use a small large language model.

the classic language models before LLMs existed

Which models are you referring to here? Earlier versions of GPT (like GPT-2)?

There are small LLMs like Phi 4 Mini that you could look at. Those were part of the "small language model" craze (SLMs).

If you want meaningful commit messages though, nothing beats handwritten messages. Commit frequently and the messages should be short and easy to come up with.

As well-intentioned as this might be, I doubt they understand how trained models work.

they are not notes to meself when there are others in the project. And the commit message is not always one line. Sometimes it's more. And even if it is one line, it is still annoying to manually type for everything and every change.

I want meaningful commit messages pal :)

why generate commit messages? they are notes to yourself about what you have done and why. they don't need to be more than a single line.

8GB means around 8B parameters. It's no where near small. I meant the classic language models before LLMs existed. Something which I can easily execute on CPU to generate the commit messages.

And here, I'm not asking for "what model" rather "what utility" which uses such these models. Finding or training a model is much easier than maintaining such a software and keeping it useful.

Where do you draw the line between Large LM and a non-large LM? You can fit Gemma models into 8GB VRAM or even way less:

https://blog.google/innovation-and-ai/technology/developers-tools/quantization-aware-training-gemma-4/