Instead, a question one step earlier: how does a kid who made swords out of cardboard end up talking to a language model at 3am?

Every week, someone tells developers how to “survive” AI.

Learn this model.

Master these tools.

Become an AI engineer before it’s too late.

The implication is always the same:

Adapt, or become obsolete.

I understand where that anxiety comes from.

I just don’t find it particularly interesting.

Which, written down like that, sounds a little glib.

Telling someone with a mortgage and a kid and a real question about next year’s salary to “just enjoy it” is its own kind of cruelty.

The survival conversation isn’t happening because people are bored. It’s happening because livelihoods are attached to it.

I know that.

And I still think this.

Not because I think AI is a fad. Quite the opposite.

Large language models are probably one of those rare technologies that actually survive the hype cycle and become part of the foundation we build on.

But I never became an engineer to survive.

I became one because computers were ridiculously fun.

And I suspect a lot of us did.

I’m not here to talk about surviving AI

Let me get a few things out of the way.

This is not an article about:

• whether we’re in an AI bubble

• whether the bubble has already popped

• which jobs AI will eliminate

• the 10 skills developers need to survive

• which new model scored 3.7% higher on some benchmark

• which framework will allegedly change software forever

Someone else will write those articles.

Probably several thousand people.

Every time something that looks like a technological revolution appears, the industry runs into the room holding up a giant tuna and screaming:

LOOK AT THIS THING. EVERYTHING HAS CHANGED.

I was born in 1998, and as far as I can remember, this has always been happening.

Windows.

The web.

Smartphones.

Cloud computing.

SPAs.

Blockchain.

Machine learning.

Now AI.

Some technologies disappear.

Some become boring infrastructure.

Some “revolutions” quietly circle back to ideas we already had twenty years ago.

And once in a while, something genuinely becomes the new default.

LLMs may very well be one of those things.

That’s exciting.

But when someone tells me I need to learn AI so I can “survive as an engineer,” my reaction is mostly:

You don’t need to threaten me.

I was going to play with it anyway.

Give engineers a new toy and half of us will voluntarily lose sleep trying to figure out how it works.

No survival instinct required.

So why did we become engineers?

That question has been on my mind lately.

Before careers.

Before salaries.

Before titles like “Senior Software Engineer.”

Before system design interviews.

Before cloud bills, Kubernetes manifests, pull requests, dashboards, roadmaps, and quarterly OKRs.

Why did we start?

For me, the answer begins long before I ever wrote code.

It begins with making things.

Before software, I wanted to build houses

My father worked in civil engineering.

As a kid, I used to look at architectural drawings and construction plans without really understanding what any of the lines or numbers meant.

I just loved the idea that someone could draw something on paper and eventually that drawing could become a real building.

So I copied them.

Badly, of course.

I drew my own houses.

This room goes here.

The stairs go there.

The entrance should be here.

I once told my father I wanted to become an architect.

He told me not to because there wasn’t enough money in it.

Inspiring stuff.

But looking back, I think the important part was already there.

I loved turning something imaginary into something structured.

Something that could exist.

That urge eventually found a much cheaper medium than concrete.

Cardboard weapons, clothespin airplanes, and Kamehameha training

I was not exactly building sophisticated prototypes.

If I found cardboard, I made weapons out of it.

Swords.

Shields.

Things that probably looked impressive only to children.

We would fight with them like some extremely low-budget version of Star Wars.

I also built airplanes out of clothespins.

Why clothespins?

No idea.

They were available.

That was enough.

I think that was the fun of it.

Take something ordinary.

Combine it with something else.

Turn it into something it was never supposed to be.

And when reality wasn’t cooperative enough, I moved on to imagination.

Like many kids who grew up watching Dragon Ball, I spent an unreasonable amount of time seriously considering how to fire a Kamehameha.

I practiced.

Results were disappointing.

Then there was Doraemon.

The gadgets were impossible, obviously.

But the idea that technology could create things that felt like magic stuck with me.

Machines that understood people.

Robots that could think.

Tools that could answer questions.

Things that could turn imagination into reality.

At the time, they were cartoons.

Now some of those ideas sound suspiciously like product roadmaps.

Then the computer showed up

My memory is fuzzy here.

It may have been Windows 98.

It may have been XP.

Either way, there was a PC in the house, and I was obsessed with it.

Not with programming.

Not yet.

I played pinball.

I used Paint.

I played Minesweeper without understanding Minesweeper.

That alone was enough.

Then the internet happened.

And the computer stopped feeling like a machine sitting in one room.

It became a portal.

There was music.

Videos.

Forums.

Strange websites made by strangers.

Eventually, Nico Nico Douga.

Every click revealed something I had never seen before.

For a kid, especially one far away from the centers of the tech industry, the internet felt infinite.

There were entire worlds full of people building things I didn’t know were possible.

That feeling changed me.

Then the future started arriving

My generation got to watch a strange transition happen in real time.

The iPod appeared.

Then the iPhone.

Then the iPad.

My first smartphone was an iPhone 5s.

Today, smartphones are so normal that it’s hard to remember how absurd they once felt.

A music player disappeared into a phone.

Then the camera did.

Then maps.

Then messaging.

Then the web.

Then almost everything.

The entire internet had somehow moved into a piece of glass in your pocket.

I remember looking at these devices and thinking:

People actually built this.

Not “technology.”

Not “the future.”

People.

Engineers.

Designers.

Researchers.

Someone had to figure out how every part worked.

And once I understood that, the feeling changed.

I didn’t just want to use these things anymore.

I wanted to know how they worked.

“Wait. How does this work?”

This question became a problem.

Press a button and the screen changes.

Why?

A device connects to the internet.

How?

You search for something and get millions of results.

How?

A game contains an entire world.

Who built that?

How?

I took apart computers.

I modified my PSP.

I changed settings I shouldn’t have changed.

I installed software I didn’t understand.

Naturally, I broke things.

Naturally, adults were not impressed.

But once you become infected with curiosity about what’s inside the machine, it’s hard to go back.

Something changes when you realize that the “magic” you’ve been watching is not actually magic.

There are systems underneath it.

Protocols.

Code.

Architecture.

Decisions.

Someone made all of this.

Which means, theoretically, maybe you can make things too.

That was when programming became dangerous.

Software felt like unlimited construction

When I started building applications, the most addictive part was simple:

Things that existed only in my head started appearing on the screen.

Yesterday there was nothing.

Today there’s a page.

A button.

A database.

A user account.

A feature.

Someone on the other side of the planet can open something I built.

That still feels slightly insane.

And unlike architecture, I didn’t need land.

I didn’t need timber.

I didn’t need a factory.

I didn’t need heavy machinery.

I needed a computer.

That was enough.

It felt like the childhood joy of drawing houses had come back with almost no physical limitations.

I could design systems instead of rooms.

Interfaces instead of walls.

Data models instead of floor plans.

The material had changed.

The impulse had not.

Then came the endless rabbit hole

React.

Rails.

Databases.

Infrastructure.

Machine learning.

Deep learning.

Networks.

Operating systems.

Architecture.

Books.

O’Reilly books thick enough to be used as blunt weapons.

Every time I learned one thing, it revealed ten things I didn’t understand.

There was always another layer.

And somehow, I loved that.

For some people, the fact that software engineering never ends is exhausting.

For me, that’s part of the appeal.

You can study for years and still regularly encounter something that makes you say:

Wait, what the hell is that?

Wonderful.

There is no final level.

No completion screen.

No moment where the industry says:

Congratulations. You now understand computers.

You just keep going.

Eventually, it became a job

At some point, something that had begun as curiosity became professional work.

I joined an internship.

For the first time, I was around engineers building real systems for real users.

That world was very different from hacking on something alone.

There was design.

Code review.

Operations.

Responsibility.

Other people had to understand what you wrote.

Things had to keep working after you went to sleep.

Later, I worked as an employee.

I freelanced.

I kept doing independent development.

I tried to build businesses around software.

At one point, I attempted to digitize nutrition labeling and bring it into restaurants.

It went nowhere.

That happens.

Reality is annoyingly good at rejecting your product ideas.

But what surprised me was what happened afterward.

I didn’t stop wanting to build.

I just thought:

Okay. What should I make next?

Of course I want to succeed.

I want people to use the things I build.

I’d love to create a large software business.

But underneath all of that ambition is something much simpler.

I just like making things.

I think many engineers started with wonder

Everyone has a different origin story.

Maybe yours was video games.

Maybe you built your first PC.

Maybe you made Flash websites.

Maybe you wrote Minecraft mods.

Maybe you fell in love with Linux.

Maybe you saw the first iPhone and lost your mind.

Maybe you watched Steve Jobs give a keynote.

Maybe you discovered open source.

Maybe you just heard engineers made decent money and tried programming.

That’s fine too.

But I think a lot of developers have a moment somewhere in their past when technology made them feel something.

Someone built a game.

Someone built a website.

Someone designed a computer.

Someone created a programming language.

Someone wrote a piece of software that felt impossible.

And you looked at it and thought:

What is this?

Then, eventually:

Can I make something like this?

That second question is where things begin.

I received that feeling from other people’s work over and over again.

The first computer.

The internet.

The iPhone.

The first program I wrote that actually worked.

The first time a stranger used something I had built.

At some point, I wanted to be on the other side of that experience.

I wanted to make the thing that made someone else curious.

And now someone gave us AI

So here we are.

And someone dropped another extremely powerful toy in front of us.

Large language models can write.

They can code.

They can generate images.

They can use tools.

They can help explore ideas.

They can increasingly participate in the process of building software itself.

And immediately, the conversation became:

Will this replace engineers?

Maybe parts of the profession will disappear.

Probably.

Maybe writing code by hand will become a much smaller part of software development.

Probably.

Maybe some of the skills we spent years mastering will become less valuable.

Almost certainly.

But my first reaction still isn’t fear.

It’s the same question I’ve been asking since I was a kid.

What can I build with this?

That’s the part I don’t think has changed.

Give a kid cardboard and he builds a sword.

Give him clothespins and he builds an airplane.

Give him a computer and he takes it apart.

Give him the internet and he builds a website.

Give him AI and, of course, he’s going to try to make something with it.

I did exactly this a few nights ago.

3am. I was telling a model that I wanted to turn YouTube into a newspaper.

Which is, I admit, a terrible way to explain anything.

Predictably, it interpreted the vague thing vaguely and handed back something plausible.

No — I don’t want a list of videos. I want a day’s worth of them read, and a front page waiting for me in the morning.

I said that. It fixed it.

We went back and forth for a while, and by morning a front page that had only existed in my head was sitting on the screen.

“Huh. There it is.”

I am fairly sure my face at that moment was the same face I had at ten years old, staring at a floor plan of a house that did not exist.

The quality of the feeling has not changed at all.

The tool went from pencil, to computer, to this.

That’s the whole difference.

Maybe we never loved typing code

Sometimes I wonder whether we confuse programming with the thing we actually love.

Do we truly love writing syntax?

Do we love semicolons?

Do we have a deep emotional attachment to moving JSON from one API to another?

Probably not.

At least, I don’t.

What I love is this:

Taking something that exists in my head and making it exist in the world.

Code happened to be an extraordinarily powerful way to do that.

If tomorrow the best way to create software changes from Ruby to natural language, fine.

If keyboards become less important, fine.

If an AI agent writes half the implementation, fine.

If the abstraction changes, I’ll learn the abstraction.

That’s what engineers have always done.

The tools change.

The urge to build remains.

What would my younger self think?

Sometimes I imagine showing today’s technology to the kid sitting in front of that old Windows machine.

I’d tell him:

There are machines now that you can talk to.

They can answer questions.

They can write stories.

They can generate pictures.

They can help write software.

You can describe something you want to build and actually work on it together.

Then I could warn him:

You know, people are worried this might destroy your future career.

He probably wouldn’t be listening.

He’d be staring at the machine.

And eventually he’d ask:

“Can I try it?”

That question tells me almost everything I need to know.

We didn’t come here to survive

I don’t know exactly what software engineering will look like in ten years.

Maybe the profession changes dramatically.

Maybe “writing code” becomes a niche activity.

Maybe half of what we consider essential today looks ridiculous in hindsight.

That’s fine.

We were never promised stability.

And if I’m being completely serious, I don’t think stability was what attracted many of us anyway.

We came because it was fascinating.

Because machines could do impossible things.

Because the internet felt endless.

Because we discovered that the magic had an implementation.

Because once we realized someone had built these things, we wanted to build something too.

We did not become engineers because we had a carefully optimized strategy for remaining employable through every technological paradigm shift.

We became engineers because this stuff was too interesting to ignore.

And now we may be living through one of the strangest technological shifts of our lives.

So yes, think about your career.

Learn new tools.

Pay attention to how the industry changes.

Those things matter.

But every once in a while, maybe remember the person you were before all of that.

Before “career development.”

Before “staying relevant.”

Before “AI-proofing your skill set.”

The person who saw a computer do something impossible and thought:

How does that work?

And then:

Can I build something with it?

That person is still here.

At least mine is.

And he is having a great time.

Written by Mairu Matsuyama, born 1998. Indie developer, ex-employee, ex-freelancer, startup survivor, still building things nobody asked for. I post about software and indie hacking on X. Right now I’m building Paperman, which turns YouTube into a daily newspaper. I don’t know whether it will succeed or join the long list of things I tried — but I’m fairly sure what happens afterward. I’ll build something else. Apparently I never learned how to stop, and given the toys we have now, I’m not particularly interested in learning.