Will AI Take Our Jobs? Reflections from a Developer Meetup

Few days ago, I attended a local developer meetup with a central theme:

“Will AI take our jobs?”

There were approximately 100–120 attendees, mostly software developers. Before the talks began, we were asked to submit our opinions via a form. The overwhelming majority of developers expressed confidence that AI will not replace us.

The speakers, however, presented a more nuanced spectrum of perspectives some optimistic, some pessimistic.

This post captures my position after reflecting on the discussions.

We Don’t Just Write Code. We Build Solutions.

Reducing software engineering to “writing code” is fundamentally inaccurate.

Code is the output.
Engineering is the discipline.

Our actual responsibilities include:

• Translating ambiguous business requirements into deterministic systems
• Designing scalable and maintainable architectures
• Making trade-offs across performance, cost, reliability, and time
• Managing technical debt
• Ensuring observability, security, and operational stability
• Owning outcomes in production

AI can generate code snippets.

It does not own production incidents.
It does not negotiate trade-offs.
It does not assume accountability.

Software engineering is fundamentally about structured problem-solving under constraints. That layer remains human.

Calculators Didn’t Eliminate Mathematics

When calculators were introduced, we did not stop teaching arithmetic.

We still teach:

• Algebra
• Calculus
• Proofs
• Number theory

Why?

Because tools abstract computation, they do not replace conceptual understanding.

AI is similar. It increases abstraction. It reduces boilerplate. It accelerates pattern recall.

But an engineer who cannot reason about:

• Complexity
• Concurrency
• Distributed systems
• Memory models
• Failure modes

…cannot properly evaluate AI-generated output.

Understanding remains non-negotiable.

AI Is Trained on Existing Work

Most generative AI systems that produce code are trained on:

• Open-source repositories
• Public documentation
• Community discussions

This means:

• Their knowledge is retrospective.
• Their output is statistical inference over past patterns.
• They inherit both strengths and weaknesses from their training data.

There is also an ongoing ethical discussion around licensing and attribution.

We contribute enormous amounts of public knowledge. In that sense, we are collectively feeding these systems.

But the intelligence is derivative.
It is not autonomous reasoning.
It is not original authorship in the human sense.

Who Is Most Confident We’ll Be Replaced?

A pattern emerged during discussions and outside the meetup as well:

The strongest claims that developers will be replaced often come from:

• Business owners
• HR departments
• Sales-driven roles
• People outside software engineering

Rarely from practicing engineers.

Engineers understand the depth and unpredictability of real systems. We deal with integration complexity, legacy constraints, unclear requirements, and production incidents daily.

Narratives of total replacement are often aligned with:

• Product marketing
• Investment positioning
• Fear-based adoption
• Buzzword amplification

Doom and disruption sell.

But software systems remain complex socio-technical organisms.

We Are a Young Profession And We Self-Train

Compared to medicine or law, software engineering is a relatively young profession.

Doctors train within structured systems.
We often train outside working hours.

We:

• Read documentation at night
• Build side projects
• Continuously reskill
• Adapt to new paradigms rapidly

Lifelong learning is not optional in our field.

If anything, AI increases the premium on:

• Deep understanding
• Systems thinking
• Architectural judgment
• Clear reasoning

Surface-level knowledge will be exposed faster, not hidden.

What About Junior Developers?

A common concern is that AI will eliminate junior roles first.

This argument fails structurally.

Without juniors:

• There are no future seniors.
• There is no knowledge pipeline.
• There is no succession.

Junior engineers:

• Learn through exposure to real systems
• Build intuition over time
• Make mistakes and internalize lessons

AI may accelerate onboarding.
It may increase expectations.
It may shift what “entry-level” means.

But removing the entry layer entirely is unsustainable.

Misconceptions Around Layoffs in Tech

Recent layoffs in the tech industry are often cited as “proof” that AI is replacing engineers. This is a misleading narrative. The majority of large-scale layoffs over the past few years were driven by macroeconomic corrections, over-hiring during zero-interest-rate periods, post-pandemic demand normalization, and shareholder pressure to improve margins, not by AI automation replacing software engineers at scale. Many companies expanded aggressively between 2020–2022 and later rebalanced headcount when growth projections failed to materialize. Cost optimization, duplicated roles, shifting product strategy, and restructuring explain far more than AI displacement does. Conflating cyclical business corrections with structural technological replacement oversimplifies the economics of the industry and fuels unnecessary panic.

AI Is a Tool, And a Useful One

Let me be clear:

AI is a tool. A powerful one.

I use it daily.

• I use it to automate repetitive tasks I’ve performed thousands of times.
• I use it to reduce boilerplate.
• I use it to refine drafts.
• I even used it to help refine this very post.

It helps eliminate friction.

It removes cognitive load from tasks that are mechanical and boring.

That does not make it a replacement. It makes it leverage.

We have always adopted tools:

• Higher-level languages
• Frameworks
• IDEs
• Linters
• CI/CD pipelines

AI is the next layer of abstraction.

The Real Shift: Increased Leverage

When abstraction increases, leverage increases.

When leverage increases:

• One engineer can accomplish more.
• Iteration cycles shorten.
• Experimentation accelerates.

Historically, this has not reduced software demand.

It has expanded it.

We did not build fewer systems after moving from assembly to high-level languages.
We built more ambitious systems.

AI will likely follow the same trajectory.

My Humble Position

My view is straightforward:

• AI will not replace software engineers.
• It will change workflows.
• It will increase abstraction.
• It will raise expectations.
• It will reward deep understanding.
• It will expose shallow competence.

We are not syntax typists.

We are builders of systems.
We design solutions under constraints.
We assume accountability.

As long as systems require architecture, trade-offs, and ownership, software engineers will remain essential.

The real question is not whether AI replaces us.

The real question is:

Will we adapt and expand our capability — or cling to outdated definitions of our role?

A Fun Note: Devoxx Athens

There was also a giveaway at the meetup, 5 tickets to Devoxx Athens.

I managed to win one.

Out of roughly 100–120 attendees, I somehow got lucky.