Why Developers Still Say "I Built It" When Claude Wrote the Code
A Hacker News user posting as gonzar79 asked why developers say "I built it" instead of "Claude built it for me" or "I asked Claude to build this." The thread's dominant answer is that authorship in software has never been defined by who performs the keystrokes — it is defined by who sets the goal, steers the work, ships the result, and accepts responsibility for it. Claude is treated by most commenters as a tool in the same category as a compiler, an IDE, or a CNC machine.
The core argument: accountability defines authorship
The most-upvoted reasoning in the thread is that the person who ships a product owns it, regardless of which tools produced it. The claim "I built it" is a claim of responsibility, not a claim of manual labor.
Because they did. No matter what tools they used, they are accountable for the resulting product. People who use CNC machines to create physical objects don't reject the idea that they made the object, even though the machine did the work. Don't fall into the trap of anthropomorphizing Claude, or any other LLM. It is a tool. The person using it is still the creator.
A related comment sharpens the distinction between generating code and building a product: the model did not independently decide what to make.
Because Claude didn't somehow sit down and analyze my business and come up with the most custom, bespoke piece of software possible to serve its needs. I did that.
The tool analogy: compilers, IDEs, and the JVM
Several commenters argue that the "Claude built it" framing collapses if applied consistently, because developers already delegate enormous amounts of code generation to non-human tools without changing how they describe their work.
Because Claude is a tool, just like other development tools. We don't say "My IDE built it", or "the compiler built it", regardless of the optimizations and generated output it provides. Claude (and LLMs in general) takes an input and generates an output as a general purpose tool.
One commenter reduced the question to a direct equivalence between two levels of abstraction:
What's the difference between you writing Java and then the JVM building the application, and you writing English and then Claude building the application?
Another pointed out that the tooling lineage predates LLMs entirely, citing an early computer science assignment that required hand-entering Alt codes in DOS to produce a binary executable.
In one of my first CompSci classes, we had a homework assignment that involved using Alt code in DOS to create a binary executable. These tools are more advanced :) but they are still just tools.
The counterpoint: depth of involvement decides the claim
The thread is not unanimous. A recurring refinement is that the honest verb depends on how much steering, planning, and maintenance the human actually contributed. The same commenter can legitimately disclaim one artifact and claim another.
It's about depth of involvement, steering and ownership. I had Claude build me some TamperMonkey scripts here and there, I don't claim I wrote those. I do claim I built my side project with it being mostly vibe coded, because I've steered, planned and guided every aspect of that site regardless of how it was built. I own it, I maintain it. Months of building on the side.
One commenter proposed a simple test for allocating credit:
Would Claude have built the thing without me, for me to use? If not, I'll take full credit. Would I have built the thing without Claude? If not, I'll retain some credit and leave some credit to Anthropic's team for the help.
"I designed it" may be the more accurate verb
A practical suggestion in the thread is that "built" is not the only available word. For AI-assisted work where the human supplied the specification and the model supplied the implementation, "designed" may describe the contribution more precisely.
"I designed it" is also a possible choice. When Claude gets to the point that you can build a functional equivalent of Adobe Creative Suite, with one and only one prompt, then "Claude built it for me" might become appropriate. But we're not there yet. There is still significant work that goes into shaping a software package even when people vibe code.
Other commenters offered alternative verbs for the same activity, including "I generated it" and "I willed this into existence."
The agency inconsistency
A notable observation is that the same people who insist an LLM is "just a tool" with no intelligence or agency often also insist the human directing it deserves no credit either. One commenter framed this as a contradiction:
AI haters simultaneously want to rob AI of intelligence and agency and insist it is just a dumb tool but then in the next breath want to say the person who commands it also has no agency or intelligence.
The same commenter noted that attributing agency is inconsistent in both directions, pointing to cases where people object to phrasing like "OpenAI's agents hacked Hugging Face" even when logs show the agent behaving deliberately. The comment extends the point beyond AI:
Such discussions are not limited to AI. "We won the World Cup!" like they were in that football team, "We went to the moon!" like they were even born yet when the last Apollo mission returned to Earth, "Musk's new spaceship/car" like he's the developer rather than the owner.
The dissenting view: insecurity and legal exposure
Not every commenter accepts the tool framing. One attributes the language to anxiety about skill loss:
The reason is insecurity. People forfeited their skills and knowledge to a black box and want to feel useful.
Another raises a practical objection about liability rather than credit, arguing that claiming authorship of code you do not fully understand carries risk:
Fully agreed. More so because (1) you can't make that claim legally and (2) you are assuming responsibility for something you do not know everything about.
Credit is layered, not binary
A quieter theme in the thread is that "who built it" is the wrong question because all software is built on prior work. One commenter invoked the classic framing that nothing is made from scratch:
We all stand on the shoulders of others work. Designers use fonts, engineers tools, etc. To make an apple pie from scratch you must first invent the universe.
Extending that logic, another commenter noted that the training data behind Claude was itself produced by a large number of people, and suggested the pronoun might reasonably be "we."
Practical takeaway
The thread's working consensus is that "I built it" remains defensible when the speaker set the direction, made the product decisions, shipped the result, and maintains it. "Claude built it" becomes the more accurate description as the human contribution shrinks toward a single prompt. For work in between, "I designed it," "I built it with an agent," or "I steered it" communicate the split more honestly than either extreme.