I Don't Care If AI Wrote Your Code

In September 2023, I was reviewing a pull request with a junior engineer I was mentoring. I asked them to explain what some code did and why they had taken that approach. They shrugged and told me it was what GPT had told them to do.
The code was plainly wrong. That was easy enough to spot. What stayed with me, and what I wrote about at the time, was that they had accepted it without understanding or questioning it. They had turned a possible answer into an implementation without any real engineering occurring in between.
I was fairly dismissive of AI‑generated code back then, but by September 2026 I was reflecting on agents investigating problems, finding their way around enormous codebases, proposing solutions, and writing tests and production code. It's fair to say that I had underestimated where the tools were heading. That earlier pull request remains a useful example of what I expect from the person using them.
I have always encouraged engineers on my teams to use whatever helps them do the work properly. Read the documentation. Find an existing implementation. Ask a colleague. Use Stack Overflow, a technical article, an LLM, or a coding agent. I am interested in the result and the reasoning behind it, not in auditing how much of the engineer's afternoon was spent typing out code.
AI can be a considerable force multiplier. Work that once took weeks can sometimes be done in days, without any real notable deterioration in quality, when the engineer understands the problem, can direct the work, and can judge what comes back. I actively encourage that in my teams. There is no particular virtue in taking three days to type something that could have been generated and properly checked in an afternoon.
The Code You Submit
We have been adapting other people's work for as long as I have been writing software. A documentation example might supply the structure of a request. A blog post might explain an awkward browser behaviour. A colleague might suggest a much simpler approach to a problem that we have spent the morning making complicated.
None of those sources takes responsibility for the change we eventually submit. The example might assume a different framework version, a smaller data set, or an environment which bears very little resemblance to ours. We have to establish whether it applies alongside whether it works.
An agent can produce a much larger change than a snippet from a blog; that gives us more to understand before we can submit our work.
I don't care whether an engineer typed the code themselves. I care whether they understand it and take responsibility for it. They need to be able to explain its behaviour, the assumptions they relied upon, and why it belongs in our application.
That does not mean that I need you to be reciting the internals of React or personally inspecting every dependency down to the operating system. We work through abstractions because otherwise nothing would ever get finished. It does mean understanding the contract we are relying on, checking the behaviours that matter for the task at hand, and knowing when an assumption needs investigation rather than blindly repeating.
To offer an example, suppose that an AI agent adds caching to a slow endpoint. The response will be faster, the tests will pass, and the diff looks quite reasonable. Before approving that pull request, though, I would want to know whether that response varies by user, what the cache key includes, and what happens when the underlying data changes. A fast response containing somebody else's information would be a fairly substantial problem with an otherwise attractive optimisation.
Those questions come from understanding the application. An agent can help investigate them, trace the relevant code, and add tests. The engineer still has to recognise which questions matter and decide whether the answers are sufficient enough.
Tests make up an important part of that decision; they can demonstrate that particular behaviours hold, catch regressions, and can quickly expose a mistaken assumption in the code. They can also faithfully encode the same wrong assumption as the implementation. If the test expects the wrong thing, passing it is not much of an achievement. Reviewing the requirement and the test's reasoning matters just as much when the test was generated alongside the code.
Security checks, integration tests, and architecture review have different jobs to do in this regard, too. I have written about why cheaper implementation does not make QA dispensable. The useful question here is which evidence gives us confidence in this particular change, including its failure paths and effects on the surrounding system.
Generating Faster and Finishing Sooner
My earlier writing about AI in web development concentrated on small, bounded tasks. Those remain useful, but I would not now make boilerplate the limit of what an agent is allowed to contribute to your codebase when steered by an attentive and experienced engineer. They can direct substantial investigation and implementation, provide missing context, reject a poor approach, and keep the work tied to the actual problem (where, in my experience, AI can often wander into adjacent areas of the feature if left to its own devices). That is a valuable use of experience.
Faster generation still needs to translate into finished work. Three workplace experiments involving 4,867 developers found more completed pull requests with Copilot. Microsoft was involved in that research, and completed pull requests do not tell us the full cost of owning the code. METR's early‑2025 experiment, on the other hand, found experienced contributors taking longer on tasks in repositories they knew well. Its February 2026 follow‑up could not establish a reliable updated estimate because participation and task selection had changed.
I would not turn those results into a universal verdict on today's agents or their capabilities. A tool can be enormously useful for one piece of work and an expensive distraction for another.
Nor do I assume that generated code must be worse to maintain. A June 2026 study found no significant maintenance penalty when developers worked on implementations created with different levels of AI assistance. It covered limited tasks in one application, not years of changes. I still need to assess the implementation in front of me.
However, experience is not an immunity from getting things wrong. Knowing a codebase well can help us question a proposal; it can also make a familiar‑looking proposal easy to accept. The work still needs checking.
Before Somebody Else Reviews It
The time saved producing a change is not necessarily time saved reviewing it. An agent can generate another several hundred lines whilst a colleague is still working out whether the previous change is safe to merge or not. I would argue that the increase in code productivity has a direct impact on how long a pull request then requires to review and approve.
A July 2026 preprint examining one company's adoption found roughly twice as many pull requests per reviewer and much greater use of automated review, whilst merge and revert rates remained broadly the same. The company had an explicit productivity mandate, and this was an observational study with limited measures of quality. More code was being merged, but accommodating it had changed how review was done.
I am quite comfortable with spending more time of my time reviewing my team's code if it helps us deliver useful work sooner overall. Code reviews are an essential part of engineering, and some changes deserve a great deal of attention. But submitting an implementation without trying to understand it, and leaving that work to the reviewer, is not ok.
The submitting engineer should already have read the change, checked it against the requirement, investigated the relevant risks, and tested what they reasonably can. They should be able to explain what still feels uncertain to them. A reviewer can then challenge that understanding, spot something they missed, or suggest a better decision. The reviewer should not have to reconstruct the author's reasoning because the author never formed any.
There is room here for asking for help. I would much rather an engineer flag an unfamiliar authentication boundary and ask for a second pair of eyes than confidently wave through a suggestion they cannot assess. Owning a change includes recognising where we need someone else's expertise. It does not require pretending to know everything.
This distinction really matters for learning too. In a small randomised experiment published by Anthropic in January 2026, developers learning an unfamiliar Python library with AI assistance scored lower on an immediate unassisted quiz. The overall time advantage was not statistically significant. That is a study of acquiring unfamiliar knowledge in one session, not proof that established engineers are losing their skills. It does show why a finished task and an acquired understanding deserve separate attention.
As an engineering lead, I need to make time for that understanding. If I encourage engineers to use agents and then judge them entirely by how quickly pull requests appear, I am encouraging the exact shortcut that I object to in review. Explaining a decision, investigating a failure, or admitting that the answer is still unclear has to count as work. Otherwise, the easiest way to look productive is to stop asking questions.
I would keep changes small enough to reason about, make expected behaviour explicit, and use automated checks for the things they can reliably catch. Where the risk warrants it, I want design discussion before an agent produces a large implementation. Those are practical ways to help people use powerful tools well, without turning every review into an interrogation about whether AI was involved.
What I wanted from that junior engineer in 2023 was an explanation of the code and a reason for choosing it. With much more capable tools available, that remains a reasonable thing to ask. I don't need the person submitting a change to have typed every line. I do need them to understand what they are asking the rest of us to accept.