Quick Fix: Tracking Design Intent with Dev Journals

Quick Fix: Tracking Design Intent with Dev Journals

“Ugh, this is broken,” Alice groaned, staring at the flickering enemy AI.

Bob sighed. “Tell me about it. I spent all morning on this new patrol pattern, and now they’re just running into walls.”

“It’s more than that,” Alice said, pointing to the enemy’s attack behavior. “Remember how we wanted the goblins to only throw rocks when the player was at a medium distance? Now they’re chucking them point-blank.”

Bob frowned. “Yeah, that was the idea. I thought I implemented that correctly.” He scratched his head. “Wait… did we even write that down anywhere?”

Alice’s face fell. “I… don’t think so. We talked about it, but it was weeks ago. I vaguely remember something about a design doc, but I can’t find it.”

“Great,” Bob said, running a hand through his hair. “So now we have to spend hours reverse-engineering our own design decisions. Again.”

The Price of a Forgotten Vision

This scenario, or one very much like it, plays out in indie dev teams (and solo dev projects!) all the time. A great idea is born, discussed, and (hopefully) implemented. But as weeks turn into months, and new features pile on top of old ones, the original design intent gets lost in the shuffle.

The result? Conflicting features, wasted development time, and a game that feels less cohesive than initially envisioned. In Alice and Bob’s case, they spent the next two hours combing through code, trying to figure out why the goblin AI was behaving so erratically.

They eventually found the culprit: a forgotten line of code in a separate script that overrode the intended attack range. The fix was simple, but the time wasted was significant.

Introducing the Dev Journal: Your Design Intent Time Machine

A dev journal is a dedicated space for you to track your game development progress, stay consistent with devlogs, and organize your creative process. It’s more than just a glorified to-do list; it’s a living document that captures your design intent, technical challenges, and creative breakthroughs.

Here’s how a dev journal could have saved Alice and Bob (and can save you!) a lot of headaches:

1. Document Design Decisions Immediately: The moment you and your team settle on a design choice, write it down. Don’t rely on memory. Include the why behind the decision. Why did you choose a medium-range rock throw for goblins? What problem does it solve? What gameplay experience does it create?

2. Use a Consistent Format: Establish a standard template for your journal entries. This might include fields for:

   • Date
   • Feature/Task
   • Design Intent
   • Implementation Notes
   • Challenges/Solutions
   • Next Steps

   Having a consistent format makes it easier to search and retrieve information later on.

3. Regularly Update Your Journal: Make it a habit to update your journal at the end of each development session. Even brief notes are better than nothing. Consistent updates create a reliable record.

4. Tag and Categorize Entries: Implement a tagging system to easily filter entries by feature, system, or problem area. This is invaluable when you need to find all entries related to AI, combat, or level design.

5. Review Your Journal Periodically: Don’t let your journal gather digital dust. Set aside time each week to review past entries. This helps you stay aligned with your original vision and identify potential inconsistencies early on.

Common Pitfalls and How to Avoid Them

• Pitfall: Treating the journal as an afterthought.

  • Solution: Make journaling a core part of your development workflow.

• Pitfall: Writing vague or incomplete entries.

  • Solution: Be specific and detailed. Imagine you’re explaining the decision to someone who knows nothing about the project.

• Pitfall: Not using a consistent format.

  • Solution: Create a template and stick to it.

• Pitfall: Letting the journal become disorganized.

  • Solution: Use a tagging system and regularly clean up old entries.

Dev Journals in the Real World

Many successful indie developers swear by dev journals (or similar systems) for tracking game development progress:

• Lucas Pope (Papers, Please, Return of the Obra Dinn): Known for his meticulous design process, Pope often shares excerpts from his development notebooks, revealing his thought process and problem-solving strategies.

• ConcernedApe (Stardew Valley): Eric Barone kept detailed notes throughout the development of Stardew Valley, which helped him stay focused and consistent over several years of solo development.

Take Control of Your Game’s Vision

Implementing a dev journal might seem like extra work at first, but the long-term benefits are undeniable. It can save you time, reduce frustration, and ensure that your final game aligns with your initial vision.

Ready to start tracking your design intent effectively? Try our journaling tool to better track design decisions, prevent similar issues, and ensure the final product aligns with the initial vision. Start your Game Dev Journal today It offers a structured format, tagging system, and other features to help you stay organized and focused.