Throughout my career as a developer, I’ve exhibited varying degrees of hubris — the good bulk of it at the beginning of my journey. I was the cocky junior dev, filled with overconfidence and somewhat zealous advocacy of things I only thought I understood.
It happens to all of us — especially in our early days when we think we know it all. In reality, it’s just the Dunning-Kruger effect perpetuating its glorious cycle on our egos and (eventually) pushing us toward reality. When we start out as developers, we’re like children — full of fantasies, hopes, dreams and potential. Then somewhere between the initial spark of inspiration and maturing into senior devs, we realize...we’re not as smart as we thought.
The Dunning-Kruger Effect
We look back at our old code and cringe at our clunkiness, nested loops and sloppy logic. We look forward and realize that in our current state we are mostly incompetent. We can’t do anything except pick up the next set of tools, technology stacks and whatever else we need just to make something work by the skin of our teeth. We become beginners — over and over again.
While we can’t escape the Dunning-Kruger effect, we can at least soften its impact on our mental health. But how? How can we beat the Dunning-Kruger effect and mature as developers? First, we need to understand how the Dunning-Kruger effect works.
How the Dunning-Kruger Effect Works
The Dunning-Kruger effect is a form of cognitive bias where people overestimate their ability to do a particular task. Have you ever wondered why someone who’s completely unskilled gains an illusion of superiority — why they’re completely overconfident in their ability to execute any task? That’s the Dunning-Kruger effect at work.
As time progresses and the person gains more knowledge, they begin to see how much they don’t know. We represent the Dunning-Kruger effect as a downward curve, with the person starting at the top and quickly descending to the bottom as they gain more knowledge and skills. In other words, as you learn more you realize how much you don’t know! Then there’s the hard slogging climb back up the confidence curve over time as you obtain true proficiency.
In a way, experiencing the Dunning-Kruger effect is like experiencing a node tree structure unfurling in real life. One bug or feature request can easily lead you down a rabbit hole. One bug or feature request can easily lead you down a rabbit hole. Your confidence only truly starts to pick up once you dive into enough rabbit holes, you find burrows and realize they’re all interconnected — a veritable rabbit warren.
It’s All Connected
When it comes to code, nothing is ever clear-cut and no problem truly exists in isolation. Being a developer means cultivating a cacophony of skills and knowledge points that meld together to materialize a particular idea or product.
Because that’s what code is — ideas materialized, organized and systemized.
Most new developers don’t tend to think about code in this manner. It’s all about loops, switch statements and getting that app up into the cloud. This process can lead to feelings of being overwhelmed, which leads to the descent down the Dunning-Kruger slope. The more knowledge gaps you realize you have, the quicker the decline.
But it doesn’t have to be this way. From what I’ve learned, many of us spiral downhill because we don’t have a game plan. We go in thinking we can just Google it. There’s nothing wrong with Googling — but no amount of Googling is going to help if you don’t know what you’re searching for.
First, you need to figure out what you don’t know.
How to Know What You Don’t Know
While we can argue you can’t know what you don’t know, most developers aren’t that oblivious. The trick is to start with the idea and then work backward.
For example, you want to make an app. You know one of the main features is a login/logout/signup form. It’s a standard feature — but you’ve never made one before. However, you know how it works.
There is a form. You type into the fields and send it off for verification. If it passes the authentication tests, you’re allowed into the private area of the site. There’s no code involved in this — it’s just about you working out the different components you need to achieve your desired outcome — in this case, your signup form.
This initial plan is your scaffold — the thing that you should go back to as your true north star once you’ve started digging into the technicalities of implementation. It’s easy to lose your way once you start digging. You get sidetracked by other thoughts like: How are you going to secure parts of your site from non-members? What kinds of authentication systems and security protocols should you use? There’s nothing wrong with these questions, but they’ll contribute to feeling overwhelmed by your project. Put these questions to the side for now or down the slope you go.
Final Thoughts: Start With an Idea
Everything is just an idea until you code it. The process of creating software is mostly figuring out what the app looks like, its core functionalities and how to structure it. The actual code is only a fraction of the project.
To prevent the feelings of incompetence we feel when we hit the bottom of the Dunning-Kruger curve, we need to follow through with the process of figuring out what we want.
When we’ve got a plan, we at least have a road map that helps us find our way as we continue on our journey toward becoming a seasoned, confident developer. Rather than worry about the technology and everything you don’t know to get your project working (hint: it’s a lot!), figure out what you actually need to get started. It helps to decouple your personal gauge of your knowledge gaps from what you actually need for a particular project.
The issue with diving head-first into different technologies is that we don’t always have context. You can’t build an application if you don’t know what that app is supposed to be or what it’s supposed to do. It’s like someone telling you to start coding and then giving you the details of the project three months later. You’re just going to waste your time.
So start with the idea, flesh it out, decide on what you want, and then start filling in your knowledge gaps to materialize the final picture. Keep at it and at some point, you’ll find yourself looking back at all the skills and knowledge you’ve picked up along the way without diving too deep into the crevasse of the Dunning-Kruger effect.