All six parts:
Part I: lostinbrittany.dev/en/programme...
Part II: lostinbrittany.dev/en/when-tool...
Part III: lostinbrittany.dev/en/co-author...
Part IV: lostinbrittany.dev/en/developer...
Part V: lostinbrittany.dev/en/teaching-...
Part VI: lostinbrittany.dev/en/different...

The future of software development isn't less human.
It's differently human.

Keep asking better questions.
Keep teaching the next generation.
Keep caring about what we build and why.

The machines will keep getting smarter.
Our job is to stay thoughtful.

The craft continues.

We're conflating the tools with the work.

Software development has always been about one thing: negotiating with computers to make them do our will.

From ENIAC switches to assembly to LLMs, the tools change. The work doesn't.

We're still translators between human intent and computation.

And accountability.

When an LLM generates a healthcare algorithm, who's responsible if it's biased?
When it writes financial code, who answers when the audit fails?

The machine can produce. But it can't be held accountable. It can't care.

Caring is what transforms code into craft.

LLMs will always beat us at memorizing, recalling syntax, brute-force computation.

But understanding? That's ours.

Seeing not just what code does, but why it was built that way. Sensing when something feels wrong even if tests pass. Holding the full scope as relationships, not facts.

But here's what endures: understanding.

In my teaching, there's a moment I watch for. Not when code compiles or tests pass.

It's when students stop asking "how do I make this work?" and start asking "why does this work this way?"

That's the shift. That's what matters.

Here's what worries me: the gap between how fast things change and how fast we adapt.

Educational institutions move on decade timescales.
AI capabilities double every few months.

By the time a university updates its CS curriculum, the models have evolved three generations.

How do we teach judgment when students skip straight to working solutions?

How do we build mental models when the struggle has been automated away?

That's not a question about tools. It's a question about education itself.

And it requires changes at every level.

A student told me: "I used to think programming was about memorizing syntax. Now I realize it's about understanding problems well enough to explain them to something very smart but with no common sense."

That's the shift.

Full post: lostinbrittany.dev/en/teaching-...

The shift in teaching:

Old: "Write a function that finds the max value"
New: "Here are 3 implementations. Which handles empty arrays? Which is most readable? Which would you ship to production and why?"

We teach understanding, not typing.

What surprised me? Students were brutally honest.

"I got stuck in a loop with the LLM for 20 minutes before I realized I needed to read the error message."

"This part I copied from Stack Overflow because the AI solution was too complex."

That self-awareness is what we want.

So I changed my approach. Now students must submit "lab notes" with every assignment:

- Their prompts
- AI responses (what worked, what didn't)
- Their modifications
- What they learned

Make AI use explicit and structured, not hidden.

Last year, I found students stuck in loops with LLMs.

Copy-paste output. Doesn't work. Ask again. Copy-paste. Still doesn't work. Ask again.

Cycling through AI responses like a slot machine.

"Why don't you read the error message?"

Blank stares.

They weren't thinking. Just copy-pasting.

A professor asked a student to explain their binary search tree code.

"Um... I'm not sure exactly. ChatGPT wrote it."

"But do you understand how it works?"

"I mean, it passes all the tests."

Original code. Zero learning.

This is what happens when we measure output, not understanding.

📍 Codeurs en Seine — 20/11, Rouen
Deux talks à ne pas manquer :
• “Construire des serveurs MCP plus intelligents” — @lostinbrittany.bsky.social
• “Souveraineté numérique” — @waxzce.org
👉 codeursenseine.com

Seniority is shifting from knowing answers to knowing which questions matter.

Juniors bring speed. Seniors bring understanding.

Our responsibility? Teach how to learn when the machine knows syntax but not meaning.

Full post: lostinbrittany.dev/en/developer...