This site is about AI on hardware I own. This post is about something else: the work below was done by Claude Opus, a cloud model. I dictated the points of this post, Claude drafted the text from them and from the repository’s history, and I edited it.
object-sizeof is a small JavaScript utility that estimates the size of an object in bytes. I published it in 2014 and still maintain it. I picked it up again this month for one reason: to test the idea that writing software is now basically automated.
The test
I ran Claude Opus in Claude Code with ultracode, the mode that splits a task across several agents and puts sceptics and adversarial reviewers on the result. It takes more time than usual vibe coding, but it brings quality.
On the evening of 2 November it produced 2.7.0, which fixed three reported issues: web workers, ESM bundlers and the TypeScript default import. The next morning it produced 3.0.0, a new implementation. Versions 2.x measured an object by serializing it to JSON. Version 3.0 walks the object with an explicit stack. One file replaced two, and the package has no dependencies left.
The test suite went from 28 tests to 50. The new ones include cases I would never have set up by hand: a proxy that forwards a Map or a Set, as Vue’s reactive() does; a cache that keeps its data in private Maps, as quick-lru does; objects from another realm; a browser with a Buffer polyfill installed as a global. The commit also records that the default import type-checks on TypeScript 2.9 to 5.9.
npm run bench in the repository compares 3.0.0 with 2.6.5, the last release of 2024. The README carries its output, unedited: Node.js v26.9.0, darwin-arm64, median of 3 runs.
| 2.6.5 | 3.0.0 | |
|---|---|---|
| 1M small records: first call | 409 ms | 218 ms |
| 1M small records: repeat call | 375 ms | 358 ms |
| 1M small records: extra memory | +393 MB | +119 MB |
| 100k records of 1 KB text and 50 numbers: first call | 303 ms | 42 ms |
| 100k records of 1 KB text and 50 numbers: extra memory | +543 MB | +16 MB |
It has a cost. Version 3.0 keeps its working memory on the V8 heap, so a process already close to its heap limit can run out of memory where 2.6.5 did not. The README says so.
For a relatively quick amount of work by a good model I got high-quality output. On this evidence the idea holds: you describe what you want, and the tool writes good code and tests it harder than you would.
So any package can be regenerated
If a model can rewrite this package overnight, nobody needs to install it. They can ask a model for the same function and have it in their own code in minutes. I think the same is true of much of npm. A package is now something you can vibe-code on request.
The regenerated copy works today. So does the package. Today they are equal.
What the copy does not have
The difference is time.
A package on npm has a past. It has a history of versions, a list of people who maintain it, and a record of what broke and how it was fixed. The Lindy effect is the rule of thumb that something which has lasted ten years will probably last ten more. A package that has been maintained for years will probably be maintained next year. A copy generated this morning has no past, and nothing to suggest a future.
This rewrite shows it. The code of 3.0.0 is a few days old. What it was built from is not. Its tests and its benchmark come from reports that users filed over three years: a string measured differently in Node.js and in a browser (#82, 2023), nesting too deep to measure (#91, 2023), a crash inside a web worker (#101, 2024), a cache whose measurement used too much memory (#102, 2025). A regenerated copy starts without any of those reports.
A history also shows the weak spots. This one shows a single maintainer and no release between July 2024 and this month. Anyone can read that before depending on the package. There is nothing to read about a tool that was generated this morning.
What the developer still decides
When you create software you cannot think only about now. You have to think a year ahead, or several. The code you write today will sit on top of other code, and that code has to be there, and working, when you come back to it.
So the skill changes. Development becomes building from Lego bricks, and the bricks have to be proven. The proof is their record: open-source projects that have been maintained for a long time and are likely to stay maintained.
Maintaining one is the same thing seen from the other side. The model wrote this release. These were still mine:
- Whether to ship a breaking change. Version 3.0 returns different sizes from 2.x, and anyone with thresholds built on the old numbers has to recalibrate them. That is why it is a major version.
- When to publish, and from which commit. I got this wrong once. I published 2.7.0 from a commit made before two type fixes, and the default import stopped compiling on TypeScript 2.9 and 3.0. 2.7.1 followed five minutes later.
- How to publish. By hand. Publishing needs my second factor, so no session can do it.
So what
Writing the code is no longer the scarce part. Choosing what to build on is, and the measure is time: how long a brick has existed, who looks after it, and whether it will still be looked after when you need it.