---

Write the code → run it → observe the results → make some tweaks → run it again → check the results → and repeat—this has always been the revolving wheel of every developer before finishing a project. Yet, there are countless moments when a developer struggles to recall their thoughts during this process.

Have you ever stared at a piece of code you wrote months ago, wondering how you brought it to that end? Or found yourself stuck on a problem you’ve solved before but can’t remember how? Both of these are common frustrations in the life of a developer.

These situations are all too familiar, reminding us how human memory can fail. As the saying goes, “A short pen is better than a long memory.” Keeping a developer’s journal or log can come in handy, saving the day for the coder in distress and providing a huge solution to forgotten fixes and lost insights.

In this article, we’ll explore why every developer should make logging their work a habit and how it can make programming easier, more productive, and more rewarding.

---

Is it worth it or a waste of time for programmers to keep a running log while coding?

Is taking down notes while coding just a waste of time?

It depends.

• Do you copy and paste code without truly understanding it?

• Do you blindly follow along with lessons/tutorials without questioning them?

• Do you just depend on what your tutor said without engaging with other materials?

• Do you engage in these actions and are still distracted by something else?

If you are doing these things. Then YES, you're writing "spaghetti code"—it's a waste of time.

But…

• Do you leave comments in your code, highlighting key variables and logical flow?

• Do you rewrite concepts in simpler terms, provide more explanations, and ensure clarity?

• Do you first write your algorithm in comments before diving in to write the actual code?

• Do you engage deeply with the problem, trying to break it down mentally?

• Do you record anything that isn’t immediately clear within the code?

• Do you check your work often and note bugs to fix in the code, or do you brainstorm new features to include and, if bugs are few, write them as possible “next steps” in your code?

• Do you bookmark helpful sites quickly—whether in your browser or directly within your project notes?

If you answered yes, then you're writing well-structured, maintainable code—you're not wasting time!

This is a basic learning technique. Writing notes forces your brain to process what you’re penning (putting) down. Processing that information signals your brain that it matters. Recognizing it matters helps your brain retain it.

Even while coding, I take down notes in VS Code, using Markdown. I take thorough notes, but that’s just how I absorb things generally, whether it’s coding or otherwise. Having code snippets in my notes is simply priceless. It gives me a log of something I found significant (while coding) that I didn’t want to pause my flow to tackle right then. Later, when I’ve got spare time, I revisit my notes. There are usually tasks left to complete the work. Here’s why it’s valuable and worth doing and why it’s not.

The Pros:

• Like any skill, the more notes you take and the more diverse your thoughts and insights on the topic, the sharper you'll be able to recall it in time of need.

• You can dig into and master ideas more deeply than if you just grind through problems or drills.

• You’ve got notes you can revisit that make sense since you wrote them.

• You can track your progress and learning journey over time.

• You can refine your notes and grasp of ideas as your skills expand, even connecting ideas you first learned separately.

The Cons:

• It can take up a lot of time and pull you away from hands-on coding practice.

• You might just pile up a ton of notes that end up barely useful down the road.

• Some notes you’ve made could lose relevance as certain tools or functions fade out.

• It’s often much simpler to look up articles or guides online to figure out stuff you’re stuck on.

So, don’t obsess over your notes. Don’t let them slow you down or derail you from your track, but do take them. A brief peek on a note can jog your memory about what you were pondering earlier, making you revisit the idea. This will either solidify your understanding or remind you of a task to handle. Try typing immediately, boil ideas down to bullet points where possible, and don’t hesitate to cut the note-taking off if necessary!

For instance, my notes did include an in-depth breakdown of topics from the freeCodeCamp curriculum, plus links to outside resources and posts I found handy when I first encountered them. I did find them helpful and checked back occasionally. For example, when I was battling to craft a recursive function for a coding project, I flipped right back to my notes on the ‘recursion’ part of the JS course, where I had multiple code samples with step-by-step breakdown of how they functioned and reasons for recursion functions there.

Write your note and keep going. Look it over later when you’ve got spare time. However, hold onto only the notes that matter. Ditch the ones that don’t anymore. And the more you practice note-taking, the better you’ll get at it. The sharper you’ll become at nailing the key points and skipping the fluff.

Everyone’s different, but it’s obvious that the best way to learn is simply by doing. Move fast, iterate, and improve!

---

Developer logs and/or notes! what do you use?

Developers use logs to document every change made within their projects in an organized manner. It is written for other users, team members, or clients to explain new features resolve problems and update any sections in the software programs. It can include lines like “Added save button” or “Fixed a bug that crashed the app.” It is normally carefully laid out with strict adherence to format—down to version numbers and dates—and kept in a similarly titled CHANGELOG.md file.

Conversely, notes have an informal and personal tone. They are written for the developer's personal use, serving only as momentary reminders or offhand thoughts—like "Test if the login is working" or "Try adding dark mode." They don't have to be understandable by anyone else; they are commonly disorganized, scribbled-in-place in a notebook, written in an app or discarded in an unrelated document.

• In short: a developer’s log is official and shared, while notes are casual and private.

That said, how you choose to keep these records matters. To be perfectly honest, nothing beats the good old-fashioned pen and paper, whether it’s for a log or a note. It’s a proven fact that your brain retains more when you write things down by hand.

But, like me, I bet a lot of people are terrible at keeping track of physical copies of documents. I’ve lost papers more times than I can count and sometimes jumble them up when I’m in a rush. That’s the only reason I’ve switched to using OneNote. I still use a stylus, so it feels pretty similar, and honestly, I sometimes prefer it—switching colors is fast, and I can stick pictures or PDF files right into my notes.

Experience tells us that if you’ve run into a problem once, you’ll probably face it again soon, so keeping records pays off quickly. Keeping both logs and notes matters for tracking progress, solving problems, and saving work for later or for teamwork. They come in different forms, each with its purpose—whether it’s for personal reminders, team updates, or checking on a system. Below is the summary of some common types of developer logs and notes and how they’re used.

Summary of different types of developer’s log and notes

These types of logs and notes serve distinct purposes in the software development lifecycle, from day-to-day coding to long-term project management. Developers often use a combination of these, depending on the task, team size, and project requirements.

What should be included in a running log/note?

Apart from the software development field, maintaining a running log or notes of your work or project can help track your work, identify patterns, and improve efficiency. However, being a developer, below are essential elements to be found in a running log:

• When you worked - Write the date and time when you worked on the particular project.

• What you did today – Features worked on, problems faced.

• New things learned – Cool tricks, useful code.

• Errors and fixes – Problems and how you solved them.

• Project choices – Why you did things a certain way.

• Time-saving tips – Shortcuts, tools that help.

• Meeting notes – Important points and next steps.

• Personal reflections - Any thoughts or lessons learned.

• Future ideas – What you plan to do next.

• Helpful resources – Websites, books, tools you used.

By keeping these details in your log, it helps you remember what you did, fix things faster, and improve your skills as a developer!

Establishing a consistent note-taking habit

Select a tool that suits you

Pick a note-taking tool that’s simple and convenient for you—whether it’s a physical notebook, an app on your phone (like Notion or Google Keep), or a markdown file on your device. If you enjoy writing by hand, grab a notebook just for this purpose. However, go with the tool that feels natural to you so you’ll keep using it.

Start small

Do not attempt to write everything at first. Begin with just one or two things—like what you recently worked on and one problem you encountered. Try to keep it brief and simple.

Set a time to write

Set a time for you to take down notes. You can do this right after completing a particular task or at the end of the day. If you do it at the same time every day, you stand a better chance for your brain to automatically remind you of writing at a particular time.

Keep It short

Write short notes—1 or 2 sentences are fine. For example: "Fixed a bug in the login. Had to update the password check." You can add more later if you want.

Make a simple template

Create an easy format to follow every time, like:

1. What I did:

2. Problem:

3. Fix:

This keeps you from wondering what to write.

Put your tool where you can easily access it

Keep your notebook, app, or file open or nearby while you code. If it’s right there, you’re more likely to use it.

Tie it to your coding

Connect note-taking to something you already do. For example, write a note every time you finish a task or push code. It’ll feel like part of your work.

Check your notes weekly

Once a week, look back at what you wrote. Seeing how your notes help you remember stuff or fix things faster will motivate you to keep going.

Be patient

It takes time to make this a habit (maybe a few weeks). If you forget sometimes, don’t worry—just keep trying. You’ll get better at it!

And lastly, give yourself a small treat —like a snack or a break—after you take notes for a few days in a row. It makes it fun to stick with.

As you move through this coding process, your note-taking habits shift from remembering topics to intuitively identifying patterns. Over time, you'll rely less on detailed notes and more on your own understanding. Instead of asking, "How does this work?" you'll start thinking, "That's a familiar approach—I see how it fits." At this stage, taking notes becomes less about documentation and more about honing your problem-solving skills.

Common excuses lazy developers make and how to beat them

Writing logs or notes is something developers often need to do, however, it’s not always easy. These struggles can make logging or note taking feel like a hectic work instead of a helpful habit. However, there are simple ways to overcome these hurdles. Let’s look at these common issues and how to beat them.

I don’t have the time.

Write down bullet points as you go. No need for a full essay—just a few words to remind your future self what’s up. A simple "Fixed API auth issue—missing token" can save you hours later.

I don’t think I can be consistent with it.

Set a daily reminder or use habit trackers. Even if it’s just one sentence a day, building the habit matters more than the length of your notes.

There are too many tools.

Pick one or two tools and stick with them. Whether it’s Notion, Obsidian, or plain old sticky notes, “the best tool is the one you actually use”.

I get overwhelmed with too much info.

Instead of writing everything down, summarize and filter. Ask yourself, "Will I actually need this later?" If not, let it go.

I’ll do it later.

Later = Never. Start small now—just one note per day, do not procrastinate. Your future-you will be proud of your actions today.

I don’t need it, my code is self-explanatory.

Maybe today, but will it still be clear in six months? Comments in code can be helpful but notes add context, like why you chose a certain approach—not just what you did. This can later be collated into a professional documentation.

Conclusion

Keeping a developer’s log has some great benefits—it helps you track your progress, remember important details, and even boost your problem-solving skills. If you’re new to this, don’t worry about doing it perfectly right away. Why not try a simple one-week challenge? That way, you can see how it works for you without any pressure. A single note at the end of each day can just be all it takes to make a difference.

Why not take the first step today? Pick a simple tool or template and begin logging your work. Maybe jot down what you worked on this afternoon or a quick idea you had. I’d love to hear from you too if you’ll share it. Or, if you have a system that already works for you, please do share with us, your note-taking tips in the comments below! If you’re looking for a place to begin, try a basic tool like a notebook or a template from any site you like.

I’m looking forward to a future where you never struggle to remember how you solved a tricky bug or implemented a key feature some months ago. With a developer’s log, that future is within reach. Give it a shot!