A presentation at BDX I/O in in Bordeaux, France by Horacio Gonzalez
Rewriting the Role Developers in the Age of LLMs Horacio Gonzalez 2025-11-07
Who are we? Introducing myself and introducing Clever Cloud
Horacio Gonzalez @LostInBrittany Spaniard Lost in Brittany Old(ish) Developer
Clever Cloud From Code to Product
Rewriting the Role Developers in the Age of LLMs
What are we going to talk about? ● Programmers Are Always Doomed… Until they are not ● When Tools Learn, So Must We Deskilling or reskilling in the age of AI ● The Developer’s New Workflow Co-authoring with the machine ● The Developer’s Journey Growing up with smarter tools ● Teaching the Next Generation How do we teach programming when the computer can already code? ● Differently Human The future of software development
Programmers Are Always Doomed… Until They’re Not
The first program language*: Fortran It will make make programmers obsolete!
The first program language*: Fortran From machine code: 0001 0001 0010 0011 0000 0001 0000 0000 0000 0000 0001 0000 10101 00010 00010 10000 ; ; ; ; LOAD constant 21 into register A LOAD constant 2 into register B MULTIPLY A × B → result in register A STORE result (42) into memory address 16 Low-level: registers, opcodes, memory addresses To Fortran: INTEGER A, B, C A = 21 B = 2 C = A * B PRINT *, C END Low-level: registers, opcodes, memory addresses
The first program language: Fortran Source: IBM history of Fortran https://www.ibm.com/history/fortran
From punched cards to keyboards Programmers won’t think before coding anymore!
From punched cards to keyboards
From punched cards to keyboards Sources: ● Wikipedia history of Punched Cards https://en.wikipedia.org/wiki/Punched_card ● Punching cards was a clerical job https://www.computerhistory.org/revolution/punched-cards/2/4
From Code to Models: the Automation Dream Business users will be able to build applications without programming
From Code to Models: the Automation Dream Some sources: ● Software Engineering in the Twenty-First Century (M. R. Lowry, 1992) ● The Last One https://ojs.aaai.org/aimagazine/index.php/aimagazine/article/view/1012/930 https://en.wikipedia.org/wiki/The_Last_One_%28software%29
Write once, run anywhere: Java Anyone can be a programmer now!
Write once, run anywhere: Java Some sources: https://www.joelonsoftware.com/2005/12/29/the-perils-of-javaschools-2/ https://nedbatchelder.com/blog/200601/joel_spolsky_is_a_crotchety_old_man.html
Low-Code / No-Code Now anyone can be a developer
Low-Code / No-Code
Low-Code / No-Code Some sources: ● The Rise of the Citizen Developer https://www.researchgate.net/publication/358383894_Rise_of_the_Citizen_Deve loper ● Will low-code/no-code platforms replace traditional developers? ● Will the No Code Movement Change Software Development? https://www.productmarketingalliance.com/developer-marketing/will-low-codeno-code-development-platforms-replace-traditional-developers/?utm_source=ch atgpt.com https://www.quandarycg.com/no-code-movement-software-development-changes/
What Every Abstraction Wave Taught Us Yet another apocalyptic change, it must be Monday…
What Every Abstraction Wave Taught Us ● Each new layer of abstraction triggers fear of obsolescence. ● Every time, developers adapt… and redefine the craft. ● Automation doesn’t eliminate skill; it changes where it lives. ● From bit-twiddling to system-thinking, we keep moving up the stack.
What Every Abstraction Wave Taught Us We don’t lose craft, we move it up a level
When Tools Learn, So Must We Deskilling or Reskilling in the Age of AI
When Tools Learn, So Must We Are we being deskilled — or are we reskilling? I can code, refactor, test, commit, make PRs… What’s left for me?
The Deskilling Fear If AI can code, what’s left for developers? https://www.theatlantic.com/ideas/archive/2025/10/ai-deskilling-automation-tec hnology/684669/
Is software development being deskilled? A very connoted word In economics, deskilling is the process by which skilled labor within an industry or economy is eliminated by the introduction of technologies operated by semi- or unskilled workers.
Automation doesn’t deskill people It shifts expertise to places the tools can’t reach
From Repetition to Reasoning Automation shifts the skill, not the value
What We’re Really Learning Now New literacies for developers Framing Critical Reading Turning intent into precise prompts Validating AI output Debugging abstractions Ethics & Trust Tracing errors you didn’t write Knowing when not to automate
From “Lost Skills” to New Ones We’re not forgetting, we’re evolving “We’ll forget how to code” The danger isn’t forgetting how to write a loop, it’s forgetting how to think about one Every machine embodies a social decision, what gets automated, and what remains a skill
The Craft Endures Still human, just differently skilled When tools learn, so must we Automation doesn’t end craftsmanship — it redefines it
The Developer’s New Workflow Co-Authoring with the Machine
From syntax recall to intent articulation The bottleneck moves from syntax to semantics How do I write this function? What should this function accomplish? You’re no longer coding for the machine; you’re negotiating with it
From implementation to orchestration You used to be a builder, now you’re a conductor A conductor doesn’t play every instrument; they ensure harmony and timing
From writing code to curating systems Deciding which lines matter, and which ones can be delegated. Choosing what to keep, refine, or replace
Pitfalls Overtrust, hallucination, loss of mental model This is the way, trust me The risk isn’t that the model will write bad code, it’s that we’ll stop understanding the code it writes
The new rhythm of collaboration Partnering with an LLM Ask clearly The best developers I know don’t treat the model as magic, they treat it as a junior teammate who learns through feedback Review ruthlessly Teach continuously Coding with an LLM is pair programming with a young colleague who’s brilliant, tireless, and occasionally delusional
In conclusion Co-Authoring with the Machine We used to talk about “writing software.” Now we’re talking about “conducting software.” The tools play the instruments, but we still write the score
The Developer’s Journey Growing Up with Smarter Tools
The vanishing entry-level Setting the stage I do the scaffolding, the repetitive work, the easy bug fixing, even the commits and PRs So how can I learn and get better if you do all the easy tasks? If the easy problems are gone, where do new developers cut their teeth?
Rethinking learning Juniors now must learn through AI, not before AI. Tri-programming Teaching Guided co-creation Junior, AI and senior Prompt crafting, critical code reading and debugging AI output New onboarding pattern instead of rote implementation
Redefining seniority What means being senior in a world with AI? Senior ≠ years of syntax mastery Senior = common sense, system and domain understanding, empathy and leadership Seniority is shifting from knowing the answers to knowing which questions matter
Mentorship in this new world A two-ways road
Conclusion The map changed, but not the destination Still learning to talk to machines, the language just evolved
Teaching the Next Generation How do we teach programming when the computer can already code?
The broken model We’ve been teaching how to code, not how to think about code Traditional model AI assistants Grading output Syntax drills & algorithmic exercises Students can “solve” everything instantly Everyone can cheat… or worse, learn nothing
Shifting from execution to understanding Let’s teach less syntax, more synthesis Write a function that… Explain what this function does and why Change focus Evaluate process Reasoning, mental models, system design and debugging Oral defense, live reasoning, code walkthroughs
The role of friction We must design friction on purpose Constraint-based learning forces students to think. ● debug broken AI code ● critique different answers ● give incomplete requirements The struggle is where understanding grows.
Teaching collaboration with AI Students need to learn to use LLMs well, not to hide them Prompt design Describe intent precisely Verification Test and analyze the output Reflection Document what was learned and what went wrong
Assessment reimagined How can we evaluate? Plagiarism detection is meaningless Grade something else: ● Process ● Reflection ● Reasoning When understanding becomes visible, cheating becomes pointless
Re-tooling educators Teachers need their own upskilling We have to learn what these tools do, where they fail, and how to guide students through them ● Experimenting ● Sharing open lesson plans ● Accepting that “teaching AI-era programming” is itself a new discipline
Conclusion We don’t teach people to out-code the machine. We teach them to understand, guide, and question it.
Differently Human The Future of Software Development
Differently Human The future of software development Every abstraction hides a machine… and reveals a human choice.
The Pattern Repeats Every revolution ends in rediscovery Assembly → Fortran → Java → Cloud → LLMs Each looked like an ending None erased us; all redefined us The next wave will do the same
What Machines Still Can’t Do Computation isn’t comprehension Intent Context Empathy Ethics LLMs manipulate form, not meaning We supply the “why,” the value judgment, the connection to real people
The New Developer Archetype From Coder to Composer ● Orchestrates human + machine collaboration ● Balances automation with accountability ● Designs systems and stories
The Human Loop Keep the Human in the Loop Our job: preserve understanding inside automated pipelines Automation without comprehension is abdication
Conclusion Not Less Human — Differently Human The future of software development isn’t less human. It’s just differently human. Our craft remains — it just moves up a level.
That’s all, folks! Thank you all!
Every few decades, a new wave of abstraction reshapes how we build software — and each time, someone declares the developer job dead.
When C arrived, assembly programmers scoffed at the “realness” of high-level coding. When garbage collection took over, systems programmers feared we’d all forget how computers work. Now, with the rise of Large Language Models, we hear it again: “LLMs will replace developers.”
But what if that fear is missing the point? This talk explores the developer’s role in the age of LLMs, not as an endangered species, but as a shifting craft.
We’ll draw historical parallels to past transitions in software development, look at how LLMs are changing our workflows (for better and worse), and discuss what remains essential when machines help us code.
Spoiler: it’s not memorizing syntax. Whether you’re skeptical, excited, or somewhere in between, this session is a call to reframe the conversation — not around obsolescence, but around adaptation.
Because the future of software development isn’t less human. It’s just differently human.
