I compared my own GitHub commits from 2025 and 2026, here's what actually changed

I went through my own repos instead of trusting my memory of "I've gotten better." Pulled commit history and file structure from two projects a year apart: GeekMate from 2025, and CodePersona from 2026. Same person, same general skill level going in. What actually changed is more specific than "I write cleaner code now."

1. Commit messages stopped being a log and started being a record. My 2025 commits read like fixed handling, ui, .., accurate at the time, useless six months later. My 2026 commits explain the change and the reason: what was refactored, which components were affected, why a utility function got added. The difference isn't verbosity, it's that I started writing commits for a reader who wasn't in my head when I made the change, which, most of the time, is just me a year later.

2. The project root got honest about its own tooling. GeekMate's root is a package.json and a src folder, nothing tells you how the project is linted, typed, or built until you open it and guess. CodePersona's root has ESLint config, TypeScript configs split by concern, a components manifest. None of that is decoration. It means someone, including me, returning after months away, knows the rules before writing the first line.

3. Files stopped explaining themselves and started being self-evident. GeekMate has comments like // this is a readymade middleware, which helps us read the JSON data, because I was narrating what the code did since the code alone didn't make it obvious. CodePersona's components don't have those comments, and they don't need them: a typed props interface and a component named for what it renders say the same thing without the narration. Fewer comments turned out to be a sign of better naming, not less care.

4. Structure replaced convention-by-memory. In 2025 I knew where things went because I'd put them there. In 2026, hooks live in hooks/, shared logic in lib/, external integrations get their own folder, and the layout tells you the architecture before you've read a single file. That's the actual marker of the year: I stopped trusting myself to remember the plan, and started encoding the plan into the folder structure so it didn't need remembering.

None of this is about GeekMate being "bad": it shipped, people used it, it did its job. It's that code quality, for me, turned out to mean writing for someone who doesn't have the context I have right now, usually future me. Every change above is really the same change, applied at a different layer.