Developing with AI: What Changes, What Stays, and What Becomes Critical

AI tools write code quickly. But which skills truly become central when code is no longer scarce?

I. Introduction  

AI-powered coding assistants have profoundly changed developers’ day-to-day work.
They generate working code in seconds, propose complete implementations, and drastically reduce the time spent on repetitive tasks.

This evolution raises a central question:

If code can be produced easily, where does the developer’s value now lie?

To answer it, we must look not at what AI can do, but at what it does not take responsibility for.

II. Code Is No Longer Rare, but Judgment Is  

For a long time, writing correct code was costly:

• in time,
• in attention,
• in cognitive effort.

AI has radically reduced this cost.
But it has not reduced the number of decisions to be made, nor the responsibility associated with those decisions.

Choosing a solution is not the same as producing it.
That is precisely where value now lies.

Every generated line of code still implies:

• a structural choice,
• a division of responsibilities,
• an implicit trade-off.

AI can propose solutions, but it cannot bear responsibility for their long-term consequences.

The developer’s role therefore shifts:

• from execution to arbitration,
• from production to evaluation,
• from speed to relevance.

In a world where code is abundant,
the rare skill becomes the ability to say:

this solution is correct, but not appropriate here.

III. Acceleration Makes Errors Happen Faster  

One of the most visible effects of AI is the overall acceleration of development:

• more code produced,
• more features delivered,
• more variants explored.

But this acceleration also applies to:

• poor abstractions,
• bad decompositions,
• decisions made without sufficient perspective.

A poorly structured system becomes problematic faster, not slower.

IV. Reading and Modifying AI-Generated Code Remains a Human Task  

When code is generated by AI, it is not fundamentally different from:

• code written by a colleague,
• or legacy code with no identifiable author.

In all cases, the developer must:

• understand the intent,
• identify responsibilities,
• evaluate the quality of the decomposition,
• decide how to evolve it.

AI does not eliminate this work.
It merely postpones the moment when it becomes unavoidable.

V. The Danger of “Reasonable but Fragile” Code  

A common pattern with AI is the production of code that is:

• readable,
• locally coherent,
• compliant with conventions.

Yet this code can remain fragile over time:

• overly generic abstractions,
• unnecessary dependencies,
• scattered logic.

This is not bad code.
It is code that is hard to evolve without deep understanding.

As Kent Beck often reminds us, human readability and the ability to change code matter more than mere functional correctness.

VI. Prompting Is Not Deciding  

Writing a prompt is about expressing an intention.
But an intention is not a complete design decision.

Even with explicit constraints:

• tests,
• style rules,
• guidelines,

the AI still has to:

• interpret,
• choose,
• arbitrate.

To achieve consistent results, developers must therefore learn how to write clear, structured, and contextualized prompts. This requires the ability to:

• make the functional context explicit,
• describe critical constraints,
• formulate precise goals rather than vague requests.

But this skill does not replace design decisions.
It depends on them.

If a developer cannot explain the choices made by the AI afterward,
the system becomes dependent on the tool rather than truly mastered.

VII. AI as a Maturity Amplifier  

In practice, AI rarely acts as an equalizer.
It acts as an amplifier:

• an experienced developer reaches a relevant solution faster,
• a less experienced developer reaches a solution faster that they are not yet able to judge.

This observation echoes long-standing ideas in software craftsmanship:
tools do not replace experience, they make it more visible.

VIII. Why Fundamentals Become Even More Important  

With AI, some skills become more important, not less:

• knowing how to break down a problem,
• recognizing an unnecessary abstraction,
• identifying dangerous coupling,
• simplifying before adding behavior.

These skills are not learned through prompting,
but through repeated experience writing, reading, and modifying code.

IX. Learning to Code Remains Essential  

Even in a development environment heavily assisted by AI, learning to code remains essential:

• to develop technical intuition,
• to recognize a bad solution,
• to understand the consequences of a decision.

X. Conclusion  

AI profoundly transforms code production.
But it does not change the nature of software work.

At the core of the profession remains decision-making under constraints.

Code is faster to produce.
Responsibility remains human.

Useful Links  

• The Skill That Separates Good Developers from GREAT Ones
  A reflection by Emily Bache on the link between code, design, mental models, and the use of AI assistants.

• Articles on code readability and maintainability
  In particular, writings on human understanding of code and refactoring as a core activity.

• Tidy First?
  A short book by Kent Beck on the importance of small structural decisions before adding behavior—highly relevant in the age of AI.

• Publications on AI and software craftsmanship
  Concrete experience reports on using AI tools in software development, with a strong emphasis on judgment and quality.