# Why Developers Feel Like They're Never Good Enough

There’s something strange about learning to code.

When I was starting out, every little thing I learned felt like progress.

I remember the feeling of making something work and thinking, *“Okay, maybe I can actually do this.”*

And then you learn more.

Not necessarily enough to become confident.

Enough to discover how much you don't know.

That's the weird part.

The better I get at development, the easier it becomes to look at something I've built and notice everything that's wrong with it.

The code works, but it could be cleaner.

The project is finished, but the architecture could be better.

You finally understand something you've been struggling with for weeks, and five minutes later you find someone explaining a much more advanced version of it.

And suddenly your achievement feels... smaller.

I've caught myself doing this more times than I'd like to admit.

I'll finish a project and instead of enjoying it, I'll start thinking about what I *should* build next.

I'll look at someone else's GitHub and wonder why my profile doesn't look like theirs.

I'll learn something new and somehow turn it into a reminder that there are ten other things I haven't learned yet.

It's exhausting.

And I don't think it's only because there is so much to learn.

I think it's also because of how easy it has become to see how much everyone else is doing.

* * *

![](https://res.cloudinary.com/duftaszh1/image/upload/overwhelm-programmer_x20ljs.png align="center")

* * *

When I started learning, I mostly compared myself to myself.

Yesterday I couldn't make this thing work.

Today I can.

That's a pretty straightforward way to measure progress.

But somewhere along the way, the internet enters the picture.

Now there's always someone building something bigger.

Someone who seems to understand the thing you're struggling with effortlessly.

Someone who has been coding for ten years.

Someone who has a GitHub profile that makes yours look like you created it yesterday.

And sometimes, you don't even have to actively compare yourself.

You just scroll past it.

A project.

A launch.

A technical article.

A new job.

A cool open-source contribution.

Someone talking about something you've never even heard of.

And there's that little thought again:

*“I should probably learn that.”*

One more thing gets added to the list.

* * *

The strange thing about that list is that it doesn't really have an ending.

You learn one technology and discover another.

You understand how something works and then realize you don't understand what happens underneath it.

You build an application and then start thinking about how you'd make it scalable.

You deploy it and discover that deployment is its own rabbit hole.

You finally feel comfortable with something, and six months later the ecosystem has moved on anyway.

I don't mean that as a complaint.

Honestly, it's one of the things I like about development.

There's always something interesting around the corner.

But I think there is a difference between **being curious about what comes next** and **feeling inadequate because you haven't learned it yet.**

I've definitely confused the two.

* * *

```javascript
$ developer --status

Projects completed: 14
Things learned: a lot
Things I don't know: apparently everything

$ confidence

still loading...
```

* * *

There's another thing I've noticed.

Sometimes getting better actually makes you more critical of yourself.

When you're starting out, you don't know enough to see all the problems.

You make something.

It works.

You're happy.

Later, you learn more about good architecture, clean code, security, performance, accessibility, testing, whatever it happens to be.

Then you look at something you built six months ago and immediately notice all the things you'd do differently now.

And it's very easy to look at that old code and think:

*“Wow, I was bad.”*

But maybe that's not what happened.

Maybe you just learned something.

The person who wrote that code didn't know what you know now.

That's kind of the whole point.

I think we forget this because we're usually looking forward.

We're thinking about what we need to learn next, what we should improve, what we should build, what we're missing.

We don't spend nearly as much time looking backwards.

* * *

Sometimes I open one of my older projects and cringe a little.

The code isn't how I'd write it now.

The UI could be better.

There are decisions I'd definitely change.

But then I remember that there was a time when even getting that project to work felt difficult.

And that version of me did the best he could with what he knew.

I think that's worth giving some credit for.

Not because the project was perfect.

It wasn't.

But because it existed.

And that's something I think developers sometimes underestimate.

**Finished and imperfect is still finished.**

A working project that taught you something is probably worth more than the perfect project that never leaves your hard drive.

* * *

The comparison problem gets even stranger when you realize that you're usually comparing your *behind the scenes* to someone else's *finished product*.

You see their polished GitHub repository.

You don't see the abandoned ones.

You see the final version.

You don't see the three weeks where nothing worked.

You see the announcement.

You don't see the months of uncertainty before it.

And I'm guilty of doing exactly the same thing to myself.

I'll look at somebody else's work and compare it to my own unfinished thoughts.

Of course theirs looks better.

They've already finished theirs.

* * *

I think that's why I've started liking the idea of building things more than simply learning technologies.

When you're building something, you have a reason to learn.

You don't need to know everything before starting.

You run into a problem.

You don't know how to solve it.

So you figure it out.

Sometimes you Google it.

Sometimes you read documentation.

Sometimes you ask AI.

Sometimes you spend an embarrassing amount of time staring at the same error.

Then eventually...

it works.

And you know something you didn't know before.

That's a much more honest kind of progress.

You're not trying to complete some imaginary developer syllabus.

You're just solving the next problem in front of you.

* * *

![](https://res.cloudinary.com/duftaszh1/image/upload/roadmap-figure_hmbgjg.png align="center")

* * *

And maybe that's what makes this feeling so difficult.

There isn't really a point where the list ends.

There will always be someone who knows more than you.

There will always be another technology you haven't touched.

There will always be something in your own code that you could have done better.

That's not a problem with you.

That's just how ridiculously large this field has become.

You could spend years getting really good at one part of development and still feel like a beginner somewhere else.

And that's okay.

I don't think being a good developer means reaching some magical point where you finally feel qualified to call yourself one.

Maybe it's being able to sit in front of something you don't understand and not immediately assume you're incapable of understanding it.

Maybe it's being comfortable saying:

*“I don't know this yet. But give me some time.”*

I like that word.

**Yet.**

It leaves the door open.

* * *

Because six months ago, there were things you couldn't build that you can build today.

There were errors you couldn't understand that you can probably debug now.

There were concepts that sounded completely alien that have slowly become normal.

There are probably things you're doing today without even realizing they were once difficult for you.

You probably just forgot to notice.

And maybe that's the part we need to fix.

Not our skills.

Our measurement of progress.

We're very good at keeping track of what's missing.

The next skill.

The next project.

The next job.

The next milestone.

Maybe we should occasionally keep track of what's no longer missing.

The things that used to scare us.

The things we can do now.

The problems we know how to solve.

The version of ourselves that would've been impressed by where we are today.

* * *

I still don't think I'm “good enough.”

I'm not sure I even know what that would mean.

And maybe that's fine.

There are still plenty of things I don't know.

There are projects I haven't finished.

There are technologies I haven't learned.

There are things I look at and think, *“How the hell does someone even build this?”*

But I also know that a few years ago, there were things I couldn't build that I can build now.

So I'll take that.

Maybe that's enough for today.

I'll learn the other stuff when I get there.

And maybe, every once in a while, I'll stop looking at the next thing long enough to notice that I've already come quite a long way.

```javascript
$ git log --progress

6 months ago
    couldn't build it

today
    can build it

6 months from now
    probably something else

$ status
    still learning

$ confidence
    getting there
```

And honestly...

**“Getting there” is probably a pretty good place to be.**