DEV Community: Henri Leinonen

If You're a Junior Developer, Start Learning AI Tools Now

Henri Leinonen — Sun, 08 Mar 2026 10:51:49 +0000

Lately I've been seeing more and more job postings looking for AI developers or developers who at least understand how to work with AI tools.

If you're just starting out in your development career, this is something worth paying attention to. The market is clearly moving in this direction.

One thing I usually recommend to juniors is simple:

Start experimenting with AI developer tools early.

You don't need to master everything. Just get hands-on experience.

Tools I Recommend Trying

Two tools I recommend trying first are:

Cursor
Claude Code

For example, with the $20 Cursor Pro plan, you actually get quite a lot.

This month I implemented:

A couple of features using Opus / Sonnet 4.6
One feature using Composer 1.5, including both planning and implementation

And I still have tokens left. Actually quite a lot if I mainly use Composer 1.5.

So from a learning perspective, it's a pretty good deal.

Why Composer Is Actually Great for Learning

Composer might not be the coolest model out there right now.

But if you want to understand agentic workflows, it's honestly really good.

One of the biggest lessons is that planning matters.

Before you run an agent, you should already have a rough idea of:

What the feature should do
What files might change
What steps are required
How the implementation should be structured

When you work with agent-style workflows, you quickly realize that good planning makes the agent much more effective.

In a way, it forces you to think more like a software architect.

AI Skills Are Becoming Market Skills

Recently I've seen quite a few job postings looking specifically for developers with AI experience.

Not necessarily people building foundation models but developers who know how to:

Work with LLM APIs
Build AI-assisted workflows
Use tools like Cursor or Claude
Integrate AI into real products

This is becoming a real skill set.

If you're early in your career, this is a great time to start learning these things.

The barrier to entry has never been lower.

My Advice for Junior Developers

If you're a junior developer, I would suggest:

Start using AI tools in your daily coding
Learn how AI agents actually plan and execute tasks
Build small features using AI-assisted development
Follow the market and see what skills companies are asking for

You don't need to become an AI researcher.

But understanding how to work with AI as a developer is becoming increasingly valuable.

Final Thoughts

AI tools are not replacing developers.

But developers who know how to use AI tools effectively will probably move faster, learn faster, and build faster.

If you're early in your career, this is definitely something worth exploring.

The "Don't Be an Asshole" Theory of Career Growth: Why Weak Ties Matter More Than Clean Code

Henri Leinonen — Sat, 14 Feb 2026 14:04:45 +0000

Introduction: The Myth of the Meritocracy

We like to tell ourselves a comforting lie in the tech industry: "If I am just good enough at coding, nothing else matters."

We imagine that if we lock ourselves in a dark room, learn Rust, master Kubernetes, and produce 10x output, the world will beat a path to our door. But that’s not how it works.

This is especially true now that AI is rewriting the rules. Technical execution is becoming easier: Agents can generate the boilerplate, refactor the functions, and write the unit tests. What is left for humans?

The answer is connection.

Technical skills are the baseline and price of admission. But as AI raises the floor for technical competence, the ceiling is no longer defined by how fast you code, but by who you know and how you treat them. The multiplier is the social game. And the most critical piece of that game is a concept called Weak Ties.

The Science: Granovetter’s Bombshell

In 1973, a sociologist named Mark Granovetter published a paper titled "The Strength of Weak Ties." It is one of the most cited papers in sociology, and it completely changed how we should understand social networks.

Here is the breakdown:

Strong ties: These are your best friends, your immediate family, and your daily teammates. You move in the same circles. You know the same information.
Weak ties: These are acquaintances. The guy you met at a conference once. The project manager from your last job. The person you chat with occasionally on X.

Weak ties theory offers us something counter-intuitive. When it comes to finding new jobs or spotting new opportunities, weak ties work much better than strong ties.

Why? Because people close to you already know what you know. They are in your bubble.

Weak Ties are bridges. They connect you to social circles you don’t belong to. They possess information you don’t have. Statistically, your next big break is far more likely to come from someone you barely know than from your best friend.

The "Don't Be an Asshole" Perspective

This brings us to the Golden Rule of the social game: Don't be an asshole.

When you realize that "Weak Ties" are the source of opportunity, you realize that every interaction matters.

The junior dev you rolled your eyes at during code review? They might be a CTO in five years.
The person you had coffee with and forgot about? They might remember you when something changes.
The non-technical stakeholder you condescended to? They might be the one deciding whether your project lives or dies.

If you treat people transactionally and only being nice to those who can help you right now, you are burning the bridges that Weak Ties are built on.

My Perspective: The Serendipity of Connections

I know quite a few people, and the trajectory of careers often hinges on random interactions that seem meaningless at the time.

Here is a real example from my own life:

I used to chat with a guy at my local gym. We weren't "friends" in the traditional sense. We didn't hang out on weekends or know each other's life stories. We just had fun, small conversations between sets. He was a nice guy, easy to talk to.

One day, he casually asked if my company had any open positions. As it happened, we did. He asked who he should contact, so I gave him my boss's phone number.

Later, I told my boss: "Look, he seems like a nice person, but I don't know anything about him professionally. I can't vouch for his code, only his character."

I wasn't involved in the interview process at all. He had to prove his technical merit on his own. But guess what? He got the job.

Think about the mechanics of this:

The Weak Tie: If he hadn’t been open to chatting with a stranger at the gym, he might have missed out on the open role.

The Filter: Because he wasn't an asshole at the gym, I was willing to share the contact info.

The Result: A connection based on pure social chance resulted in a career change for him and a new hire for us.

He obviously needed the technical skills to pass the interview. I didn't hand him the job. But the access to the job came entirely from a social game played in sweatpants, not a suit.

How to Play the Game (Without Being Fake)

You don’t need to be a slimy networker collecting business cards.

You need to cultivate serendipity.

Weak ties don’t require intensity.
They require light, consistent signals that you’re still there.

Be a "Router," not a "Firewall": When you meet someone interesting, ask yourself: Who else should they know? Connect people. Create bridges. The person who links two clusters becomes more valuable than the person who hoards access.
The "Five-Minute Favor": If you can help someone in less than five minutes (an intro, a code snippet, a quick answer), just do it. Don't calculate the ROI. The ROI is the Weak Tie you just strengthened.
Leave Good Artifacts: Most weak ties don’t know you personally. They might even just know your pull requests, your documentation, your comments. Those are also social artifacts. Make sure they say, “I’m thoughtful and easy to work with,” not “I’m technically right and emotionally expensive.”
Check in with no agenda: Once in a while, message that old colleague just to say, “Hope you’re doing well.” Don’t ask for anything. Keep the bridge intact. Don’t wait until you need something — by then, the bridge may already be on fire.

Conclusion

Code rots. Frameworks change. The only thing in your career that appreciates in value over time is your network.

You can be the smartest 100x AI engineer in the room, but if you’re an asshole, you isolate yourself from the chaos of luck. Weak ties bring luck. They bring the "right place, right time" moments.

So, write clean code, study your algorithms and AI tools but remember: the person sitting next to you (or on the other side of that Zoom call) is the variable that will likely define your future. Treat them accordingly.

Why “Just Build Projects” Isn’t Enough for Junior Developers

Henri Leinonen — Tue, 10 Feb 2026 14:54:53 +0000

Everyone tells junior developers to “just build projects.”

Build more.
Practice more.
Code every day.

It sounds reasonable — but it leaves out something important.

After talking to a lot of juniors, a pattern keeps showing up:
they’ve built projects, but they still don’t feel ready for real work.

Not because they’re lazy.
Not because they lack motivation.

But because they’re learning alone.

The problem with learning in isolation

Most junior developers learn by building solo projects.

That means:

no shared codebase
no pull requests
no code reviews
no one to explain decisions to
no feedback loop

You write code, it works ("Hey it's working on my machine!"), and… that’s it.

There’s no signal telling you:

Is this good?
Is this how teams actually do it?
Would this survive in a real codebase?

So even after finishing multiple projects, something still feels missing.

What real work actually looks like

In a real development team, coding is only part of the job. A lot of the work happens around the code:

planning tasks
understanding the client problems
breaking work into tickets
making tradeoffs
working in a shared repository
opening pull requests
reviewing someone else’s code
explaining why a decision was made

These are skills you’re expected to have. but they’re rarely taught.

Tutorials focus on syntax.
Solo projects focus on output.

Neither prepares you for collaboration.

The gap no one talks about

Here’s the uncomfortable truth:

Many junior developers aren’t missing technical ability.
They’re missing work-like experience.

They’ve never practiced:

touching code they didn’t write
getting feedback on unfinished work
adjusting based on reviews
learning from mistakes in a team setting

And when the job market is tight, that gap becomes painfully visible.

Why this matters more than ever

When I started my own developer journeys, the market was hot.
Breaking into tech was hard — but possible.

The last few years have been very different.

Junior developers are expected to have experience before they’re given a chance to gain it.

That’s a tough position to be in — especially when you’re doing everything “right” and still feel stuck.

Practicing the work before the job

This gap is exactly why we started building PiecesHub.

The idea is simple:
give junior developers a place to practice working the way real teams do — before a job expects it. A place where developers can find small teams and feel safe to learn by doing, together.

Not by replacing tutorials.
Not by grading people.

But by creating space to:

work together on shared projects
make decisions
reflect on what was learned along the way

Because confidence doesn’t come from shipping alone.
It comes from understanding how and why things are done.

I’m curious

If you’re a junior developer:

What part of “real work” feels the most unclear or intimidating right now?

If you mentor juniors or work with them:

What do you see them struggle with most when joining a team?

I’d genuinely love to hear your perspective!

If you’re curious what we’re building, this is the platform we mentioned above:
👉 https://pieceshub.com