Code So Simple Even Your Old Grandma Could Read It
A roadmap to writing readable code in 90 days (even if you're just starting out).
Hey there!
Last week we dove into the horror stories of poorly written code.
It’s something I’ve heard quite a bit:
"I thought I was the only one terrified of my old code!"
"Just last week, I opened a project from 3 months ago... big mistake."
“I never thought I could write maintainable code”
You're not alone. I was the same. Impostor syndrome hits hard.
So let’s tackle it head on!
I especially noticed my despair being amplified because the context of the code I was writing changed as I started my career.
It was no longer academic.
It was practical.
Focused on efficiency and value, rather than for learning purposes.
But here's the thing: Jason Voorhees, the tax man and entropy might be unstoppable, but unreadable code isn't.
What many early-career developers miss
What they miss, and what nobody tells you, is this: Writing readable code isn't about knowing every best practice, but about mastering the basics first.
There's a natural progression to writing clean code.
Today, I'm sharing the roadmap that's helped me go from "my code works" to "my code makes sense" in just 90 days.
Let's break down your journey to readable code into three achievable phases:
Month 1: Master the Art of Naming
Month 2: Function Design
Month 3: Code Organization
Month 1: The Naming Phase
(This phase never ends)
This is where everyone should start.
There are only two hard things in Computer Science: cache invalidation and naming things.
- Phil Karlton
Think of good naming as the foundation of readable code.
Confusing names makes your intent unclear.
Unclear intent is the bane of all future development.
It multiplies the time it would take to make changes, rendering your code less maintainable, less Enduring.
Your focus areas:
Use descriptive, intention-revealing names
Keep names searchable and pronounceable
Use consistent naming conventions across your codebase
Avoid abbreviations unless they're universally understood
Make the scope of variables clear through their names
Weekly Goals:
Week 1: Rename variables that do not give enough detail
Week 2: Make boolean variables answer a question (isActive, hasPermission)
Week 3: Name functions using verb-noun pairs (calculateTotal, validateInput)
Week 4: Document your naming conventions in a personal cheat sheet
Month 2: The Function Phase
(Once your names make sense, tackle this)
Now that you can name things well, let's structure your code better.
The goal? Each function should be like a good message.
Short, focused and easy to understand.
It should do a minimum of things, and it should do them well.
Your focus areas:
Keep functions focused on a single task
Limit parameters (aim for 3 or lower)
Extract complex conditionals into well-named functions
Make functions predictable (same input = same output)
Write functions that are easy to test
Weekly Goals:
Week 1: Identify functions longer than 20 lines
Week 2: Identify functions that take more than 3 parameters
Week 3: Split complex functions into smaller ones
Week 4: Write function documentation that explains WHY, not WHAT
Month 3: The Organization Phase
(The final piece of the puzzle)
Time to see the bigger picture.
How do your well-named, focused functions fit together?
When it all comes together you create Structural Clarity in your code.
Things are where you expect them.
Things do what they say.
The intent is clear, and the approach intuitive.
It becomes a joy to navigate.
Your focus areas:
Group related functions together
Separate concerns (data access, business logic, presentation)
Create clear file structures
Define clear boundaries between different parts of the application
Create consistent patterns for error handling and logging
Weekly Goals:
Week 1: Group related functions into classes or modules
Week 2: Separate data access from business logic
Week 3: Create proper file organization
Week 4: Document your project structure
That's it.
Here's your key milestones in this roadmap:
Month 1: Every piece of code you write has clear, meaningful names
Month 2: Your functions are focused, small and easy to understand
Month 3: Your code has a clear, logical structure that promotes clarity and reveals intent
Start your journey today: Open your current project and rename just THREE variables to be more descriptive. That's all.
Tomorrow, do it again.
Small steps lead to big changes.
I’d love to hear which part of the roadmap you struggle the most with? Is it naming?Complex functions? Structural Clarity?
Why do you think that is?
See you next Tuesday!
PS... Enjoying this newsletter? Consider referring it to a friend who's also navigating the start of their career! Each new subscriber helps us create more in-depth newsletters.