Devoxx Athens 2026

A couple of months ago, I wrote about a local developer meetup where the central question was:

“Will AI take our jobs?”

Shortly after, I had the chance to attend Devoxx Athens 2026 thanks to a ticket I somehow won out of ~100 attendees.

This wasn’t just another event. It was a dense, multi-track snapshot of where software engineering is actually heading, beyond hype, beyond headlines.

This post is not a recap of everything. It’s a reflection on the talks that stayed with me and how they connect to the broader shift we’re all experiencing.

Vibe Coding vs Context Engineering vs Spec-Driven Development

One of the most grounded talks I attended tackled something many of us are already doing, but not naming properly.

We often treat “using AI” as a single workflow.

It’s not.

The talk broke it into three distinct modes:

1. Vibe Coding

Fast, intuitive, exploratory.

• You prompt loosely
• You iterate quickly
• You accept imperfections

This is great for:

• Prototyping
• Side projects
• Exploring ideas

But it breaks down fast in production environments.

2. Context Engineering

More structured, more intentional.

• You carefully craft inputs
• You provide relevant context
• You guide the model toward correctness

This is where AI starts becoming genuinely useful in real-world systems.

3. Spec-Driven Development

The most rigorous approach.

• Clear specifications
• Deterministic expectations
• Strong validation loops

This aligns closely with traditional engineering discipline.

If your thinking is fuzzy, AI will scale that fuzziness.

The Selfish Team Player

This one hit close to home.

The idea sounds contradictory, but it’s not.

A “selfish” developer:

• Protects their time
• Sets boundaries
• Avoids unnecessary complexity

A “team player”:

• Shares knowledge
• Supports others
• Contributes to collective success

The intersection is where high-performing engineers live.

“.NET is Proprietary, PHP is Dead, and Everything You Know is Wrong”

This talk was a reality check against tribalism in tech.

We love narratives:

• “This language is dead”
• “That platform is obsolete”
• “This is the future”

Most of them are wrong.

The talk dismantled several assumptions:

• Technologies don’t die, they evolve or stabilize
• “Proprietary vs open” is often more nuanced than we admit
• Ecosystems matter more than syntax

And most importantly:

Engineers often overestimate trends and underestimate inertia.

There is a massive amount of working software in the world.

It doesn’t disappear because a new framework is trending.

Code That Moves the World - The Rise of Physical AI

This was one of the most forward-looking talks.

We’ve spent years saying:

“Software is eating the world.”

Now it’s doing more than that.

It’s interacting with the physical world.

• Robotics
• Autonomous systems
• Smart infrastructure

AI is no longer just generating text or code.

It’s:

• Controlling systems
• Making real-time decisions
• Operating under physical constraints

And unlike web apps:

Failure has tangible consequences.

Latency, reliability, and safety are no longer abstract concerns.

Software engineering is expanding into domains where correctness is not just important, it’s critical.

AI Code Reality - Help, But With Costs

This talk aligned strongly with my own experience.

Yes, AI helps.

But it also introduces new risks:

Quality Issues

• Subtle bugs
• Incorrect assumptions
• Overconfident outputs

Security Risks

• Vulnerable patterns
• Outdated practices
• Insecure defaults

Cognitive Risks

• Reduced deep understanding
• Over-reliance on generated code

The key idea:

AI reduces the cost of producing code, not the cost of validating it.

If anything, validation becomes more important.

The Sound of Your Secrets

Easily one of the most fascinating talks.

It demonstrated how models can be trained to extract sensitive information from unexpected channels, in this case, audio patterns.

The point wasn’t just the specific technique.

It was the broader lesson:

Systems leak. Often in ways we don’t anticipate.

Security is no longer just about:

• Input validation
• Access control
• Encryption

It’s about:

• Side channels
• Emergent behavior
• Model exploitation

Connecting the Dots

Across all these talks, a pattern emerged.

Not explicitly stated, but clearly visible:

1. Abstraction Is Increasing

AI, tooling, platforms, everything is moving up the stack.

2. Responsibility Is Not Decreasing

If anything, it’s increasing.

3. The Skill Gap Is Widening

• Shallow knowledge is easier than ever
• Deep understanding is more valuable than ever

4. Software Is Expanding Its Reach

From browsers and APIs to:

• Physical systems
• Security-critical environments
• AI-driven decision loops

Winning that ticket felt random at the time.

Looking back, it wasn’t just luck, it was leverage.

A small moment that led to a high-density learning experience.

And honestly, that’s what this field is about.

Till next one.