Conventional Commits encourages focus on the wrong things

m_m_carvalho

As a solo developer, I rarely struggle to remember what changed yesterday. I often struggle to remember why I made a decision six months ago. Conventional commits are most valuable to me as historical context rather than as a release-management tool. The larger the project becomes, the more useful that context gets.

nailer

Asides from the well made points here ('scope is more important than type' etc). > something like fix, feat, chore, docs, or refactor 'Docs' are also part of the program, they need fixes too, and features need docs. If the docs don't match the features because they're not being updated when the code is, the docs are a lie and waste other developers time. Also if you were writing a standard: why would you randomly abbreviate 'feature' but not 'refactor'? That sounds like a nitpick but standards require great thought, this is a bit of a smell that there hasn't been much thought into designing 'conventional commits'. Finally: the name 'Conventional commits' is a land grab (reminds me of when someone made a JS Standard and called it 'StandardJS', ignoring every existing popular standard). From the article, the *actual* convention is 'scope: work" - Linux subsystem: description - FreeBSD prefix: description - Git area: description - Go package: description - nixpkgs pkg-name: description

brzz

“The audience of a changelog is entirely different than the audience for a commit log! A changelog is user-facing” I'd say that ship has probably sailed. Most companies are happy with “Bug Fixes & Performance Improvements”. At least if they're not going to put the effort in, then a generated changelog is better than nothing.

shmerl

I don't care much what it says as in "fix", "chore" etc, but for me the main benefit is breaking changes indicated with "<type>!", something like "feat!: ... ". This makes neovim plugin manager highlight the change differently which brings attention to it when you update stuff. So please do use it instead of complaining! I do like the suggestion of scope!: ... if it will be treated the same way with breaking changes reactions.

akersten

The author's example of a conventional commit is not correct anyway IMO, which is maybe why they think the "fix" part is redundant: > fix: prevent foo from bar'ing The whole idea of conventional commit is: > fix: [problem] so the correct conventional commit would be: > fix: foo bar'ing which is succinct and perfectly fine.

chrismorgan

I have long despised Conventional Commits for pretty much these reasons. Yes, it’s structure, but it’s not useful structure. Of the five things it claims to enable, three are nonsense and the other two are actively bad . And it’s ugly. (But I suppose I am talking primarily about the first line part. The “BREAKING CHANGE” bit is potentially actually useful, though being incompatible with git-interpret-trailers despite leaning on git-interpret-trailers for other footers seems a bit crazy.)

mh-cx

My main complaint with conventional commits always was that they don't include an issue number in the commit title. It's not even mentioned in their standards as optional or something. To me this is almost the most important information in a commit message. I don't know how often in the last 15 years I was cross checking the issue description referenced by some old commit to get the full context of a change. I also felt that this habit is kind of standard - until i had to learn about "conventional commits". I never got the hype.

IshKebab

Couldn't agree more with this. The commit type tells me almost nothing and just wastes my time skipping over it. Scopes are way more useful.

skydhash

Mine is “ticket id - Imperative phrase”. Then I write a “why” description of the changes if needs be. As for personal project, I quite like the scoped commits style.

RVuRnvbM2e

The thing conventional commits are really helpful for is continuous delivery. Every merge to main can be automatically tagged with semver and shipped because the thought that goes into tagging and versioning has already been done by the developers when they wrote the commit message. I fully recognise that it doesn't make sense for huge projects like the Linux kernel to do this. But for 99% of projects conventional commits combined with semver vastly improves the release process status quo and makes it easy to automate.

docheinestages

I think some structure in commit messages is helpful, but not to the point where it gets in the way of effectively reflecting what the commit contains, why it was done, and any comments for future reference, e.g. potential regressions.

Benjamin_Dobell

Odd. The main reason to use this style of commit message is for CI/CD automation. EDIT: I didn't see this covered in the article on my first pass. It is covered though. My apologies. The type of the commit informs the automated workflows how to handle the commit. This is why it comes first. For example, if you're performing CD, if you only commit a bunch of `fix: ` then only your semantic versioning patch version number is incremented. If you commit a `feat: ` then it's a minor version is bump. `feat! ` is a major version bump. Even if you're not using CD for releases, semantic commit messages are sometimes used to automate change log generation. Granted, your change logs should not typically include the Git commit messages themselves — those are developer facing, not user facing.

sandstrom

I totally agree. If one needs to put metadata in commits, usually better to just put it in a Git trailer. https://git-scm.com/docs/git-interpret-trailers `Co-authored-by: Alice` is a common one, but you can have anything in there.

jmull

There’s a much less awkward way to keep a change log: Keep a change log.

codingjoe

I think any notation is use case specific and should be adapted to beat serve its domain. However, actually writing a good commit message is an art form few have mastered. I wrote a small natural language linter to teach my teams meaningful technical writing: https://github.com/codingjoe/word-weasel

flakiness

I see more of these conventional commit-style comments recently and it feels like coming from Claude Code etc. It's a bit unsettling that not only training data but also random lines in the default system prompt affects this kind of software development norms in subtle and pervasive ways.

skerit

And then you have me, using gitmoji

bowlofhummus

I really dont care about commit messages. Just create strict rules for branches that contains issue nr + description, and squash all commits on merging the PR.

xg15

This entire essay is just about how it should be "<scope> <optional type>" instead of "<type> <optional scope>"?

codybloem

I quite dislike this style of writing titles. "Stop something". I seems very popular. It sounds very commanding and "I am definitely right about this". Why not write "In favour of something" or "A case against something" or something like that?