Lessons from my month-long GitHub commit streak

As a full-stack developer, I‘ve always been fascinated by the power of consistent practice and the compounding effect it can have on skill development. I‘ve seen it firsthand in my career – the developers who commit to continuously learning and refining their craft are the ones who tend to go the furthest.

But like many developers, I often struggled with procrastination and finding the motivation to code outside of work, especially when faced with the constant barrage of new frameworks and tools to learn. It‘s easy to fall into the trap of feeling overwhelmed and putting off learning for "someday."

So on October 1st, I decided to take drastic action by committing to the #100DaysOfCode challenge. The rules were simple but daunting: code for a minimum of 1 hour every day for 100 days straight and publicly commit your progress on GitHub.

While 100 days felt too intimidating for me, I decided to start with a smaller goal: make at least one GitHub commit to a personal project every day for 30 days straight, no matter what. I wanted to build a consistent coding habit, rapidly expand my skill set, and see how far I could push myself as a developer.

Well, I‘m thrilled to report that yesterday marked day 30 of my challenge, and the impact on my development skills has been immense! Here are some of the key lessons and insights I took away from my month of coding every single day:

Committing to daily practice removed the friction of getting started

One of the biggest obstacles I‘ve faced as a developer is simply starting. After a long workday of coding, the last thing I feel like doing is coming home and coding more. It‘s so tempting to make excuses about being too tired or needing to relax.

What surprised me most about this 30-day challenge is that the simple act of committing to coding every day took the decision-making out of the equation. No more internal debates or negotiations. Coding become a non-negotiable part of my daily routine, as automatic as brushing my teeth.

On the days when I was really dreading it, I gave myself permission to only code for 30 minutes. But once I got started, I was often surprised to find myself getting absorbed in the work and happily coding away for hours. The hardest part is always opening up your editor and writing those first few lines of code.

This experience really drove home the power of habit and the "2-minute rule" – commit to just 2 minutes of coding, knowing that momentum will often carry you much further. Over time, daily coding became almost effortless, the default instead of the exception.

Momentum and compound growth are real

Prolific writer and artist Austin Kleon once said "When you don‘t feel like working, just show up and see what happens." This challenge was living proof of that ethos and the power of small gains compounding over time.

By carving out focused time to code every day, I was able to make steady forward progress and build serious momentum. Concepts started clicking into place more quickly. Debugging became more intuitive. I was able to pick up where I left off and keep building on the foundation of the previous days.

Image credit: James Clear

Let‘s do the math. The average developer spends 52 minutes per day coding. Assuming you code Monday through Friday, that‘s 260 minutes per week (4.3 hours). Multiply that by 52 weeks and you get 224 hours of coding per year.

Now imagine you committed to coding for 60 minutes every single day, 365 days per year. That‘s 365 hours of practice, a 60% increase! Compounded over a career, those extra hours can be the difference between a junior developer and a senior architect.

"Small, seemingly insignificant steps completed consistently over time will create a radical difference." – Darren Hardy

Quantity leads to quality (and building in public is a game changer)

You‘ve probably heard the old adage that it takes 10,000 hours to master a skill. What‘s less commonly mentioned is that a big part of those hours is producing a high volume of work, even if a lot of it isn‘t great.

Throughout this challenge, I committed to shipping code and pushing to GitHub every day, no matter how small or ugly it was. This often meant publishing half-finished features, prototypes full of bugs, and code that made me cringe. But by doing so, I was able to get rapid feedback, quickly identify areas for improvement, and make many small iterations.

This approach of "building in public" was incredibly motivating. Knowing that other developers could (and did) look at my code kept me accountable to keep going. I also found myself connecting with other developers and getting great suggestions for improvement.

And when I did occasionally miss a day, I refused to let it derail the entire challenge. I simply got back on track the next day and kept the streak going.

"The ceramics teacher announced on opening day that he was dividing the class into two groups. All those on the left side of the studio, he said, would be graded solely on the quantity of work they produced, all those on the right solely on its quality.

His procedure was simple: on the final day of class he would bring in his bathroom scales and weigh the work of the "quantity" group: fifty pound of pots rated an "A", forty pounds a "B", and so on. Those being graded on "quality", however, needed to produce only one pot — albeit a perfect one — to get an "A".

Well, came grading time and a curious fact emerged: the works of highest quality were all produced by the group being graded for quantity. It seems that while the "quantity" group was busily churning out piles of work — and learning from their mistakes — the "quality" group had sat theorizing about perfection, and in the end had little more to show for their efforts than grandiose theories and a pile of dead clay."

• Art and Fear by David Bayles and Ted Orland

Metrics and progress tracking were crucial for maintaining motivation

One of the most powerful aspects of this challenge was the visual progress tracking. Every day that I made a commit, a green square would appear on my GitHub contribution graph. Over time, I had a long unbroken chain of green squares that I became determined not to break.

Image credit: GitHub

This simple visual cue became a strong motivator and point of pride. I also used a habit tracking app to record my progress and time spent coding each day. Watching those numbers tick up over time was incredibly satisfying.

"What gets measured gets managed." – Peter Drucker

I also gained motivation from joining a community of other developers participating in #100DaysOfCode. Seeing their progress and projects kept me inspired to keep going. On days when I didn‘t feel like coding, I would browse through the #100DaysOfCode hashtag on Twitter and instantly feel a jolt of motivation to get back to work.

The challenge taught me how to learn more efficiently

One unexpected benefit of daily coding was that I became much more adept at quickly picking up new concepts and technologies. Through repeated exposure and application, I started to notice common patterns and abstractions that made learning new things easier.

I also developed a system for quickly getting up to speed with a new tool or language:

1. Read the official docs and tutorials to get a high-level overview
2. Browse GitHub for simple starter projects I could dissect and learn from
3. Watching conference talks and video tutorials for practical examples and best practices
4. Completing interactive coding challenges and exercises to cement the fundamentals
5. Referencing the documentation frequently as I built small projects with my new skills

By following this formula, I was able to add a number of new tools to my developer toolkit, including: React, Node.js, MongoDB, Docker, and AWS. I was able to quickly get over the "hump" of feeling overwhelmed by a new technology and start applying it confidently.

The projects I shipped and skills I gained

So what did I actually build during those 30 days? Here‘s a summary of the the key projects I shipped and skills I leveled up:

• Twitter-bot: A Node.js Twitter bot that tweets out daily code tips. I learned how to authenticate with the Twitter API, build a scheduled Node.js script, and deploy to Heroku.

• Weather app: A simple React app that displays the weather forecast for a given location. I learned the fundamentals of React components, state management, and data fetching.

• Task manager API: A RESTful API for managing a to-do list application. I learned how to set up a Node/Express server, define routes, and perform CRUD operations with MongoDB.

• URL shortener: An application that shortens long URLs into compact, shareable links. I learned how to build a full-stack application with Node, Express, and MongoDB and deploy it to Heroku.

• Developer portfolio: I revamped my personal portfolio site as a React application and added detailed case studies for my major projects. I became much more comfortable with React and CSS.

In addition to these projects, I also completed a number of coding exercises, algorithm challenges, and tutorials. I gained experience with test-driven development, AI/ML libraries like Tensorflow, and cloud platforms like AWS.

But beyond any specific project or tool, I gained confidence in my ability to learn and grow as a developer. I now have a proven system for attacking any new skill or technology. I know that with focused, consistent effort, I can become proficient at anything I set my mind to.

Tips for succeeding with your own 30-day challenge

Feeling inspired to start your own 30-day coding challenge? Here are some tips for success:

1. Set a clear, achievable goal: Aiming to complete #100DaysOfCode right off the bat might be too daunting. Start with a smaller goal, like coding for 30 minutes every day for 30 days. The key is to make it achievable but still challenging enough to push you.

2. Build a streak: Focus on just showing up and putting in the work every day, no matter how small. Over time, you‘ll build a long streak that you‘ll become determined not to break.

3. Track your progress: Whether it‘s pushing commits to GitHub, crossing off days on a calendar, or logging your hours, find a way to visually represent your progress. Make it satisfying to see your hard work adding up.

4. Start small and scale up: On days when you‘re struggling with motivation, tell yourself you only have to code for 5 minutes. Starting small helps you overcome that initial resistance, and often you‘ll find yourself getting into a flow and working for much longer.

5. Focus on the process, not the results: Your projects don‘t have to be perfect or even complete. What matters is that you showed up and put in the work. Trust that the skills and results will come with consistency.

6. Embrace "building in public": Share your progress and projects with the developer community, whether it‘s on GitHub, Twitter, or your own blog. You‘ll be surprised at the support, accountability, and motivation you‘ll gain by being open about your journey.

7. Celebrate your wins: Take time at the end of each week to reflect on what you accomplished and learned. Give yourself credit for your efforts and celebrate your progress, no matter how small.

Remember, the goal is progress, not perfection. You might not become a world-class developer in 30 days, but you‘ll be amazed at how much you can achieve with focused, consistent effort.

Conclusion and looking ahead

In many ways, this 30-day challenge was just the beginning for me. It helped me cultivate a consistent coding habit, demystify the process of picking up new skills, and prove to myself what I‘m capable of as a developer.

I‘m still in awe of how much I was able to learn and accomplish in such a short time period. But more than that, I‘m grateful for the mindset shift this challenge sparked. I now see myself as a lifelong learner, constantly seeking out new challenges and opportunities to grow.

Looking ahead, I‘m planning to continue my streak and complete the full #100DaysOfCode challenge. I‘m excited to see how much more I can learn and build with another 70 days of focused, unbroken effort.

Even more than that, I‘m committed to maintaining a daily coding habit for the rest of my career, no matter how experienced I become. In an industry that changes as rapidly as software development, continuous learning is essential for staying relevant and moving forward.

"Learn to love the pain. You‘re going to encounter it often if you plan to grow." – Rich Hickey, Creator of Clojure

So if you‘re feeling stuck or wanting to rapidly expand your skills as a developer, I encourage you to start your own 30-day challenge. Start small, focus on consistency, and watch as the compound effect of daily practice turns you into the developer you‘ve always wanted to become.

And hey, you might just find that you enjoy the pain a little. There‘s nothing quite like the satisfaction of looking back at a month of hard work and realizing how far you‘ve come.

Here‘s to many more months of coding every single day and embracing the joy of lifelong learning. Happy coding!