“The Frustrated Junior Dev”
“I’m doing everything ‘right’… so why does it still feel wrong?”
A junior dev once asked me that after a standup where their ticket got picked apart. They followed the pattern. Wrote the unit tests. Named variables cleanly. But somehow, they still missed the mark.
- The architect refactored their logic.
- The PO changed the acceptance criteria.
- The team lead rewrote their comments.
They weren’t slacking. They weren’t careless. They were doing everything by the book and still, it wasn’t clicking.
If you’ve ever been there doing all the “right” things yet still feeling off-balance, welcome to Shu, the first stage of mastery.
We’ve all been there: copying patterns we don’t fully understand, and sticking to the rules even when they chafe a little. That’s not failure.
That’s where real growth begins!
Let's explore Shu Ha Ri, the Japanese path to mastery in Agile and beyond. Learn how discipline, adaptation, and transcendence shape true growth.
🧱 The Dev Path: Shu, Ha, Ri
Let’s walk through how Shu Ha Ri shows up in real dev life, not just theory or martial arts metaphors.
🟦 Shu: Learn the Rules
Even if you don’t know why yet.
Shu is about imitation. You absorb structure before you shape it. Tutorials. Stack Overflow. Framework docs. Team conventions. You don’t have context for every line, but you're building your foundation.
You might be in Shu if:
✅ You build yet another CRUD app to really grasp routing.
✅ You follow the team’s linter rules religiously, even when they feel arbitrary.
✅ You memorize the Git flow process like a mantra.
👉 Shu isn’t about flair, it’s about form. Muscle memory. Good habits. It's the reps before the rhythm.
🟩 Ha: Question the Rules
Now you’ve got enough reps to push back.
You’ve internalized the basics, and now you start wondering why. Why this pattern? Why that tool? Ha is when curiosity grows teeth. You're still grounded in structure, but you start to bend it.
You might be in Ha if:
✅ You swap ngIf for ngSwitch and explain why.
✅ You propose an RxJS operator that simplifies the async chain.
✅ You fork the design system and customize the primitives.
👉 Ha is where your developer voice starts to emerge. You're remixing the craft.
🟨 Ri: Transcend the Rules
The code flows. You guide more than grind.
In Ri, your instincts take over. You’re not thinking about syntax; you’re thinking about outcomes. Architecture. Design. Flow. Mentorship. The code becomes the medium, not the message.
You might be in Ri if:
✅ You lead a refactor with calm precision.
✅ You help teammates navigate tradeoffs before a line of code is written.
✅ You know when a dev needs guardrails, and when they need space.
👉 Ri isn’t the end. It’s a lens. You don’t cling to mastery; you return to Shu when new stacks or challenges emerge.
📦 Closing Recap: The Cycle of Mastery
Shu Ha Ri isn’t a staircase. It’s a loop.
We all rotate through:
- Shu when learning a new framework.
- Ha when we hit friction and start questioning.
- Ri when the work feels like play; teaching becomes part of the craft.
Feeling frustrated that you're “just following the rules”?
That’s not a sign you're stuck.
It’s a sign you’re on the path.
🤔 Your Turn
Where are you in the cycle right now?
Shu, laying the bricks?
Ha, testing the limits?
Ri, flowing with purpose?
Are you walking the path of mastery?
Drop a comment, or share this with a teammate who's ready for the next stage.
Want to see how I apply it to my life, with examples about sumo and bonsai? 👉 https://lnkd.in/e25hmBFj
For a more detailed explanation without my Bonsai and Sumo stories > 👉
https://lnkd.in/epQnVFUS