Becoming friends with AI

My journey with AI started like meeting a new coworker.

At first, it felt… weird.

It had strong opinions, it sounded confident, and people kept saying “this changes everything”. My first reaction was skepticism. I’ve seen too many trends.

So I did what I usually do with hype: I didn’t fully join, but I stayed close enough to understand it.

First impressions

The first days were like talking with someone who thinks differently from you.

Same problem, different approach.

Sometimes it was useful. Sometimes it was wrong. Sometimes it was right but for the wrong reasons.

And the confidence didn’t help. That “I know everything” vibe can trigger your ego fast.

I remember thinking:

“Who is this person?”
“Is it really that good, or is everyone just excited because it’s new?”

The moment I put my ego aside

The turning point wasn’t a model release.

It was internal.

I realized I was fighting a tool because of pride. Not because of reality.

So I decided to treat it like a relationship:

• I don’t need to agree with everything.
• I can set boundaries.
• I can test trust in small steps.
• I can learn how the other side thinks.

And yes… it paid off.

Trust is built with rules

Once I stopped expecting perfection, I started getting value.

But only when I stopped using AI like a magic button and started using it like a teammate.

A teammate needs context.

So I began giving it:

• the goal (what “done” means)
• the constraints (performance, security, timeline)
• the style (project conventions)
• the trade-offs (what we can sacrifice, what we can’t)

That’s when AI stopped being “random output” and started being a real accelerator.

Builders are not going away

I keep seeing the same headline:

“Developers will disappear.”

I don’t buy it.

I think what’s happening is simpler: a new abstraction layer.

We already lived this multiple times:

• We moved from low-level code to frameworks.
• We stopped writing tons of boilerplate.
• We adopted conventions so we could move faster.

React didn’t kill developers.
Next.js didn’t kill developers.
TypeScript didn’t kill developers.

They changed what we focus on.

AI is doing the same thing.

Now the interface is more “verbal”. You describe intent, and the code appears.

But you still need a driver.

The bottleneck moved

This is the key part many people miss.

Even if AI writes code 3x faster, teams won’t ship 3x faster.

Because writing code was never the full cycle.

The real-time sinks are:

• coordination
• reviews
• waiting
• alignment
• QA cycles
• unclear requirements
• “What are we actually building?”

AI helps a lot, but it doesn’t magically fix the system.

What it does change is that the cost of “trying” goes down.

You can prototype faster.
You can show something real earlier.
You can reduce speculation.

That’s huge.

What changed in my daily work

Today, I use AI like a strong friend that complements me.

Not like a boss.
Not like a replacement.
Not like an intern either.

More like: someone fast, tireless, and sometimes annoying, but very useful.

Where I accelerate the most:

• first drafts (components, scripts, tests)
• exploring options (trade-offs, approaches)
• documentation and refactoring
• debugging when I’m stuck and tired
• quick prototypes to get feedback early

Where I slow down on purpose:

• architecture decisions
• anything that creates tech debt
• anything that touches critical business logic
• “It works,” but feels wrong code

Because this is where experience matters.

If you’ve built systems for years, you have intuition.
You see risks early.
You smell tech debt.

That’s hard to replace.

The “friendship” part

Like any friendship, you learn how to work together.

Sometimes you lead.
Sometimes you let the other person run.
Sometimes you stop them because they’re going too fast.

The best results happen when you do both:

• AI accelerates execution.
• You bring judgment, taste, and responsibility.

This is why I don’t see myself as “just a programmer”.

That label is too small.

I care about building things people use.
Solving real problems.
Shipping with quality.
Avoiding dumb tech debt.

That’s builder work.

The human part matters more now

One unexpected effect:

The better AI gets at generating, the more I value raw humanity.

For code, AI is amazing.

But for:

• meaning
• stories
• emotions
• leadership
• trust
• working with people

Humans still matter a lot.

Maybe even more than before.

Final thoughts

Today, AI and I are in a good place.

We’re not inseparable.
We’re not naive.
But we trust each other.

And we build faster together.

Maybe one day I’ll hand over more.
Maybe the relationship will change.

But right now, I’m still the driver.

AI is my friend in the passenger seat.
It helps me navigate.
It warns me.
Sometimes it pushes bad ideas.
But it also makes me better.

If you haven’t started building that “friendship” yet, start small.

One hour a day.
Real tasks.
Real context.
Clear boundaries.

That’s how trust is built.