← Carlos Cardona

Outcomes, not authorship

Two questions keep coming up when I talk about building with AI.

The first one: "but did you write this article, or did the AI write it?" The second one, usually from senior engineers: "juniors are never going to have the scars of doing the groundwork, so how will they ever really understand things?"

They sound like different concerns. They are the same mistake. Both judge the work by the process that produced it, and both take one particular biography, the speaker's own, as the required process. I had to fight the compiler, therefore fighting the compiler is where understanding comes from. I typed my essays, therefore typing is what makes them mine.

Here is my test case. I built a personalization engine in Python, a full project, and it multiplied conversion roughly three times. I do not know Python. The agents wrote the code; I directed the system: what it should do, how it fit the product, what to measure, what was good enough to ship, and what to change when it was not.

Now, did it matter that I do not know Python? It used to. Not knowing the language meant you would make mistakes you could not see, or you could not even get the thing deployed. Knowing Python was a proxy for being able to deliver a working outcome, and proxies are useful right up until the world changes. The world changed. The outcome is now directly observable: the engine runs, conversion tripled, I can modify and maintain it. Checking the proxy after you have measured the real thing is not rigor. It is nostalgia.

The same logic answers the article question. Yes, an AI types most of my drafts. The thesis, the examples, the position being defended, the decision that paragraph four is wrong and gets rewritten: that is me directing the piece. If the argument is bad, it is bad because I directed it badly, and no amount of "but I typed it myself" would redeem it. Authorship did not disappear. It moved up, to the level where it always actually lived: deciding what is worth saying and whether the result says it.

Which brings me to the juniors, because the scar argument deserves a real answer, not a shrug. The fear is that people who skip the groundwork will be hollow, all surface and no understanding. But look at what actually happens to their time. A junior starting today spends the years I spent on mechanical debugging working instead at the level of systems: what to build, how components fit, why an architecture holds or collapses. Same years, higher altitude. There is a real chance they become better architects and better system designers than my generation, precisely because their reps happen where the leverage is instead of where the typos are.

We have run this experiment before. Nobody argues that programmers who never wrote assembly are hollow, or that engineers who never managed memory by hand cannot be trusted with software. Every generation of tooling deletes some scars, and every generation of veterans predicts the newcomers will be lesser for it, and the newcomers keep being fine, because understanding attaches to whatever level you actually work at.

None of this means nothing matters anymore. It means one thing matters and one thing never did. Does it work, does it hold up, does it produce the result: that always mattered. Whose fingers touched it: that never did. We just could not measure the first thing cheaply, so we policed the second. Now we can. Judge the work.