# AI-Written Code Is Still Your Code

A short essay from martiansoftware.com built around one observation, which the author puts in bold: "We've never needed to treat *understanding* our own code as a separate cost from *writing* it, because writing it largely *forced* us to understand it" [[ai-written-code-is-still-yours]].

## Unbundling writing from understanding

Coding agents push the cost of writing software toward zero, and for most projects writing was the bulk of the work of shipping. But writing always came bundled with something taken for granted. Outside homework-sized problems it is hard to write something you don't understand and still satisfy a professor, a boss or a customer, so the understanding came along for free. There is plenty of writing about designing systems that *others* can understand; the author's point is about understanding code you wrote yourself, which nobody had to think about. Even the familiar experience of finding your own old code baffling assumes that it made sense to you at the time you wrote it.

With agents doing the writing, that understanding becomes optional, and the author is dry about how far it goes: have agents review and test the code too, "and we can avoid those pesky mental models altogether!"

## Ownership is not optional

He has no objection when the stakes are low. He has built one-off personal tools and a couple of fun projects this way, things that would otherwise have stayed in a someday pile. The line is ownership, meant beyond intellectual property: whoever builds software takes on its quality and security, and debugging, operating, maintaining and evolving it over time. The question he wants people to ask changes from "Can we build this?" to "Do we want to own this?", and he wants that to be a conscious decision rather than a responsibility discovered once the code is already yours.

He calls human understanding of generated code the new bottleneck, and says AI "can be a complexity factory". The essay ends on a direction rather than a proposal: making understandability to humans a first-class design goal, not by understanding every line but by designing systems whose pieces are understandable and whose boundaries let a person zoom in and out and reason safely at several levels. He says he is developing ideas along those lines, so the essay reads partly as a preface to later work.

## How it sits in the vault

The piece is brief and makes its case without data, but the framing is a clean statement of something several pages circle. [[cognitive-debt]] is the measured version of the unbundling: the MIT group found that most LLM-assisted writers could not quote their own essay, which is understanding failing to arrive when the writing is done elsewhere. [[programming-as-theory-building]] supplies the older claim that the understanding was always the real product. [[disposable-code]] covers the low-stakes case the author exempts, where code is cheap enough to throw away and ownership barely applies, and [[cheap-reverse-engineering]] is a concrete example of it.

On the opposing side, [[control-the-ideas-not-the-code]] argues that line-by-line understanding of LLM code is wasted effort as long as you own the design, which is close to the author's multi-level zooming but gives up more of the detail. [[not-understanding-your-codebase]] argues partial understanding is normal at scale anyway. [[writing-code-vs-building-software]] also holds that shipping generated code means owning it, but defines owning as having understood and validated every part, stricter than this author's zooming between levels. Both are compatible with his closing idea, since both depend on boundaries that let someone reason about a part without the whole.

[[refactoring-that-never-happens]] makes the team-level version of the same argument: the moment a human got lost in the code used to trigger a refactoring, agents never get lost, and so the structure that keeps code understandable stops being maintained. [[peril-of-laziness-lost]] is the reason the "complexity factory" line holds: work costs the agent nothing, so nothing in the agent pushes toward less code.