Human remains accountable even when AI writes the code, says Hugo Venturini

In an episode of the Engineering Culture podcast from InfoQ published on November 13, 2026, editor Shane Hastie interviewed engineer Hugo Venturini about a problem that the adoption of generative AI has made more visible: who is responsible when the code written by an agent goes wrong.

Venturini's résumé spans language typing, search, and organizational culture. He earned a PhD in 2008 on debugging optimized code, was a manager at Meta (then Facebook) responsible for the type checker and compiler of the Hack language, founded and grew his own company, and was CTO of Qwant, the European search engine, leading 90 people including network engineers and AI researchers. He now works at an AI tools startup.

AI Doesn't Remove Anyone's Accountability

The central point of the conversation is direct: for Venturini, AI is a powerful tool, but whoever operates it remains in charge and must answer for the result.

AI is just another tool. And yet if it fails, the one conducting this great tool is accountable, is in charge and should answer what goes wrong.

Hugo Venturini, software engineer and former CTO of Qwant

According to him, AI-generated code needs to be precise "down to the semicolon," and when the tool makes a mistake, good engineering around the model can provide the right feedback so it corrects itself before reaching the human.

The Problem of Giant Pull Requests Already Existed Before AI

Hastie brought up a common symptom in teams today: increasingly large pull requests, sometimes thousands of lines long, piling up in review queues. Venturini disagrees that this is a problem created by AI.

For him, PR size was already a challenge before code agents, and the answer doesn't change: not everything needs line-by-line human review.

• Code that compiles and passes the tests the team itself wrote has already gone through much of the verification possible.
• Mature teams already operated on trust: a senior engineer can merge without outside review, taking responsibility if something breaks.
• What actually needs human review is the core of the product (for quality) and the parts that spread knowledge across the team.

Venturini does acknowledge a new problem, one that is indeed tied to AI: not the size of each diff, but the number of diffs that AI allows to be generated in parallel. He admits he has no ready answer for this and said publicly, on the podcast, that he's looking to hear how other teams solve the issue.

The Microsoft Precedent from 2014

To illustrate how merging roles can raise quality, Venturini cited a concrete case from his own career: in 2014, Microsoft merged the software engineer career track with that of tester, ending the cycle in which one group wrote code and another tested it separately.

By removing the official testing step by somebody else, it actually raised the quality of the software. And the reason I believe is because it made software engineers accountable for the final product, not one step of the chain.

Hugo Venturini

The risk, according to him, is that AI reverses that gain: by turning every engineer into a "tester" of what the model generates, accountability for the complete product can dilute again, if people start blaming the tool instead of seeing themselves as owners of the result. Venturini reported having noticed a drop in quality in software he uses, coinciding with press reports about heavy AI use by those teams, though he didn't point to specific cases.

Roles Collapsing: PM, Architect, Tester

AI is also erasing boundaries between roles that organizational growth had separated over decades, such as product manager, architect, and tester. In small startups, a single person takes on all of these roles; large companies split these functions among specialists.

For Venturini, AI pushes organizations back toward the startup model, where everyone does a bit of everything, except now with tools that let anyone perform roles they were never trained for. He argues this requires deliberate investment in training, because AI responds well to the question asked, but doesn't replace the skill of asking the right question, something he directly associates with seniority.

Transparency as a Precondition for Accountability

The second half of the conversation dealt with how leaders build a culture that allows people to take on accountability without fear. Venturini shared a personal case: he took over as CTO of a company with an organizational culture he described as broken, marked by lying and hiding information.

People dare to do things if they know they will be accountable but not blamed for what happens.

Hugo Venturini

The solution he described had concrete steps:

1. Establishing a weekly Q&A session open to the whole team, answering with honesty, including admitting mistakes publicly.
2. Naming solutions and products, never people, when discussing problems.
3. Creating an anonymous question channel, relayed by managers from other areas so that not even he could identify the source.
4. Letting the team vote on the most relevant questions for the next session.

According to him, the effect was gradual: the first questions were easy, but over time, the team started bringing difficult questions, a sign that trust had been established.

Culture Change Doesn't Depend on Hierarchy

Asked how someone without formal power in the organization could promote this culture, Venturini replied that there's no such thing as "just" a team lead: every position has something to contribute. He mentioned having seen isolated teams within a 1,200-person company adopt these transparency practices on their own, with smaller impact since they were limited to one team, but still relevant.

For him, mid-level managers face a particular difficulty: they answer simultaneously for their own team and for being part of a body of managers with goals that sometimes conflict with the team's. His recommendation is to lead by example at a small scale and let the visible result convince other managers to replicate the practice.

What Remains Open

Venturini was explicit about not having a ready answer for the problem of the volume of AI-generated pull requests, even when each one is small and individually reviewable. He also didn't present metrics proving the drop in software quality he says he has observed, treating it as personal perception, not as settled data. The full interview, with the complete transcript, is available on the InfoQ website.