The Qualities of Tomorrow's Programmers

Based on the video "Le qualità dei programmatori di domani"

Software development is being reshaped by AI. Code gets cheaper by the day. What doesn't get cheaper is judgment.

Here are the seven qualities tomorrow's programmers need.

1. See the whole system

The most important skill: understand the entire system, not just your module.

"You need the model of the whole system in your head: how data flows, where the tables live, how queries run, where the cache is, how it scales."

Know how data moves from user input to database and back. Know the real bottlenecks. Know the implicit dependencies between services.

Why it matters now: AI writes code locally, creating "islands of code" that work in isolation but break the global architecture. Only people with a complete mental model can catch that.

2. Spot irreversible choices

Not all decisions are equal. Changing a library is cheap. Changing a production SQL schema is not.

Examples of high-cost choices:

• Table schemas with active users
• The core database
• Communication protocols between services
• Your central domain model

"That's a choice with a degree of irreversibility. Develop an alarm bell for this type of choice."

When facing one: raise the alarm, increase reversibility with feature flags or abstractions, and ask: "If this is wrong in six months, how much does it cost to fix?"

3. Gate AI inference quality

If you run models in production, enforce quality gates on inference from day one.

"If you don't gate inference quality immediately, you pile kernel on kernel with numerical drift and errors. Later, recovering quality means rewriting kernels from scratch."

Monitor drift and error rates. Automate rollback when quality drops. Test across model families, not just the current one. Skipping this builds inference debt, the hard kind. Models change, kernels get rewritten.

4. Know when to stop

A psychological skill, not a technical one: knowing when to stop shipping and consolidate.

"When there are unsatisfied users and bugs, stop. Take time to restructure the foundations and fix the technical debt."

The math changed. Refactoring used to take months, so nobody stopped. With AI, it takes weeks. That makes stopping the rational choice.

If management pushes forward while the system is fragile, push back. Don't use AI as an excuse to run faster into a broken architecture.

5. Communicate mental models

As AI writes more code, human value shifts to communication.

"In a world where ideas and system models matter more, we must be skilled communicators, not only with LLMs and AI but also with other people."

You need to articulate why a PR is risky, not just what it changes. You need to onboard someone in thirty minutes, not thirty days. You need to lead whiteboard sessions: "Which direction do we take?"

Test yourself: can you explain how the system works, in plain language, in half an hour? If not, your mental model isn't clear enough.

6. Use AI as an amplifier

AI accelerates writing. It doesn't replace architectural thinking.

"Using AI as an excuse to always go forward, even as complexity and fragility pile up, exacerbates problems we already saw in traditional development."

AI for the details. Humans for the architecture. Treat AI as a sparring partner, not an oracle. Validate everything against your mental model.

7. Own your responsibility

The video ends with a strong point: professional responsibility.

"You are developers. Others use your software. Even when you work for other people, you can say: 'I strongly advise against this direction.'"

Engineers who build bridges refuse to cut steel. Software is no different. Fragile systems in production hurt real users. Say no when it matters.

The bottom line

Tomorrow's programmer isn't the one who writes code faster. AI wins that game.

Tomorrow's programmer:

• Sees the whole system
• Weighs consequences
• Guards quality when nobody asks
• Communicates models clearly
• Takes responsibility

Use AI to build solid things, not to accumulate debt faster.