Have you ever finished a coding session, leaned back in your chair, and thought “I should write about this”? And then… never did? Yeah, me too. That’s exactly the problem I set out to solve on January 14th when I had a simple but frustrating realisation: developers do interesting work, but we’re terrible at documenting it.

The issue isn’t that we don’t want to share our work. It’s that by the time we sit down to write a blog post (if we ever do), we’ve lost the narrative. The real-time decisions, the unexpected blockers, those “aha!” moments when something finally clicks - all of that gets filtered through retrospective memory and comes out as sanitised technical documentation instead of the messy, human story of how software actually gets built.

So I decided to build BlogLog: a tool that captures the development story as it happens, with zero friction.

The Core Insight: Replace, Don’t Add

The biggest decision I made early on was that BlogLog had to be a replacement, not an addition to existing workflows. Instead of asking developers to remember to run bl note "something interesting", I designed it around bl commit - a command that completely replaces git commit -m.

When you run bl commit "fix user authentication bug", two things happen:

1. Your commit and message get logged to a timeline with timestamp
2. git commit -m "fix user authentication bug" runs automatically

This was crucial. The tool had to slip seamlessly into existing muscle memory. No new habits to form, just a natural evolution of something you’re already doing dozens of times per day.

Claude Code: The Perfect Development Partner

I used this project as my introduction to Claude Code, and honestly, it was a revelation. About 40 minutes in, I captured this note: “Loving Claude Code - this is effortless to start, but I can see how I’ll be able to step in when the snafu’s happen. So powerful.”

What struck me most was how Claude Code gives you space for documentation during the build process, not after. I could describe what I wanted, watch it get built, reflect on the decisions, and capture those thoughts in real-time. It’s like having a incredibly capable pair programming partner who never gets tired of explaining their reasoning.

The meta aspect was perfect: I was using BlogLog to document building BlogLog itself. Every breakthrough, every small win, every “oh wait, I need to handle this edge case” moment got captured in the tool I was creating.

Building in Public, One Commit at a Time

The development timeline tells the story better than I could reconstruct from memory:

• 7:20 PM - Initial project setup with CLI, web, and shared packages
• 7:25 PM - CLI foundation complete with commit, note, win, and blocker commands
• 7:26 PM - First major win: bl commit works end-to-end
• 7:33 PM - Web interface routes built
• 7:53 PM - Conversation logging and AI summary working
• 8:46 PM - Blog post generation page complete
• 9:02 PM - Pushed to GitHub - project complete!

What’s wild is that entire journey - from idea to working product - took about 3 hours, including a TV break. The combination of Claude Code’s scaffolding ability and BlogLog’s real-time capture meant I could move fast while still documenting everything.

The Technical Decisions That Mattered

A few key architectural choices shaped the whole project:

CLI-first design: The command line tool is the primary interface. The web interface is for viewing timelines and generating blog posts, but the day-to-day interaction happens in the terminal where developers already live.

JSON file storage: Instead of a database, everything gets stored in .bloglog/timeline.json in your project directory. This keeps it git-friendly and means your development narrative travels with your code.

Multi-project support: Each project gets its own .bloglog/ directory, so you can document multiple projects without them interfering with each other.

AI integration: The web interface connects to Claude to generate blog posts from your captured timeline, turning your development notes into coherent narratives.

The Recursive Nature of Meta-Tools

The most satisfying part of this project was experiencing the recursive validation loop. As I built BlogLog, I used BlogLog to document building BlogLog. Every feature I added immediately proved its own value because I was using it in real-time.

When I added the “win” command for capturing breakthroughs, I immediately used bl win "Claude Code gives space for documentation during the build process" to document the insight I was having about my development experience.

When I finished the blog generation feature, I could immediately test it on the very timeline I’d created while building it.

What I Learned About Development Tools

Building BlogLog taught me that the best development tools are invisible. They don’t interrupt your flow - they enhance it. The zero-friction principle isn’t just nice to have, it’s essential. If a tool requires conscious thought to use, it won’t get used consistently.

I also learned that AI-powered development isn’t about replacing developers - it’s about augmenting our ability to think through problems and iterate quickly. Claude Code let me focus on the design decisions and user experience while handling the implementation details.

Next Steps: From Tool to Habit

BlogLog is complete as an MVP, but the real test is whether it becomes a natural part of my development workflow. Can bl commit actually replace git commit in my muscle memory? Will I remember to use bl blocker when I hit roadblocks?

The early signs are promising. Writing this blog post from the timeline BlogLog generated feels like closing a loop - using the tool to tell the story of building the tool.

If you’re interested in trying BlogLog yourself, it’s up on GitHub. And if you do try it, I’d love to read the blog post it helps you write about your own development adventures.

Because the best way to get better at building software isn’t just to build more software - it’s to reflect on what you’re building while you build it.

---

This blog post was generated from a BlogLog timeline capturing the real development session described above. Meta? Absolutely. Useful? That’s what I’m hoping to find out.