Forem: Mathias Falci

How Do You Actually Compare LLMs? (The Battle Nobody's Talking About)

Mathias Falci — Thu, 25 Dec 2025 23:45:00 +0000

Hey folks! 👋

So... The end of 2025 was absolutely wild in the AI world. Within just two weeks, we got Claude Opus 4.5, Gemini 3 Pro, and GPT 5.1, all claiming to be the best coding model ever made. It felt like watching a Formula 1 race where everyone crosses the finish line at the same time.

But here's the thing that's been bugging me: how do we actually know which one is better?

I mean, sure, companies throw around impressive numbers like "80.9% on SWE bench!" or "91.9% on GPQA Diamond!" But what does that even mean for us developers who just want to ship code?

After spending way too much time diving into benchmarks, testing different models, and trying to make sense of this AI arms race, I want to share what I've learned about actually comparing these models in a way that matters.

The Problem With Benchmarks (Yeah, I Said It)

Look, benchmarks are useful. They give us something to compare. But here's what nobody tells you: a model that scores 80% on SWE bench might actually perform worse for YOUR specific use case than one that scores 75%.

Why? Because benchmarks test specific skills in specific ways. It's like saying someone is a better developer because they can solve LeetCode problems faster. That might be true! But it doesn't mean they'll write better production code for your app.

When Claude Opus 4.5 launched, Anthropic made a big deal about it scoring higher than any human on their internal engineering exam. That's genuinely impressive! But does that mean it's better at helping you debug a React component? Not necessarily.

What Actually Matters When Comparing LLMs

After testing these models for different tasks, I've realized there are really three dimensions that matter way more than any single benchmark score:

1. What Are You Actually Building?

This sounds obvious, but it changes everything. The "best" model for writing a Python script is different from the best model for architecting a microservices system.

For example, when comparing the big three models on coding tasks:

Claude Opus 4.5 dominates on complex, multi step workflows. It's like having a senior engineer who thinks through the entire architecture before writing code.
Gemini 3 Pro crushes it on pure reasoning tasks and academic level problem solving. If you need to solve a really gnarly algorithmic problem, this might be your pick.
GPT 5.1 (especially Codex Max) is incredibly reliable for straightforward implementation tasks. It just works, and the code it produces tends to integrate cleanly.

None of these is "better", they're optimized for different things.

2. Speed vs. Quality (the hidden trade off)

Here's something that benchmark scores don't show: how long does the model take to respond?

I noticed this when using different models for the same task. Gemini 3 Pro often gives you working code faster, but Claude Opus 4.5 might give you a more thoughtful solution that considers edge cases you didn't even think about. GPT 5.1 lands somewhere in the middle.

For rapid prototyping? Speed wins. For production code that needs to be bulletproof? Maybe you want that extra thinking time.

3. Cost (let's be real)

This is where things get really interesting. Claude Opus 4.5 dramatically dropped their pricing, making frontier level performance actually affordable for regular use.

But here's the catch: a "cheaper" model that takes 3 attempts to get right might cost more than an "expensive" model that nails it on the first try. Token usage matters just as much as token price.

The Benchmarks That Actually Help

Okay, so if single scores don't tell the whole story, what should you look at? Here are the benchmarks I actually pay attention to:

SWE bench Verified: This tests real world bug fixing from actual GitHub repos. If a model scores high here (like Claude Opus 4.5's 80.9%), it means it can handle the messy, context heavy work that developers actually do.

Terminal bench 2.0: How well can the model work in command line environments? This matters way more than people realize if you're building DevOps tools or automation.

MCP Atlas: For scaled tool use. If you're building agents that need to juggle multiple APIs and services, this benchmark shows which models can keep track of complex workflows.

The key is looking at benchmark combinations that match your use case, not just the highest single score.

My Real World Test

I wanted to see this for myself, so I gave all three models the same task.

Claude Opus 4.5 gave me the most comprehensive solution, it thought about data validation, built in retry logic, and even suggested monitoring. But it was also the slowest and used the most tokens.

Gemini 3 Pro was lightning fast and gave me clean, efficient code. But I had to manually add some edge case handling it missed.

GPT 5.1 was the most balanced, solid code, reasonable speed, handled most edge cases. It felt like the "safe choice."

Which one was best? Honestly, it depends on whether I'm prototyping (Gemini), building production features (GPT 5.1), or architecting something complex (Claude Opus 4.5).

So... How DO You Choose?

Here's my framework:

Start with your specific task -> Don't just pick "the best model." Pick the best model for what you're building right now.
Test with your actual use case -> Spend an hour trying different models on a real problem you're solving. The difference in how they approach your specific domain will be way more revealing than any benchmark.
Consider the full cost -> Factor in tokens used, iterations needed, and your time debugging. Sometimes the "expensive" model is actually cheaper.
Watch for specialization -> Models are increasingly being optimized for specific tasks. Claude for agentic workflows, Gemini for reasoning, GPT for reliability. Use that to your advantage.

The Bottom Line

The "best" LLM is the one that works best for your specific needs, at a price point that makes sense, with a workflow that fits how you actually work.

These benchmark wars are fun to watch, but they're not the full story. Just like how the fastest laptop isn't always the best laptop for YOUR work, the highest scoring model isn't always the best model for YOUR project.

The real skill isn't knowing which model has the highest score, it's knowing which model to use when, and why.

What's your experience been? Have you found certain models work better for specific tasks? I'd love to hear what you've discovered in your own testing.

How I Built a Fully Automated Instagram Bot in One Weekend (From Zero n8n Knowledge to Live Workflow)

Mathias Falci — Fri, 05 Sep 2025 19:42:04 +0000

Hey everyone! 👋

I want to share something pretty cool that happened last weekend. I went from never touching n8n to having a fully automated Instagram bot that finds content, processes it with AI, and creates beautiful carousel posts (all without any manual intervention). Honestly? I had no idea what I was getting myself into.

The "Aha!" Moment

Let me be straight with you: n8n is incredibly powerful, and I had zero experience with it before this weekend. I had some previous experience automating with Python, but n8n really showed me the full potential of workflow automation tools.

The thing that blew my mind 🤯 is how there are literally unlimited possibilities. Seriously, check out their templates page if you want to see what I mean. From simple data processing to complex multi step workflows involving APIs, databases, AI agents, it's like having a programming language built specifically for connecting different services together.

The Pivot That Changed Everything

My original idea was simple: Create an instagram account that posts current crypto prices. Seemed straightforward, right? Wrong.

About halfway through building it, I realized something obvious that I should have thought of earlier, crypto prices get outdated in hours (even in minutes). By the time someone sees a post, the information is basically useless.

So I pivoted. Instead of prices, why not crypto news? News stays relevant longer, provides actual value to followers, and there's always fresh content to work with. ✅

Why I'm Really Doing This

Look, I'll be honest, automation has always fascinated me. There's something almost magical about setting up a system that just... works. While you're sleeping, having coffee, or working on other projects, this thing is out there doing its job.

But beyond the cool factor, I wanted to really understand what n8n could do. I learn best by diving into actual projects, and this felt like the perfect way to explore a tool that could change how I approach repetitive tasks.

How the Magic Happens

Here's the workflow breakdown:

Content Discovery: The bot searches for trending crypto news from reliable sources using RSS feeds and news APIs.
Content Processing: Each article gets analyzed by AI (using Gemini API) to extract key points, determine relevance, and create engaging summaries.
Content Creation: The AI then transforms this information into Instagram friendly carousel content, multiple slides with digestible information, proper formatting, and engaging hooks.
Automated Posting: Finally, everything gets posted to Instagram automatically using their API, complete with relevant hashtags and optimal timing.

Of course, just looking at these steps it seems pretty simple, and the idea actually is, but here we have the final workflow view (which I kindly call my little monster):

The beautiful thing is that once it's set up, it just runs. Every few hours, fresh content appears on the Instagram account without me lifting a finger.

The Numbers Don't Lie

After about 5 days of running this automation, here are the results:

I'm curious to see what the next few months bring. Will the content quality stay consistent? How will the engagement evolve? Will I need to tweak the workflow as I learn more about what works?

These are the questions that keep this project interesting beyond just the technical challenge.

Want to Build Something Together?

Here's the thing, this project taught me that the barrier to entry for powerful automation is way lower than I thought. If you've been curious about n8n, workflow automation, or just want to build something cool, I'd love to connect.

Whether you're thinking about content automation, data processing, or something completely different, there's probably a way to make n8n work for it.

10 Years on GitHub: What I’ve Learned

Mathias Falci — Sat, 07 Jun 2025 18:03:07 +0000

TL;DR: After 10 years on GitHub, I’ve learned the value of consistency. From my first commit as an intern to collaborating on open source, GitHub has shaped how I learn, share, and build. In this post, I reflect on key lessons from my journey, and why it still matters today.

🧠 A Decade on GitHub

I remember when I was in my first job as an intern in a software house called Absis (2015). I was with two more colleagues and we decided to create a GitHub account (to be honest here, I don’t exactly remember why), because in the software house we used Tortoise SVN (yeah, pretty old huh?). But the thing is, we created it and my journey with that awesome and powerful platform began (cheers to Kaleb and Gabriel). By the way, I do not find the Gabriel's GitHub anymore :/

As I mentioned before, I was an intern and I didn’t even know exactly the purpose of GitHub, but I knew that it was important since all my references used it and had it.

Things didn’t start smooth with GitHub. We created it, but actually the journey of learning how to use it had just begun. Then I started some free online courses, and things started to make sense.

Maybe for most of the readers, Git and GitHub are already mastered topics, and you use them in your daily work routine. But trust me guys, it can look pretty simple and useful for us right now, but for those who are starting, it is so complicated and can take a month or more to get used to it. It’s hard, but whenever possible, try to put in practice your empathy to look at things with a beginner’s perspective.

The following tip is very useful and I wish someone had shared it with me before. I discovered it by myself, but basically, before starting to use or study something, I like to go back to the origin and understand why it was created, what problem it solves. In the case of Git, it was pretty interesting, I strongly recommend you to go for that information and learn more about it =)

🕰️ Early Days

I don’t remember exactly my first repository, my first star or issue. Of course, I can check it, because we always have all the history stored in GitHub. Probably I learned that after pushing some changes that deleted something that was not meant to be deleted haha.

What really made a difference in my GitHub learning journey was consistency, even just to get familiar with the common commands. After the intern job in the software house, I had the opportunity to work as a front-end developer in a digital marketing agency, where I needed to use GitHub every day to deliver my work.

It was around 2017, two years after the creation of my GitHub account. At that time, things started to get serious with GitHub, and I understood that there is no better place for collaboration than inside GitHub or any other Git-based versioning platform/tool.

📚 What GitHub Helped Me Learn

It is so satisfying when you create pull requests to a recently discovered project and your collaboration is accepted by the owners of the project. Probably GitHub was the reason for my passion about open source and collaboration.

I really recommend you take a periodic look at the trending page in GitHub. There are always awesome projects that you can check out, that you can use, fork, make modifications and improvements to, or even discover new worlds of possibilities.

Who, with more than 1 year of coding, has never found an issue in the repository of a lib that you use, and you are facing some error that you have no clue how to solve — and another person already created an issue with the same problem. You feel so understood! Of course, sometimes there is no issue related to the problem you are facing, so be the one who will create the issue (following the issue template, please haha), and help future folks who will fight with it in the future.

Also, every year we have the hacktoberfest, a brilliant event that incentivizes open source collaboration. You will achieve points and get rewards if you collaborate with other repositories, if people collaborate with your repositories, and so on. It’s really cool for experienced developers, but even more so for those who are starting in that world.

I don’t have words to describe how “proud” I felt after receiving my first prize kit from Hacktoberfest back in 2019. Until today I have and use my t-shirt :D

🔮 What’s Next?

After 10 years on GitHub, I know one thing for sure: this journey is far from over.

The tech world is evolving faster than ever with AI, new frameworks, and new ways of collaborating. GitHub itself is changing, with tools like Copilot making coding even more accessible and collaborative.

For me, the next step is about keep consistent , keep contributing, keep learning, and keep helping others, especially beginners who are just getting started (like I once was).

And of course… the goal is to come back here in another 10 years and write a new post: 20 Years on GitHub 🚀.

Thank you for read until here 🙏 Let's connect! Feel free to follow me on github, I'll for sure, follow you back. Happy coding!

50 Must-Know JavaScript Topics to Master Your Next Interview 🥷

Mathias Falci — Thu, 30 Jan 2025 20:29:53 +0000

Introduction

A carefully curated list of topics that are commonly covered in JavaScript technical interviews. Due to the quantity, we won’t dive deep into each topic, but the goal here is to present them, so you can explore more on your own. Without further ado, let’s dive into the content!

1. `compose()` and `pipe()` Polyfill

Both are higher-order functions that allow you to combine multiple functions into one. compose(): Composes functions from right to left, meaning the rightmost function is executed first. pipe(): Composes functions from left to right, meaning the leftmost function is executed first. Check the implementation here.

2. Promises and Their Helper Methods

Promises are fundamental for handling asynchronous operations in JavaScript. Understanding how to implement polyfills for Promise.all(), Promise.race(), and Promise.allSettled() demonstrates deep knowledge of promise mechanics and common async patterns.

Promise.all(): Waits for all promises to resolve or fails if any reject
Promise.race(): Resolves/rejects as soon as the first promise settles
Promise.allSettled(): Waits for all promises to settle, regardless of outcome

3. Implement the `.map`, `.filter`, `.reduce`, and `.forEach` polyfills

Creating these polyfills highlights your grasp of array iteration methods and how to work with JavaScript's Array.prototype. Each method serves a unique purpose, such as transforming, filtering, or reducing data. Explore practical examples.

4. Implement the `Function.bind`, `call`, and `apply` Methods

These methods are fundamental for controlling the execution context this of functions. Implementing them requires a solid understanding of how this behaves in JavaScript. Learn more.

5. Implement Async.parallel and Async.series for Executing Async Tasks

These are utility methods to manage asynchronous workflows. While parallel runs tasks concurrently, series executes them sequentially, making it crucial for managing complex async operations. Check code examples here.

6. Build a Promise from Scratch

Creating a promise from scratch demonstrates your understanding of the promise lifecycle, including states (pending, fulfilled, rejected) and chaining. Here's a good example.

7. Implement a Retry API

Retry APIs are used to handle transient failures in async operations. Implementing one showcases your problem-solving skills for error recovery in unreliable systems. Retry logic like a PRO.

8. Implement Memoization

Memoization optimizes performance by caching the results of expensive function calls. This technique is commonly used in recursive problems like Fibonacci sequence calculations.

// Fibonacci with Memoization
function fibonacci(n, memo = {}) {
  if (n <= 1) return n;

  // Check if the result is already cached
  if (memo[n]) return memo[n];

  // Compute and store the result in the cache
  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
}

9. Currying

Currying transforms a function with multiple arguments into a sequence of functions, each taking one argument. It’s a powerful functional programming concept often used for partial application. An excellent practical example of currying.

10. String.prototype.repeat

The repeat method repeats a string a specified number of times. Understanding this showcases your grasp of string manipulation and built-in methods.

11. Design Patterns

Design patterns are essential tools in software development, offering reusable and proven solutions to common design challenges. They promote best practices, improve code maintainability, and foster collaboration by providing a shared vocabulary for developers. Definitely is a must-know topic. A comprehensive guide.

12. Implement the Publisher-Subscriber Pattern

The Publisher-Subscriber (Pub-Sub) pattern is a way to let different parts of your application communicate without knowing about each other. In this pattern, "publishers" send out events, and "subscribers" listen for those events and react. This makes your app more scalable (you can add or remove parts easily), modular (components work independently), and flexible (you can handle events dynamically). More detailed explanation.

const pubsub = {
  events: {},
  subscribe(event, callback) {
    this.events[event] = this.events[event] || [];
    this.events[event].push(callback);
  },
  publish(event, data) {
    (this.events[event] || []).forEach((callback) => callback(data));
  },
};

pubsub.subscribe("message", (data) => console.log("Received:", data));
pubsub.publish("message", "Hello, Pub-Sub!");

13. Prototype and Prototype Inheritance

In JavaScript, every object has a hidden "prototype" that it can inherit properties and methods from. This is called prototypal inheritance, and it’s a key feature of how JavaScript handles object-oriented programming. Instead of creating classes (like in other languages), JavaScript uses prototypes to share functionality between objects. This makes your code more efficient and flexible, as objects can reuse behavior from their prototypes.

14. How Rendering Works in the Browser

When you load a webpage, the browser goes through several steps to display it: it reads the HTML to build the structure (DOM), processes the CSS to create styles (CSSOM), combines them into a "render tree," and finally paints the page on the screen. Understanding this process helps you identify and fix performance issues, like slow-loading pages or janky animations. A detailed explanation here.

15. Event Delegation and Event Propagation

Event delegation is a technique where you add a single event listener to a parent element instead of multiple listeners to individual child elements. This improves performance, especially for dynamic content. Event propagation describes how events move through the DOM: first "capturing" (top-down) and then "bubbling" (bottom-up). Understanding these concepts helps you handle DOM events more efficiently and avoid common pitfalls. Learn more about event delegation and propagation here.

16. Progressive Web Applications (PWAs)

PWAs are web apps that feel like native apps. They work offline, send push notifications, and can be installed on your device. They use service workers (for offline functionality) and app manifests (for app-like behavior). Deep dive into PWAs.

17. Clone an Object

Cloning an object means creating a copy. A shallow copy duplicates only the top-level properties, while a deep copy duplicates nested objects too. Use Object.assign for shallow copies and structuredClone or libraries for deep copies. See more about object cloning here.

18. Debouncing and Throttling

Both techniques improve performance in apps with frequent events (like scrolling or typing). Debouncing delays execution until after a pause, while throttling limits execution to once every set time interval. Learn more about debouncing and throttling here.

19. Implement clearAllTimeout()

This function clears all active setTimeout timers. It’s useful for managing multiple timers and preventing unwanted executions. Code example.

20. How Does "this" Work in Different Scenarios?

The value of this changes based on how a function is called:

In global scope: this refers to the global object (e.g., window in browsers).
In object methods: this refers to the object.
With bind, call, or apply: this is explicitly set. Deep dive into this binding here.

21. Difference Between Synchronous and Asynchronous Code

Synchronous code runs line-by-line, blocking other operations until it finishes.
Asynchronous code runs in the background, allowing other tasks to continue. It uses callbacks, promises, or async/await. Learn more about async vs. sync here.

22. Explain the Concept of "Truthy" and "Falsy" Values

In JavaScript, some values are treated as false (falsy) in conditions, like 0, "", null, undefined, and false. Everything else is true (truthy). This helps avoid bugs in conditionals. See the official docs for truthy and falsy.

23. What Are Template Literals in ES6?

Template literals are strings wrapped in backticks (`) that allow:

Multi-line strings.
Embedding variables or expressions using ${}. Example: `Hello, ${name}!`. Learn more about template literals here.

24. How Do You Handle Errors in JavaScript?

Use try-catch blocks to catch errors and prevent crashes. You can also throw custom errors using the Error object and handle them gracefully. Deep dive into error handling here.

25. Implement a Function to Flatten a Nested Array

Flattening turns a multi-dimensional array (like [1, [2, [3]]]) into a single-level array ([1, 2, 3]). Use Array.prototype.flat() or recursion. Code example and explanation here.

26. Implement an LRU Cache

An LRU (Least Recently Used) cache removes the least accessed items when it reaches its size limit. It’s useful for optimizing memory in apps. Learn more about LRU cache implementation here.

27. What Are Closures in JavaScript?

Closures are functions that "remember" the environment where they were created. They’re useful for creating private variables or encapsulating logic. Deep dive into closures here.

28. Explain the Event Loop in JavaScript

The event loop handles asynchronous tasks. It checks the call stack and task queues (like the callback queue or microtask queue) to decide what to run next, ensuring non-blocking execution. Learn more about the event loop here.

29. What is the Difference Between var, let, and const?

var: Function-scoped, can be redeclared, and is hoisted.
let: Block-scoped, cannot be redeclared, and is hoisted but not initialized.
const: Block-scoped, cannot be redeclared or reassigned, and is hoisted but not initialized.

See more about var, let, and const here.

30. How Does Hoisting Work in JavaScript?

Hoisting moves variable and function declarations to the top of their scope during compilation. However, only the declaration is hoisted, not the initialization. For example, var x; is hoisted, but x = 5; is not. Learn more about hoisting here.

31. What is the Purpose of setTimeout and setInterval?

setTimeout delays the execution of a function by a specified time, while setInterval repeatedly executes a function at regular intervals. Both are used for scheduling tasks in JavaScript. Deep dive into timers here.

32. Explain How to Use the Fetch API

The fetch() method is used to make network requests. It returns a promise that resolves to a Response object, which can be parsed as JSON, text, or other formats. Learn more about the Fetch API here.

33. What is a Service Worker in the Context of PWAs?

A service worker is a script that runs in the background, enabling features like offline access, caching, and push notifications in Progressive Web Apps (PWAs). Deep dive into service workers here.

34. Describe How to Implement Deep Cloning of an Object

Deep cloning creates a copy of an object, including nested objects. Use structuredClone() for modern browsers or write a recursive function to copy all properties. Learn more about deep cloning here.

35. What Are Modules in JavaScript? How Do You Use Them?

Modules let you split code into reusable files. Use export to share functions or variables and import to use them in other files. Deep dive into JavaScript modules here.

36. Explain the Concept of this Binding with Examples

The value of this depends on how a function is called. Arrow functions inherit this from their parent scope, while regular functions depend on the calling context. Learn more about this binding here.

37. What is a Closure? Provide an Example

A closure is a function that remembers its outer scope, even after the outer function has finished running. For example, a function inside another function can access its parent’s variables. Deep dive into closures here.

38. How Do You Prevent Default Behavior of an Event?

Use event.preventDefault() to stop the default action of an event, like preventing a form from submitting or a link from navigating. Learn more about event prevention here.

39. What Are Arrow Functions, and How Do They Differ from Regular Functions?

Arrow functions are a shorter syntax for writing functions. Unlike regular functions, they don’t have their own this and are great for callbacks. See more about arrow functions here.

40. Explain the Concept of Promise Chaining

Promise chaining links multiple .then() calls, where each promise resolves and passes its result to the next. This creates a sequence of asynchronous operations. Learn more about chained promises here.

41. What is the Purpose of Object.create()?

Object.create() creates a new object with a specified prototype. It’s useful for implementing inheritance without using classes. Code example here.

42. How Can You Check if an Object is an Array?

Use Array.isArray() to check if a value is an array. It works reliably across different contexts.

43. What Are IIFE (Immediately Invoked Function Expressions)?

IIFEs are functions that run immediately after they’re defined. They’re used to create private scopes and avoid polluting the global namespace. Oficial documentation.

44. Explain How to Create a Custom Event in JavaScript

Custom events are created using the CustomEvent constructor and dispatched with element.dispatchEvent(). They’re useful for communication between components. CustomEvent documentation.

45. What is JSON, and How Do You Parse It?

JSON (JavaScript Object Notation) is a lightweight data format. Use JSON.parse() to convert a JSON string into an object and JSON.stringify() to convert an object into a JSON string. Working with JSON.

46. Describe How to Implement a Simple Event Emitter

An event emitter is a utility for managing events. It allows you to register listeners and emit events, often implemented using an object to store event callbacks. Building a Simple Event Emitter.

47. What Are Weak References in JavaScript?

Weak references allow access to objects without preventing them from being garbage collected. They’re useful for managing memory in caches or maps.

48. How Do You Optimize Performance in Large-Scale Applications?

Optimization techniques include debouncing, throttling, lazy loading, code splitting, reducing DOM operations...

49. Explain How to Use localStorage and sessionStorage

localStorage and sessionStorage are key-value storage mechanisms in the browser. localStorage persists data across sessions, while sessionStorage clears data when the tab or window is closed.

50. What Are Some Common Security Issues in JavaScript Applications?

Common issues include XSS (Cross-Site Scripting), CSRF (Cross-Site Request Forgery), and insecure input handling. Mitigate them using content security policies, input sanitization, and secure coding practices. Check the top 9 JavaScript Security Vulnerabilities in 2025.

Do You Care About Commit Messages?

Mathias Falci — Wed, 15 Jan 2025 18:15:02 +0000

Have you ever read a commit message that left you wondering what the developer was thinking? Commit messages are often overlooked, but they play a crucial role in collaboration and project maintenance.

Do you care about your commit messages? You should. In this post, we'll dive into why good commit messages matter, explore tools to help craft them, and discuss how AI can assist in improving clarity and consistency.

1. Why Commit Messages Matter

In summary, commit messages are more than just a formality, they are an essential tool for keeping your project organized and making collaboration efficient. They serve as the foundation for collaboration, debugging, and documentation. Here’s how:

🤝 Collaboration: Help team members understand the context of changes made to the code. When working in a team, clear commit messages allow others to quickly grasp the intention behind a change, reducing misunderstandings and making collaboration smoother.
🔍 Debugging: During the debugging process, commit messages act as a vital reference to trace back issues. A well-written commit message provides insight into what was modified, which helps in identifying when and where problems were introduced.
📄 Documentation: Commit messages serve as a historical log for the project. As the project evolves, the commit history becomes a valuable resource, showing how the code has changed over time and providing context for future developers who may need to maintain or extend the project.

2. A Great Commit Message

A good commit message should prioritize clarity, context, and conciseness. It should clearly explain the change in a straightforward way, avoiding ambiguity. Focus on the "why" behind the change to provide context and explain the reasoning, not just the "what" was done.

Additionally, keep the title short (around or even under 50 characters) for a quick summary, and add further details in the body only when necessary to provide more context. Ensuring that your teammates and even your future self will thank you.

Good

feat: add user profile page for better account management
chore: upgrade react version to 19.0
Fix typo in checkout process causing validation error
Update footer with new contact information per marketing team request

Bad

fixed issue
Updated UI elements
whoops, fixed the bug now
WIP, added a new feature
[empty_message]

3. Tools for Crafting Better Commit Messages

There are a few different commit message conventions available (e.g conventionalcommits.org, and these can vary from company to company, each with its own set of rules and formats.

The primary goal of these conventions is to improve the readability and clarity of the project's commit history as we already talked about. Futhermore, to ensure a consistent message format, tools like Commitizen and Husky can be useful.

If you're VSCode user, consider installing the Git Blame extension (or GitLens). It's a great example of how clear and informative commit messages can benefit future developers. Those plugins shows who made a particular change, when it was made, and includes the commit message inline for quick reference.

This feature is incredibly useful when troubleshooting bugs or tracking the history of changes. Imagine you're hunting down a bug and suddenly realize - wait, that was me, three years ago?! Yes, three whole years! And no, you didn’t just time travel. This extension can reveal some pretty wild surprises 😂.

Futhermore, AI tools can greatly assist in crafting commit messages. If you're unsure what to write, simply ask an AI tool like ChatGPT. It can help you refine your thoughts, suggest clear phrasing, and ensure your message is easy to understand.

GitHub Copilot and Codeium already offer commit message suggestions based on file changes, saving time and maintaining relevance. These tools can generate messages automatically by analyzing the diffs in your code.

4. Wrapping Up

Commit messages might seem like a ~~small detail that doesn’t always deserve our attention~~, but it’s important to remember that big things are often built from small, carefully crafted pieces. While I don’t want to dive into philosophy here, the real value often lies in the simple things. If we take care of the small details, everything else tends to fall into place.

So, take a moment to consider your commit messages as a small but meaningful investment in the future of your project. Ask yourself: Will my teammate understand this? Put yourself in their shoes and think about the message through their perspective. It’s a simple exercise, but it can make a world of difference, both in coding and in life.