Is It Still Your Code If You Didn't Write Any of It?

The ship in the harbor

In his Life of Theseus, Plutarch describes the Athenians preserving Theseus's ship for generations. As planks rotted, they swapped in sound timber. By the time of Demetrius of Phalerum, the ship had become a standing argument among philosophers, one camp insisting it was the same ship, the other that nothing of the original remained.

Every developer now lives inside that argument. We just don't call it philosophy. We call it a pull request.

Planks we stopped counting

Start with the oldest swap. Nobody writes machine code anymore. Assembly replaced it, C and COBOL replaced assembly, and compilers now translate intent into instructions no human will ever read. Nobody says, "That's not your program; the compiler wrote the binary."

Then came the Stack Overflow era, which we remember as pure craftsmanship. It was hours of searching, a half-understood answer from a stranger, a snippet adapted and pasted, a library imported without ever opening its source. Add the framework doing the routing, the ORM writing the SQL, and the cloud platform deciding where it all runs. We still said, "I built this."

So the planks were always changing. We agreed not to count them.

But notice what made that agreement safe. The compiler had a specification and a test suite. The library had an interface contract. The framework behaved the same way on Tuesday as it did on Monday. You could skip reading those planks because somebody upstream had already earned the trust, and because the behavior was reproducible. Those were abstractions. You delegated understanding to a system that had been verified by someone else.

That is not what a language model is. The compiler was a plank you could trust without inspecting. The model is a shipwright you have to supervise. The distinction matters for everything that follows, because the old argument ("we've always borrowed") gets you to the edge of the problem and then stops explaining anything.

The new planks

On February 2, 2025, Andrej Karpathy, a founding member of OpenAI and Tesla's former director of AI, posted on X about a "new kind of coding" he called vibe coding. His version meant talking to Cursor by voice, barely touching the keyboard, and accepting whatever came back. Nine months later, Collins Dictionary named it Word of the Year for 2025.

The practice has since split into three modes, and each one answers the Theseus question differently.

Vibe and ship. Prompt, accept, deploy. You judge the code by whether it runs. No plank is yours, and you have not looked at any of them. This is the mode Karpathy described, and the one the term still evokes.

Vibe and repair. Generate with Cursor or Claude Code, then go back in by hand to fix what feels off. You are a surgeon operating on something grown in a lab. Some planks are yours, and you have at least touched the rest. Most professional use lives here.

The agent loop. One agent writes, another reviews, a third patches what the second one found, and the human reads the summary. This is where the puzzle gets strange. In the first two modes, a person still handles each plank, however briefly. In the loop, no human touches a plank at all. The only thing the human owns is the brief and the decision to merge.

Each mode replaces more planks than the last, and faster than anyone can sentimentally notice. The third mode replaces the shipwright too.

What we lost, what we gained

The old workflow had a texture. You hit a bug at midnight, found a four-year-old thread, and realized the accepted answer was wrong, but the third comment was right. You sketched a system design on paper, got it wrong, and redrew it. The struggle was slow, but it deposited understanding like sediment.

The new workflow compresses that, and the evidence on whether it helps is messier than the hype. In a randomized trial by METR run from February to June 2025, 16 experienced open-source developers completed 246 real tasks on repositories they knew well. When AI tools were allowed, they took 19% longer. Before the study, they expected to be 24% faster; afterward they still believed they had been 20% faster.

METR now flags that result as out of date. Its February 2026 follow-up, with 57 developers and 800-plus tasks using late-2025 agentic tools, found the sign had probably flipped: returning developers were an estimated 18% faster with AI, new recruits about 4% faster, both with confidence intervals that cross zero. METR says even those figures are likely a floor, because developers increasingly refused to submit tasks they didn't want to do without AI. The tools got faster. The perception gap didn't go away, and the follow-up surfaced a new one: several developers said they couldn't reliably report time spent because they were working on something else while the agent ran.

That last detail is the one worth sitting with. The study measured speed, and speed is now probably positive. Nobody has measured the understanding gap directly, and I'd bet real money it widened over the same period, because the thing the developers stopped doing was watching. But that is a bet, not a finding.

Developers have already priced this in, and the pricing is visible in Stack Overflow's two most recent surveys. The 2025 survey found 46% of developers distrusted the accuracy of AI output, up from 31% a year earlier, and nearly 77% said vibe coding was not part of their professional work. Asked why they'd still turn to a human, three in four said they don't trust AI's answers.

The 2026 survey, published this week with 30,903 responses from 169 countries, complicates that story in a useful way. Sentiment recovered: 62% now view AI favorably, and 80% use it at least an hour a day. But the trust that came back is conditional. Asked how much they trust AI output in their workflow, 48% said "when I can easily verify it", 16% trust it for low-risk tasks only, and 16% for many tasks but not important decisions. Just 6.6% trust it for important work decisions. And 93% said source attribution matters to whether they trust an AI answer at all. Developers also draw a line at the water. Per Stack Overflow's own write-up of the results, 67% use AI to generate code in areas they already know and 61% to debug, but only 20% let it near deploying, operating, or troubleshooting production.

Read those numbers together, and the pattern is not "developers distrust AI." It is "developers trust AI exactly as far as they can inspect it." That is the Theseus test stated as survey data. The planks are fine as long as you can still see the joints.

The gains are real. The 2026 survey also found the share of developers working as freelancers or sole proprietors jumped from 3.9% to 10.5% in a single year, which is the solo founder building what used to take a team. But if the struggle built the understanding, what builds it now? That is the quiet engine of the paradox. The planks are being replaced, and so is the process that taught us the shape of the ship.

Two ships in the harbor

Thomas Hobbes added a twist in De Corpore (1655). Suppose someone gathered the discarded planks and rebuilt them into a second ship. Now there are two candidates, and both have a claim: one has the continuity, the other has the original matter.

Your repository already contains this scenario. The hand-written first commit and the agent-refined version in main are two ships sharing one history. The original has the purity of authorship. The descendant has the features, the tests, and the users. Anyone who has refactored a prototype knows the uncomfortable answer: the original is more yours, and the descendant is more useful. Git keeps both and settles nothing.

Hobbes couldn't resolve it either, and his failure is instructive. He concluded that the question had no answer in the objects themselves. Which ship was Theseus's depended on what you cared about: the wood or the voyage. That is the honest position for code too. If you care about keystrokes, the first commit is your ship and everything since is someone else's. If you care about what the system does and whether you can answer for it, the ship in main is yours, and the first commit is driftwood.

Where identity actually lives

Philosophers have offered several ways out, and each maps onto code:

• Material identity. It's the same ship if it's the same planks. By this test, almost no software has ever been "yours." Your dependency tree alone disqualifies you.
• Formal identity, the Aristotelian view. It's the same ship if it keeps the same form. Here your architecture is the ship: the boundaries, the data flow, the decisions about what fails and how.
• Continuity. John Locke, in the 1689 Essay Concerning Human Understanding, tied identity to a continuous organized life rather than to matter. It's the same ship because each change grew out of the last. Here your intent is the ship, an unbroken chain of decisions about what the system is for.

Every one of these points away from keystrokes. I'd put code identity on three legs: intent, architecture, and accountability. Accountability is the one that cashes out in practice. When the system fails at 3 a.m., someone can explain it, defend it, and fix it. If that someone is you, the ship is yours. If that someone is a prompt you'd have to write from scratch, it isn't.

Theseus stayed the captain no matter who swapped the planks. He decided where the ship sailed, and that made it his.

The ghost-ship problem

A ship that keeps its structure but loses its captain is a ghost ship. It still floats. Nobody is steering.

The real risk of vibe coding was never that a machine wrote the code. The risk is that you can no longer explain it. Code you can't reason about is borrowed, however it got into your repo. When it breaks, you aren't debugging anymore. You're describing the symptom to the same system that caused it and hoping for a different answer.

So the useful test has nothing to do with who typed. Ask three questions:

1. Can I explain why it works?
2. Could I rewrite the critical parts without help?
3. Do I know what happens when it fails?

If yes, it's your code, even if an agent typed every character. If no, it belongs to nobody, and the 2026 survey respondents who refuse to let AI near production already understand that at the level of policy, whether or not they've read Plutarch.

The new craft

If planks are cheap, the scarce skills move up the stack:

• Taste: recognizing code that is clever but wrong, or correct but wrong for your system.
• Systems thinking: agents generate components easily and integrate them badly. The old system-design instinct matters more now, not less.
• Verification: tests, reviews, and observability are the new keel. The survey's 93% who demand source attribution before they trust an AI answer are describing a verification habit, not a preference.
• Interrogation: treat the model like a sharp junior engineer. Question it, push back, make it justify its choices, and notice when the justification is fluent and empty.

The COBOL programmer's discipline was precision. The Stack Overflow era was research. What this era demands is judgment, which is harder to teach and impossible to prompt for.

The verdict

So, is it your code or the agent's?

It's the same question we could have asked about the compiler, the framework, and the borrowed snippet, with one difference that changes everything: those earlier planks came pre-verified, and these don't. That difference is why the old answer ("we've always borrowed") stopped being sufficient, and why the Theseus question has gone from a seminar curiosity to an engineering policy.

The better question is the one Theseus would have asked: who is steering?

Models will get better, and agents will take on more. Before long, most keystrokes in any repo will belong to nobody. The ship stays yours only if you stay the captain: knowing where it's headed, why it was built that way, and what to throw overboard.

Replace every plank you like. Just don't lose the helm.

References

1. Plutarch, Life of Theseus 23. Loeb translation, University of Chicago Penelope.
2. Hobbes, T. (1655). De Corpore, Part II, ch. 11. Discussed in Stanford Encyclopedia of Philosophy, "Identity Over Time".
3. Locke, J. (1689). An Essay Concerning Human Understanding, Book II, ch. 27. Discussed in Stanford Encyclopedia of Philosophy, "Personal Identity".
4. Karpathy, A. (2 Feb 2025). Post on X coining "vibe coding".
5. Collins Dictionary (Nov 2025). Word of the Year 2025: vibe coding.
6. METR (10 Jul 2025). Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. Paper: arXiv 2507.09089.
7. METR (24 Feb 2026). We are Changing our Developer Productivity Experiment Design.
8. Stack Overflow (29 Jul 2025). 2025 Developer Survey press release. Full data: survey.stackoverflow.co/2025.
9. Stack Overflow (6 Oct 2026). 2026 Developer Survey, AI trust data, and launch post.