Alright, let’s talk about this whole “Brooke Hundley” situation I ran into a while back. It wasn’t some big company-wide thing, more like a specific way of working I picked up, or rather, tried to pick up, because of her.
So, I joined this team, right? And Brooke Hundley was one of the senior people there. Not my direct boss, but everyone kinda knew her style. She had this very particular way she wanted things documented, especially for the codebase she managed.
Getting Started with Her ‘System’
When I got assigned my first chunk of work that touched her area, my team lead basically said, “Yeah, just try and follow the Brooke Hundley format for the notes and commit logs.” Easier said than done, let me tell you.
First, I had to figure out what that even meant. Dug through some old project wikis and looked at her previous check-ins. It was… detailed. Very detailed.
- She had specific templates for documenting new features.
- Code comments needed to follow a certain pattern, explaining the ‘why’ not just the ‘what’.
- Commit messages were practically essays, linking back to specific requirements or bug tickets.
The Actual Process – Trying to Keep Up
So, I started coding my part. And honestly, keeping up with her documentation style while also trying to just get the code working? It felt like double the work at first. I’d finish a function, then spend like 20 minutes just writing the comment block exactly right. Then I’d stage my changes, and agonize over the commit message to make sure it had all the bits she seemed to prefer.
I remember one time spending nearly an hour just setting up the wiki page for a relatively small change I made. Finding the right parent page, using her preferred formatting for code snippets, making sure all the links were correct. It felt tedious. I was thinking, “Man, is this really necessary?”
My initial commits? Pretty sure they weren’t quite up to her standard. Got a few polite nudges in code reviews, like “Hey, could you add a bit more context here?” or “Make sure to link the ticket in the commit.” It wasn’t mean or anything, just… persistent.
What Came Out of It
But here’s the thing. After a few weeks of this, something clicked. When I had to go back and fix a bug in something I wrote a month earlier? Her system actually made it way faster. The detailed commit log pointed me straight to the relevant change. The documentation page gave me the context I’d forgotten.
And when I had to pick up a piece of code someone else had written using her method? It was so much easier to understand what was going on. You didn’t have to guess the original intent; it was usually written down somewhere.
So, yeah. It was a bit painful to adopt initially. Took more time upfront, definitely. And I can’t say I follow it quite as religiously now in my current role. But the core idea? Thinking about the next person who has to touch your work? That stuck with me. Putting in that extra effort to be clear and document properly – I definitely learned the value of that, largely thanks to trying to keep up with the “Brooke Hundley” way back then. It wasn’t magic, just disciplined work, and it paid off later.
