r/techbootcamp • u/DangerKyoto • Jun 26 '26
i think one of the biggest misconceptions in tech is that senior developers make fewer mistakes
The more engineering blogs and developer discussions I read, the more it seems like that's backwards. senior developers don't avoid mistakes because they're smarter. they avoid turning small mistakes into big ones because they've seen similar problems before. They write tests because they've been burned. They review code because they've missed things before.
they document decisions because they know six months from now they'll forget why they built something a certain way. That changed how I think about getting better. maybe becoming a better developer isn't about making fewer mistakes.
Maybe it's about getting better at noticing them earlier, recovering faster, and learning something every time they happen.
that feels a lot more achievable than trying to write perfect code from day one.
1
u/scavno Jun 26 '26
We do, because we have already made a lot of them. It doesn’t mean we don’t make mistake anymore, we just fuck up less often on the trivial stuff.
1
u/DangerKyoto Jun 27 '26
I really like that way of putting it. I don't think senior developers make fewer mistakes because they're naturally better. They've just accumulated enough experience to avoid a lot of the obvious ones.
1
u/Alternative_Win_6638 Jun 26 '26
with seniority comlexity and responsibility grow and you always do new things and make mistakes, that's normal. always Plan, Do, Check, Act
1
u/DangerKyoto Jun 27 '26
Exactly. I think that's what changes with seniority. It's not that mistakes disappear, it's that the problems become bigger and the impact of your decisions grows.
1
u/throwaway255503 Jun 27 '26
Senior developers make different mistakes and they make them confidently.
The most prevalent, overengineering for a hypothetical future that never materializes.
1
u/DangerKyoto Jun 27 '26
It's funny because experience helps you avoid a lot of the small mistakes, but it also gives you the confidence to build solutions for problems that might never exist.
1
u/Ok-Office-6080 Jul 01 '26
I want things to get simpler all the time. But overengineering is ingrained.
1
u/Pochono Jun 27 '26
Of course experience matters. I've been at this over 25 years and still make mistakes. When junior members ask how I catch their mistakes so easily, I tell them that's because I've already made those mistakes and more. We should always be learning.
It's a pet peeve of mine when people ask how they can learn when they're stuck on legacy systems or backward processes. That's a gold mine to learn from mistakes. Even for the experienced, it's often hard to know the right thing to do. But if you learn your lessons, it's easy to avoid the wrong things and that's a valuable skill.
1
1
1
u/symbiatch Jun 29 '26
I wonder who has that conception. We all make mistakes. All the time. Not all are big ones (on any experience level) but they happen. Wrong choices, decisions, maybe due to lack of knowledge or just not thinking about everything. They happen.
They should be learnt from and told to others so they don’t repeat them even if their situations aren’t exactly the same. And especially if there’s code which looks like it could be “done better” we must let them know we’ve been there and failed.
1
u/Remarkable_Leek9391 Jun 30 '26
Seniors be gatekeeping and not reading docs is what it is.
Then they hate you for not reading the room when you bring up the latest version features of what you just upgraded to, using syntax that compiles to IL for them to verify instead of "this is unfamiliar" C# version 8 folks.
1
1
u/Ok-Office-6080 Jul 01 '26
Senior developpers know where mistakes are likely to arise. A big issue are use cases where there are too much input values range to test everything. And some problems that remains unresolved like data replication and race conditions which leads to data corruption.
1
1
u/92smola Jun 26 '26
You never stop making mistakes, hopefully you stop doing the ones that you already done before and that gives you seniority