The expanding use of AI coding agents creates a risk that junior software engineers may complete tasks faster without developing the judgment required for senior roles, according to a new essay from Criteo's engineering community. The author does not argue that software engineering is disappearing. Instead, the concern is that delegating too much of the learning process could leave developers able to supervise tools only with help from other tools.
The essay describes Criteo engineers as still being hired and valued while also being encouraged to use agents to improve productivity. That expectation comes with a qualification: engineers must understand and remain responsible for the work. For a junior developer, however, incomplete understanding is part of the starting point, which makes automation both useful and potentially limiting.
Four human capabilities form the article's proposed route toward greater responsibility: curiosity, emulation, autonomy and collaboration. Curiosity means asking an agent to explain unfamiliar choices, support assertions and justify recommendations that seem questionable. The author says this can expose weak suggestions while helping the engineer rehearse a senior developer's obligation to defend a design and redirect work that is moving in the wrong direction.
Review is treated as a skill that must be practiced rather than a final approval click. One suggested method is to study recurring comments from experienced colleagues—such as concerns about naming or established patterns—and apply those lessons before submitting agent-produced code. The author gives an example from a product-catalogue team, where new entity types were compared with existing ones and deviations were expected to have a reason. Capturing such conventions in instructions may improve an agent's first draft, but repeatedly examining that output is what develops the engineer's own judgment.
The essay also recommends periods of working without an agent. Senior engineers can often recognize a poor direction because they have previously made implementation choices themselves and dealt with the consequences. Independent practice gives newer developers a similar base from which to evaluate generated work, rather than accepting it because it appears plausible.
This is a practitioner's argument, not a controlled study of AI-assisted career progression. Its value lies in reframing the productivity discussion around training and accountability. Faster code generation does not automatically teach architecture, trade-offs or production diagnosis. Teams adopting agents therefore face a management question as much as a tooling question: how to preserve mentoring, review and deliberate practice while benefiting from automation.
The essay's central warning is that a capable tool cannot grant professional maturity on its own. Developers still need repeated opportunities to question decisions, learn a team's standards, work independently and explain what they ship.
