A reviewer opens a pull request that touches thirty files, sees a green pipeline, and cannot say which of the changed functions anyone on the team has actually discussed. The author cannot say either, because most of the diff arrived from an assistant in one pass and two assertions were loosened until the build passed.
The argument about AI and software quality is usually staged as an argument about tools. It is better understood as an argument about what a change is. Once that question is settled, the rest of the debate follows: what a review is for, what a test is evidence of, and what a team owes the people who depend on the system afterwards.
Craft is a claim about a change's lifetime
Software craftsmanship, in the sense the term has carried since the manifesto of 2009, is not a preference for handwritten code or a nostalgia for the era before code completion. Bytecraft describes it as a professional philosophy that treats development as a skilled trade, built on technical mastery, ethical responsibility and a commitment to improvement, and its values begin with well-crafted software and steadily adding value. The operative idea is narrower than the philosophy: a change is judged over its lifetime, by the people who inherit it, and its verdict arrives long after it compiles.
That framing matters because generated code and hand-written code are indistinguishable at the point of merge and wildly different six months later. What differs is not the syntax. It is whether the decisions encoded in the diff were made deliberately: where a boundary sits, what a function refuses to accept, what happens when a dependency stalls, which failure wakes someone up.
Tim O'Reilly, in his preview of the O'Reilly AI Codecon on this subject, argues that the craft is migrating, and he describes the direction as a move "from writing code to designing systems, from typing to taste". If that is right, the object of craftsmanship has always been the set of decisions that a file encodes, and the arrival of a fast generator simply makes the distinction impossible to ignore.
The distinction that private app building made concrete
Unite.AI reported that Google now lets Android users build an app by describing what they want and run it privately on their own phone, with no public store listing and an initial release limited to the United States and to adults. The same Unite.AI report quotes Google's Sam Bright describing the shift as a move from "there's an app for that" to "there's an app for me".
That is a real widening of who gets to build, and most of what it produces will be small, personal and entirely exempt from the machinery of professional release management. The useful question is not whether these are apps. It is where accountability begins, because accountability is the attribute that separates a personal tool from a system.
| Question that separates the two | A personal app | Software other people depend on |
|---|---|---|
| Who carries the consequence of a fault | the person who built it | people who never saw the code |
| How long a fault may persist | until it inconveniences its author | until it is detected, contained and explained |
| Who approves a change | nobody, or the author | someone accountable for the service |
| What evidence a release needs | that it worked once | tests, review and a record of what changed |
| What happens when the author leaves | the app leaves with them | the system must outlive the team |
Nothing in that table is about difficulty. A personal app can be hard to write and a production service can be simple. The difference is who bears the cost of being wrong.
Velocity is visible first, and it flatters
Delivery metrics respond to AI assistance within a quarter. Quality metrics respond later, and by then the narrative has hardened.
Cortex's Engineering in the Age of AI: 2026 Benchmark Report, drawing on a survey of more than fifty engineering leaders and development metrics across several organisations, recorded these signals together:
| Measure | Direction recorded |
|---|---|
| Pull requests per author, year on year | up 20% |
| Incidents per pull request | up 23.5% |
| Change failure rate | up approximately 30% |
| Organisations with a formal AI usage policy | 45% |
Read separately, those look like four findings. Read together, they are one finding seen from four angles: generation became cheap, review did not, and the gap between the two is where defects now accumulate. Cortex's own description is that AI behaves as an indiscriminate amplifier, magnifying whatever practice a team already has.
The mechanical reason is worth stating plainly, because it explains why the problem does not resolve itself with better models. Agents cannot reliably distinguish essential complexity from accidental complexity, so they remove some of the first and add a great deal of the second at machine speed. Wes McKinney's talk at the O'Reilly AI Codecon, described in O'Reilly's preview of the event, makes the point that a codebase can reach a size where agents begin to struggle with the volume of code they themselves produced, and that taste, the judgement about what to build and what to leave out, becomes the scarce resource. That is not a tooling problem. It is a design problem wearing tooling clothes.
Shared understanding goes before quality does
The failure that never appears on a delivery dashboard is the one where the software works and nobody can explain it.
Sandro Mancuso, writing for Leeds Digital, describes a developer who submitted a large pull request touching dozens of files, and who, asked how specific edge cases were handled, replied: "I'm not sure. I'd have to look at the code again." The point is not that the developer was careless. It is that the act of writing is how a person internalises a business rule, and when the writing is delegated the internalisation does not happen by default.
Mancuso's related observation, in the same Leeds Digital article, is that review is a knowledge-sharing activity before it is a gate, and that it stops being either once a diff is too large to reason about. His piece also notes the feedback direction: a codebase with weak boundaries and inconsistent naming gives a model poor patterns to continue, so structure that was already degrading degrades faster.
None of this is an argument against the tools. It is an argument about where the effort has to go. If review is the scarce activity, then the discipline is whatever makes review possible.
A discipline you can write down
Abstract commitments do not survive contact with a busy week. These five rules do, because each one produces something a reviewer can check.
- Reproduce the fault before you change anything, using a failing test or a recorded request that shows the behaviour you intend to fix.
- Fix at the origin. If a null value reaches a formatter, the change belongs where the null was admitted, and the assertion that caught it stays as it is.
- Bound the diff to the request. If a change cannot be read in one sitting, it should be two changes.
- Run the check yourself in a clean environment and quote the output. A claim of completion without fresh output is a guess with confidence.
- Write down the assumption the change makes, so the next person inherits the reasoning and not only the diff.
The software-craftsmanship repository on GitHub packages this kind of discipline as installable rules for coding agents, with test integrity treated as non-negotiable. Its rule set forbids deleting, skipping or weakening an assertion to force a passing build, and it requires a failing test that reproduces a defect before the fix. That is a small example of the larger principle: the practices that make AI output reviewable are the same practices that made hand-written code reviewable, and none of them depend on the generator.
The craft does not move to a different person when the tool changes. It moves to a different decision. A team that can say why a boundary exists, what a test proves, and who answers for a failure at three in the morning is still doing the work that software has always demanded. The tools only make the absence of that work easier to see.
Sources
- Vibe-Coded Personal Apps vs Production Software
- Software Craftsmanship in the Age of AI – O’Reilly
- Engineering in the Age of AI: 2026 Benchmark Report - Key Findings | Cortex
- Software Craftsmanship in the AI Era - Leeds Digital
- What Is Software Craftsmanship? A Complete Guide (2026)
- GitHub - SamJU25/software-craftsmanship
from writing code to designing systems, from typing to taste
Source: The App Economy Is Changing: What Happens When Anyone Can Build Their Own Software?, Unite.AI


