Sometimes, I look into old commit messages.
The most useful bits it can have are:
- Why was the change made?
- What does it intend to fix? Issue number?
- What does the commiter think why it works?
- How well was this tested? Where is the test script and/or test data?
- Does it change preconditions and valid assumptions elsewhere?
Are we talking about commiting directly into master branch?
My pet peeve with conventional commits is that some brain genius decided to shorten “feature” into “feat”, a completely different word, in order to save three characters.
I suppose implementing a feature can be a feat sometimes.
I rarely read a comment I disagree with more than this, kudos.
In a typical 60 character space, you want to dedicate 5% of your oneline space to the chatacters “ure” so that you don’t mistake “feature” with the other words in english that start with “feat-”?
Yea, I don’t understand the reasoning behind that at all.
In a typical 60 character space, you want to dedicate 5% of your oneline space to the chatacters “ure” […]?
I agree, that’s an unnecessary crowding of an already limited space.
This is a good argument for removing that tag from the synopsis line entirely, leaving the whole synopsis line for an actual synopsis of the message.
For tags and other additional metadata, there is a whole arbitrary-length extended message on every commit, where fields like that can be put.
I agree with your argument. My main use case of tags is to indicate if that commit builds or not, I could probably just reduce it to a Boolean represented by one character, that way I’d get differentiation in my synopsis while still compressing it.
This thread has given me a lot to think about. I may abandon my current form of tagging. Idk tho, it’s nice to be able to visually filter chore commits from features from wip from fixes.
I’m torn.
Better idea, let’s get rid of all of the words and just say F: for feature, B: for bug fix
The more I think about this the more I like it.
Why waste space type lot letter when few letter do trick!
whyspace?
camelCaseWasRightAllAlong!
WhyNoPascal?
U do u my dude.
Yeah these are just awful to read. Feat/bug/chore is pretty much the most useless information to know about a commit.
You should just describe the change. On very large projects having a
component:prefix can be useful but honestly, barely. The most common way to arrive at a commit is through a link or git blame or similar when you already have context. I very rarely actually exhaustively read a list of commits.And if you want to automate your change log (which you probably shouldn’t do anyway), you can just as easily put that metadata in the commit body. In fact it’s probably better there because you can write a user-targeted description too.
Conventional Commits is one of those weird ideas that seems to make developers think they’re doing something useful but only if you don’t think about it too much.
Fuck no. Stop trying to stuff data into commit messages. Just describe your change succinctly so I know what you did. This “feat” “fix” and “chore” bullshit needs to stop.
Conventional commits is indeed too noisy for its signal
https://sumnerevans.com/posts/software-engineering/stop-using-conventional-commits/
Besides, the place for metadata in commits is git trailers. Project/issue management periphery should stay out of commit message titles.
The bigger problem by far in my experience is getting devs to write more than ‘fixed bugs’ or other meaningless drivel. Trying to get them to conform to any standard like this would be impossible unless enforced by some commit hook (dear god no!).
Even this new ‘standard’ shows the commit body as [optional]. The first line in a git commit is supposed to be a short summary, not the entire message. I try to write whole sentences, paragraphs and bullet lists in anything that isn’t trivial.
My last job enforced a Jira ticket number looking thing, but didn’t actually check that it was a valid ticket. The number of times I would read a commit message with zero content, then go to jira to find some reference and either find the wrong ticket, or perhaps the right ticket, but still no description, … too damn high!
I’ve seen people suggest using the inverted pyramid method style that journalists use.
https://en.wikipedia.org/wiki/Inverted_pyramid_(journalism)
Idea being that you front load the important stuff, so if you only read e.g. the first 5 lines, you don’t miss anything important later on, you can only “refine” the information you’ve already received.
Oddly enough the folks I work with are really good at the Jira ticket thing and frankly it’s much more useful than “feat” prefixes on everything. Because the Jira ticket gives me a “why” which can be amazingly helpful when trying to figure out “why was this line added”.
I have never once found feat/fix/chore to be of any use when looking at history. It’s useless noise.
I’m OK with Jira ticket for branch names and pull requests. If something needs paragraphs to explain it, it should be a ticket. By all means copy that to the pull request and then have it in the merge (or squash commit).
If fact, I think I’ll suggest we automate that in my org - we’ve lived through a TFS to Jira migrations and it’s a lot harder to track down the original info now. If you migrate from GitHub to GitLab or ForgeJo, that’s one more layer of business knowledge and motivation that gets lost.
Either way, I’m on board with a simple “Fixed API routing” or “Improved Artist card reflow” message. If I’m reading it, I’m already looking at the routes or the CSS.
One thing I’ve found useful with some git forges (haven’t tried them all so no idea if it’s universal) is tagging commits to issues and/or prs. Never bothered with the auto close functionality but assuming people actually put details into tickets, it’s come in handy a bunch of times this year to figure out why something got implemented when the original contributor is long gone.
That is one thing I like about the MS TFS/ADO or whatever they call it. Our Ops team enforced a task, defect or change order be linked to the PRs going into the develop/release branches. For all the hate MS gets (deservedly, their enterprise support sucks), at least the tools to allow admins to set that up easily were much more useful than what we had with jira on my previous project. Or maybe it was due to Ops admins having an actual say on the workflow instead of some senior managers coming from some ancient pre-git source control to dictate the pre commit hooks and flow of branches…
If devs on the team have trouble writing good commit messages, forcing input won’t really help
IMO would be better off auto-pulling names of components that were touched into the message.
It’s 3-5 letters you slap at the start of your succinct change description. I don’t see how it’s that big of a deal to get this upset about.
Fine - then add 3-5 actually random letters to the start of all your commits from now on.
No? I don’t understand what you’re so upset about…
Because it’s NOISE that I’m sifting through as a tech lead. And they’re often lies anyway. “feats” can have refactors and bug fixes. fix can add new features. Devs are horribly bad at separating out these types of changes neatly when making commits. “chore” is just too cute by half. I know “Version bump: 1.2.3” is just a version bump - I don’t need you to whine about it being a chore.
It sounds to me like you’re just dealing with people who write bad commit messages.
Or commits in general if you’re dealing with “feats” containing bug fixes.
It doesn’t sound to me like your core problem is with conventional commits themselves, but rather with how they’re done in your experience.
Inconsistency and unclear meaning does make it just some random noise, but that’s not how the standard is meant, that’s just people using it irresponsibly.“chore” is just too cute by half. I know “Version bump: 1.2.3” is just a version bump - I don’t need you to whine about it being a chore.
Worth noting that only
fixandfeatare actual types defined by the official spec.choreis only listed as an example of what custom types you could use. So as long as you make sure the rest of the team is on the same page, you can also use a different noun likebumporversioninstead.“feats” can have refactors and bug fixes. fix can add new features. Devs are horribly bad at separating out these types of changes neatly when making commits.
Actually looking through Conventional Commit’s page again, I also found this on-topic Q&A question:
What do I do if the commit conforms to more than one of the commit types?
Go back and make multiple commits whenever possible. Part of the benefit of Conventional Commits is its ability to drive us to make more organized commits and PRs.When both a bug fix and a feat are in the same commit, the answer isn’t to use one or the other, but to simplify the commit. I personally see more valid overlap with
refactor(which isn’t an official type), but with these two, it’s inexcusable imo.It sounds to me like you’re just dealing with people who write bad commit messages.
Really? I’ve been saying, quite clearly I felt, that “fix” and “feat” are pointless and stupid. Whether the comment after it is good or bad.
And fix and feat aren’t supposed to be pointless and stupid if done properly.
I always write just WIP or something simple. Commit often, so you can easily go back if you mess something up.
Then later when the branch gets merged, I squash it with a proper commit message (that no one will ever look at, but those are the rules!)
How would you automate changelog generation and semantic versioning without conventional commits? For me, this is the biggest selling point of this standard, when paired with tools like Release Please.
In your PR:
## Release notes - Fixed foo returning baz instead of bar when qux is passed inYour commit messages are pretty useless to the people actually reading the changelogs. If you need automatic changelog generation, then stitch it from parts written for humans to read.
You don’t. Users are different audience than the development team. Messages intended for one group are different from those for the other. This is my biggest gripe about this “semantic” BS. Commit comments are for the dev team. You should summarize it in a way that makes sense to users.
Every time I see a “changelog” from a team for something I use that is full of “fix: loop pointer in Foo.java” I just roll my eyes. Like that tells me anything useful. If I cam technically savvy enough and care I can go look at the git history. But as a user that’s meaningless.
I want to be able to scan a commit log, not just read commit titles one by one.
The type gives me a scoping of to be expected intention, change size, and potential for side effects. docs never have runtime side effects.
The scope gives me categories to scan for. Which area of the project am I searching for? Which product feature? If there’s a user bug, I can check those in the specific area and more general ones first.
I need scope to be small, so the visual scanability is not broken because of horizontal shifting of the actual commit change title.
I made sure my team capitalizes the commit change title, as an additional visual queue for scanability; being able to blend out the prefix.
Even if you don’t care about changelog generating or log scanability for developers searching, debugging, or analyzing, I find deliberate commit messages practice helpful in guiding both in thought and documenting though of what the intention of the commit is, whether to split changes because they’re logically unrelated/not the same step, etc.
In a small project or freshly started project before going stable or sizable it may not be necessary, but I still enjoy following the general practice.
(cut off because it’s a customer project, just to be sure)No prefixes is a lot less useful. Commits can provide structure and guidance.
Personally, I don’t like
chorethough, and we don’t use it in our project, reducing the number of types. Typically, those aremisc(proj)ormisc(ci)instead.The customer receives a list of feat and fix commit titles as info with a release.
Commits are already data. Metadata about changes. Merge commits are structured data, putting individual changes into structured context. Using short well defined prefixes/prefix formats is a logical extension.
The customer receives a list of feat and fix commit titles as info with a release.
The problem is that the language customers want and the language developers want are different things. Abusing commit messages to try to create documentation is just a bad idea. Spend a few mins to summarize for your users what has changed. You should be able to pull the tickets that went into a release for that pretty easily. Hell have AI do it if you’re that lazy. But as a developer I want to know what your commit did. Just explain your change in a way that will help me later on.
I find a commit message describing consequential effect and intended goal/change more useful than technical details. And those are usually what the customer cares about. “function/action works again” “fix x by y” “introduce functionality x”.
But as a developer I want to know what your commit did.
I agree. I don’t see them as opposites or contradicting to pulling them. Either as a free information forward, or as a basis for describing it into something a customer understands, or into what is notable about a release.
I find a commit message describing consequential effect and intended goal/change more useful than technical details.
100% this! I’m reminded of this post on “why” is better than “what”, as the what is self-explanatory from looking at the changeset, whereas the why requires context that should be captured in the commit message.
Agreed. Just write like a normal person. Conventional commits is such an engineer thinig to do (I say this as a software engineer myself). It’s an overengineered solution for something that should just be a human message.
That doesn’t sound very grep-pable.
Predictable practices are foundational hooks for automation.
What worth is there in grepping for
featorchore? Seems pointless to me. Besides, you could also just grep through the git history of the actual code instead of grepping commit messages.Also, maybe I’m the weird one here, but in my career as a software engineer, I’ve never had to search through commits in such a way. There’s always been better options, like looking at the blame or history of a particular section of code or a file or something like that.
I’m in favor of predictability, not any particular workflow. Your suggestions are also great.
Resource links for your convenience
- Conventional Commits
- Conventional Changelog Config spec
- convco uses
.versionrcas the file name
- convco uses
- Conventional Comments







