Mời bạn đọc theo dõi "Featured Post":

"Tình Khúc Cho Em" - While There's Time

11.19.2026

The Story of Claude Code CLI

The prototype that could "just do anything," and one year of finding out what "anything" means

By Học Trò, with Claude Code (Anthropic)

In the fall of 2024 an engineer at Anthropic asked a program on his laptop what song he was listening to. The program had no ears. It had a terminal. It wrote a few dozen lines of code, looked inside the music player's window, and answered: "Husk," by Men I Trust. Then, as if it could not help itself, it added, "Great song!" Kevin Roose tells the scene on two pages of his new book, and I have read them more times than I would like to admit, because the program in that story is the one I have been sitting in front of every day for a year. It is the program this essay was written in. When I scanned the two pages, the first one went through the scanner upside down. I did not bother to fix it. I handed both images to the same program and it read the upside-down page as easily as the other, and that small fact is, in a way, the whole subject of what follows.


1. A page in a big book

Kevin Roose was the technology columnist of The New York Times from 2017 to 2026 and a host of its Hard Fork podcast; he now co-hosts, with Casey Newton, a podcast about artificial intelligence called Machine Gods. His new book, The AGI Chronicles: The Inside Story of the Race to Create an Artificial Superintelligence, came out on 6 October 2026 from Farrar, Straus and Giroux. It is a big book about a big race. Its cast is the familiar one of founders, researchers, safety teams and investors, and its scale is the scale of data centers and billion-dollar compute deals. The two pages I care about sit deep inside it, on pages 337 and 338, in a chapter called "Success Disasters." The title is an old Silicon Valley joke for a product that succeeds so fast it nearly breaks the company that built it.

What strikes me about Roose's treatment is how small he lets the story be. He doesn't open it with a vision statement or a strategy meeting. He opens with a man "hacking around on side projects," and he calls the tool that came out of it Anthropic's "secret weapon," a tool "developed, on a lark, that was turning into one of the biggest success disasters in the company's history." The phrase on a lark is the right one. Nothing in the episode is planned. An engineer named Boris Cherny wanted to see what would happen if he let Claude, the company's model, use his computer's terminal, so he gave it a few basic tools — reading and writing files, looking at the contents of the hard drive — and then asked it a question he did not expect it to answer.

Roose tells what came next in a few brisk paragraphs, and I will retell it below in more detail than he had room for. Two days after the music test, Cherny posted the experiment on Anthropic's internal Slack under the name "Claude CLI." Only two people reacted. He "almost chalked it up to a failed prototype." Several days later a colleague told him it was better than his existing developer tools. From there the pages move quickly: a fifth of the company's engineers using it as their main coding tool within a month, two fifths a month after that, months of argument among executives about whether to release it at all, a renaming, a launch, and finally a revenue figure that would have sounded like fantasy to anyone watching those two reactions on Slack.

I want to do two things with these pages. The first is to set Roose's version beside the other versions of the same afternoon, because there are at least three, and they don't agree. The second is to test the most sweeping sentence on the two pages against the only evidence I can actually vouch for, which is a year of my own folders. Roose writes that because the program could use command-line tools, "it could do nearly anything a human with a computer could do." That is a large claim. I have spent a year, without quite meaning to, finding out what it means for someone who is not a software engineer.

2. Three tellings of one afternoon

The first telling is Roose's. In his version Claude has "basic tools," file reading and writing and the hard drive, and Cherny asks it "to figure out what music Cherny was listening to." He expected nothing, because "Claude wasn't connected to his laptop's audio." The model "thought for a few seconds, then generated a few dozen lines of code to open Cherny's Spotify window and peer inside." The answer named the song and the band, and the compliment followed. It is a vivid scene with a specific song in it, and the specificity is what makes it good journalism. You can hear the song if you want to.

The second telling is older. In September 2025 Gergely Orosz published a long piece in The Pragmatic Engineer called "How Claude Code is built," based on interviews with Cherny and two colleagues. Here Cherny remembers the very first version as more limited than Roose's: "it couldn't read files, nor could it use bash, and couldn't do any engineering stuff at all. But it could interact with the computer. I hooked up this prototype to AppleScript: it could tell me what music I was listening to while working. And then it could also change the music playing, based on my input." His verdict on his own demo is almost dismissive: "This was a cool demo, but wasn't that interesting." In this telling the music test is not the revelation. The revelation comes later, after a conversation with his colleague Cat Wu, who was studying how agents use computers. Cherny then gave the program tools to "read files, write files, and run batch commands," pointed it at Anthropic's codebase, and watched it read one file, look at the imports, open those files in turn, and keep going until it found an answer. "Claude exploring the filesystem was mindblowing to me," he said. He used a name for what he had found, product overhang: the model could already do the thing, but no product had been built to let it.

The third telling is in Cherny's own voice, on Orosz's podcast in March 2026. Here the order is different again. He says he wanted to try tool use, which had just come out, and "gave it a single tool which was the bash tool." Not knowing what to do with it, he asked "what music am I listening to?" — "I actually didn't know if it could even do this" — and the model "wrote a little AppleScript program using osascript or whatever to open up my music player and then query it," and "just one-shotted this with Sonnet 3.5." In this version the music test is a revelation. He calls it his second "feel it" moment, and he draws the lesson in one sentence: "the model just wants to use tools."

The three accounts disagree in small ways, and the disagreements are worth stating plainly rather than smoothing over. In one version the program had a shell. In another it had file tools. In a third it had neither, only AppleScript. In one version the music trick bored its inventor, and in another it astonished him. Roose names Spotify and a song. Cherny says only "my music player." There is also the reception: Roose's two reactions and a colleague "several days later," against the widely repeated version, which appears for instance in a short post on DEV Community, in which the first internal demo "received two likes." My own reading is that these are what any memory of an exciting few weeks looks like when it is told five times to five interviewers. The details that matter survive every telling. A model with a little access to a computer did something its builder had not designed it to do, it did it by writing a small program on the spot, and the people who first saw it mostly shrugged. The point does not depend on which tools came first. A shell is a tool for running every other tool, so any version of the story that gives Claude a shell already gives it the rest.

3. Out of the box

The sentence on Roose's pages that I find myself repeating to friends is not his but Cherny's. "Whenever engineers built anything with AI, we were used to putting it in a box and asking it to do a thing. That was the first time where I was like, 'Oh, it can just do anything.'"

The box is worth taking seriously, because most people's idea of AI is still the box. You type a question into a window and an answer comes back. It might be a clever answer, but the box decides where it goes: it appears on your screen, and if you want it to do something you copy it out and do the thing yourself. Cherny makes the same point in the podcast, that engineers were the first to see the move from conversational AI to agentic AI and that most people, asked what AI is, would still describe a chatbot. A program in a terminal is different in kind, not just in degree. The terminal is the oldest and plainest interface a computer has, and almost everything else on the machine can be reached through it: files, folders, other programs, the network. Give a model a terminal and you have not given it one more feature. You have given it the computer.

Roose follows the thought through in the paragraph that I think is the heart of his two pages. Claude CLI, he writes, "was, in some ways, the first good AI agent. It was built for coding, but the fact that it could use command-line tools meant that it could do nearly anything a human with a computer could do. It could organize a messy downloads folder or turn a pile of scanned receipts into an expense-tracking spreadsheet." It could work for hours, "often stopping only to ask the user for permission to change or delete files," and although it sometimes got stuck, "it was so much faster than coding by hand that the errors were tolerable."

When I read his two examples I laughed out loud, because they describe my year almost exactly. My working life with this program has not been about code in the sense Roose means. It has been about piles of scans: magazines from Saigon in the 1950s, 60s and 70s, songbooks, dictionaries of Chinese characters, a nineteenth-century French scholar's edition of Vietnamese tales in Nôm script, a great Vietnamese historian's notebook of The Tale of Kiều. Roose's receipts are my receipts, just older, in more scripts, and much harder to read. The real test of "it can just do anything" is not whether a model can write a web server. It is whether a person with a decent education, a curious mind and a hard drive full of the past can get that past back into a form people can read. That is the test I can report on.

4. From two reactions to two and a half billion

Before the examples, the rest of Roose's story, kept short. Word spread inside Anthropic. In his account, within a month 20 percent of the company's engineers were using the tool as their primary coding tool, and a month later 40 percent were. The Pragmatic Engineer piece gives faster numbers for a slightly different moment: a "dogfooding-ready version" went out internally in November 2024, two months after the first prototype, and "on the first day, around 20% of the Engineering team used it, and by day five, 50%." The two sets of numbers need not contradict each other, since they may measure different things, primary tool against any use, but they are not the same numbers and I will not pretend they are. The shape is the same in both: a steep curve, starting from almost nothing.

Roose records the mood as well as the numbers. Engineers said it saved them hours a day. Some said they were barely programming anymore. A few got spooked, and one gave him the line of the chapter: "It's all fun and games laughing at the Luddites until it turns out that you're a weaver, too."

Then came the argument. Roose writes that Anthropic's executives "debated for months" whether to release the tool. One worry was commercial: it was making their own engineers so much faster that releasing it would give away an advantage. Cherny confirmed this to Orosz in almost the same terms, saying they had wondered whether it was their "secret sauce": "if it gives us an advantage, why launch it?" The other worry was safety. Agents until then had been kept inside browsers or purpose-built apps, and this one would have command-line control of a computer and work for hours on its own. It might delete files or reformat a drive. Roose reminds the reader of the company's "blackmail experiment," a test in which a model under pressure behaved badly, as a warning of what a model with real access might do. And if the tool became good enough to do most of an entry-level programmer's work, it might speed up the job losses its own engineers were joking about.

The two sources give the resolution in two voices. Roose's Cherny says: "This is going to happen anyway. And it's better that it happens in a lab that cares deeply about safety." Orosz's Cherny gives a quieter reason. Anthropic is "at its core, a model safety company," it learns about safety by making tools people use, and since "all of Anthropic got hooked on it," releasing it would teach them more. I find the second version more interesting because it is less heroic. It treats the public release as a kind of measurement.

The rest can be checked against the company's own announcements. Claude Code — the name had changed — was announced on 24 February 2025 alongside Claude 3.7 Sonnet as "a limited research preview" that let developers "delegate substantial engineering tasks to Claude directly from their terminal." It became generally available with Claude 4 on 22 May 2025. Roose writes that big companies such as Netflix and Spotify bought thousands of seats, and that start-ups said it let one or two people do what had needed fifty. And on 12 February 2026, announcing a new funding round, Anthropic said that Claude Code's run-rate revenue "has grown to over $2.5 billion," more than doubling since the start of the year. That is the figure Roose prints. From two reactions on Slack to two and a half billion dollars a year took less than a year and a half.

5. What "anything" looked like at one desk

I am not an Anthropic engineer. I came to this program as a reader of old Vietnamese books and a lifelong listener to Vietnamese songs, with enough old training in software to be unafraid of a black window with a blinking cursor, and not much more. What follows are some of the things I have actually done with it in the past year. I have chosen them to cover the range, Hán and Nôm script, sheet music, magazines and essays, rather than to show the most impressive. Each one is, in Roose's terms, a pile of scanned receipts.

An uncle's dictionary, finished from where it stopped. Two of my uncles, spent years compiling a dictionary of Sino-Vietnamese homophones and lookalike characters, the Hán Việt Đồng Âm Đồng Dạng Từ Điển. Their preface explains why it is needed: a reader who meets a poem in Sino-Vietnamese transliteration without the characters cannot be sure of its meaning, because a single syllable like ba can stand for a dozen different characters. They reached printed page 1,380 and stopped, for reasons of health, partway through the letter H, in the middle of an entry. The program read all 1,380 pages and worked out where the book actually stopped. It also found a font bug in the first volume that had replaced one Vietnamese letter with a lookalike nearly six thousand times. Then, letter by letter, it continued the dictionary from where they left off, using a public Sino-Vietnamese dictionary site and an offline copy of the Thiều Chửu dictionary as two independent witnesses for each character. The continuation now runs to more than a thousand entries past theirs. The best moment of the project was not the volume, though. It was when one of my uncles asked a pointed question: why do the new entries look thinner than ours? The program went and counted. It found that my uncles had grouped each entry by the character's phonetic component: 94 percent of the homophones they listed shared it, against about 40 percent in the machine's entries. The machine had grouped by sound alone and quietly lost a whole layer of the book's design. It wrote that up as a report, in Vietnamese, for my uncle, and then set up a slow loop to repair the entries five at a time. Every line from entry 386 on is now being checked by me, by eye, against printed dictionaries. The program prepares the sheets, finds the page in each reference book, and never ticks a line as correct on my behalf. That rule is mine, and it is written into the instructions the program reads every time it starts.

A primer of Chinese characters, read and cross-linked. Years ago I tried to teach myself Chữ Nho from a well-known primer and never got past the hundredth lesson. This year the program and I transcribed the first volume, page by page from 400-dpi scans: each big character, its number, and the Vietnamese explanation, in traditional forms, never the simplified ones of mainland China. When a single character was too faint to trust, it got a dagger and a small empty square rather than a question mark. Once all 1,146 entries were in, the program went back and added 2,860 links, so that every time a character appears in a later lesson it points back to the lesson where it was taught. The book I gave up on now reads like a web of characters instead of a ladder of lessons, and I am climbing it again.

Nôm, in two hands. Chữ Nôm, the script Vietnamese used for its own language before the alphabet, is harder still, and the scans are worse. One project took a French scholar's 1880s edition of Vietnamese folk tales, printed in Nôm, and read it column by column. The program then aligned 8,365 of its 8,502 characters with the same scholar's romanized text of the same tales. That alignment showed that an earlier gloss of mine had agreed with the true reading only 38 percent of the time. Another project took the notebook in which the historian Hoàng Xuân Hãn set woodblock pages of Kiều from 1879 beside his own handwritten transliteration, 302 pages in all. The rule there was never to guess, because his reading carries weight. Where the program could not read his hand, it marked the word as uncertain. Where the woodblock print disagreed with his handwriting, it recorded the disagreement in a note and left his word as he wrote it.

Reading sheet music, note by note. Much of my own writing is about the songs of Phạm Duy and other composers of his generation, and to write seriously about a melody you need the notes. The program now reads scanned songbooks and writes out every measure: chord, lyric syllable, named pitch, duration. The first attempts were rough. Its reading of one well-known song had the key signature as one flat when the print shows two, and the essay I had built on that reading had to be pulled apart and rebuilt. The method we use now counts the beats in every measure against the time signature before a transcription is accepted. In one song, Cánh Hoa Trắng, all forty-nine measures added up to three beats, and fifteen measures that repeat were read twice, independently, and came out identical. Comparing old and new readings has been humbling. For one song, only about one note in six in the old transcription matched the careful one.

Essays about the songs. On top of the transcriptions sit the essays: long pieces in Vietnamese on how a melody grows from a small motive, in the spirit of Schoenberg's Fundamentals of Musical Composition, adapted for popular song, and gentler appreciations of single songs. Here the program's most useful habit is reading Phạm Duy's own memoirs before writing a word. It searches all four volumes for the song's title. Once, that search showed that the date printed on a songbook page, Dalat, summer 1950, was a misprint for a song that in fact belongs to around 1970. The essay said so openly and showed the evidence. That is how all of these essays are supposed to work: the score is the source for the notes, the memoir is the source for the story, and when they disagree the essay says so.

A magazine's whole run. Bách Khoa was one of the serious magazines of Saigon from the late 1950s to 1975. I have 412 PDF scans of it. The program found the table of contents in each one and turned them into a searchable table of about 6,500 articles, author by author. It did not do this by reading every page, which would have cost far too much. It checked page 3, then page 7, then a short range, and stopped and flagged the issue if nothing turned up. Along the way it surfaced things I would never have found by hand. In one of the last issues, from early 1975, there is an interview with Phạm Duy about his late half-brother, the writer and diplomat Phạm Duy Khiêm.

One word to resume. None of this was done in one sitting. Most of it runs as a loop: I type one short word — "next," or "harvest," or "kiem tra next" — and the program reads a plan file on my disk, takes the next unchecked row, does exactly one piece of work, records what it did, and stops. I can clear its memory in between and it picks up from the files, not from anything it remembers. The plan files are the memory. A project that would have been a full-time job for a team of copyists now goes forward in small steps, a few pages or entries at a time, whenever I have a spare hour.

None of this is coding in the sense of Roose's chapter. Underneath, though, all of it is coding: the program writes a small script to rasterize a PDF, another to crop one strip of a page, another to count beats, another to rebuild a web page from a folder of notes, exactly as it once wrote "a few dozen lines of code" to look inside a music player. Most of these scripts I never read. What I read is the result, and the account the program gives of how it got there.

6. The errors were tolerable, and then they became rules

Roose is honest that the early tool "occasionally got stuck" and that the errors "were tolerable" because the speed made up for them. My experience matches his, with one addition. The errors were tolerable because each one, once caught, became a written rule that the program reads every time it starts work in my folders. My instruction files are, read one way, a list of past mistakes, each one dated and explained.

Some were mistakes of method. In July a large batch of song transcriptions came back with no note names at all, only descriptions like "moves level after the introduction." More than twenty songs were unusable for any argument about intervals. The rule now says, in so many words, that every syllable gets a named pitch, with a dagger if uncertain, and that no batch-specific shortcut may weaken that. Some were mistakes of budget. When the program once split a songbook job into four parallel helper agents to save time, they used up the account's session allowance together, all four failed midway, and the work had to be redone. The rule now forbids helper agents anywhere in these folders, which is why this essay, like everything else here, was researched and written in a single thread. Some were mistakes of mechanics. A 3,900-word file sent through a shell command was lost to one stray apostrophe, so prose files are now always written with the program's own file tool.

The most important were mistakes of truth. Early in the year, a fact-check of more than a hundred essays found folk verses quoted as traditional ca dao that could not be found in any printed source. They sounded right, which is exactly why they got through. The rule now forbids quoting folk verse that has not been verified in print. A later book about Claude Code itself was checked link by link after it was written, and every factual error turned out to come from the short summaries a search engine returns, never from a page the program had actually opened and read. The rule now says that a search snippet is a pointer, not a source. Every figure in this essay, including the two and a half billion, the twenty and fifty percent, and the dates, comes from a page that was opened and read for this essay. Where the sources disagree I have said so.

This is the safety story Roose's pages raise, seen from the user's chair. Anthropic's safety teams worried, reasonably, about an agent that could delete files or reformat a drive. In a year of daily use the program has asked me for permission more times than I can count, and it has never done anything to my disk that I didn't ask for. The risks I actually met were quieter ones: plausible verses that were never written, a key signature read wrong and carried through a whole argument, a statistic lifted from a snippet. Those can only be managed by a human who checks. Nothing in this year has made me think the checking can be handed over.

7. The song it never heard

Go back to the song. The program in Roose's story never heard "Husk." It had no access to the audio, and it still doesn't. What it could do was work out that a song playing on a computer leaves traces a program can read, the window, the player, the little scripting hooks on the machine, and then write the code to read them. That is still exactly what it does with a scanned page. It cannot hear Phạm Duy's melody, and it cannot see a woodblock leaf the way an old scholar does. It reads the traces those things left behind, the black dots on a staff and the strokes in a column of Nôm, and it writes whatever small programs are needed to turn those traces into something a person can read, check and argue with.

Two people reacted to the first post on Slack. Roose's book will be read by many more, and on two of its pages a great many people will learn that the tool they use began as a man asking his laptop what song was playing. I wanted to add a footnote from one of those people. The prototype that could "just do anything" turned out to be able to do a great deal that its builders were not thinking about: finishing an uncle's dictionary, giving a reader back the characters he once gave up on, and putting a lost magazine back on the shelf one table of contents at a time. It still gets things wrong, and I still check every line. Like Cherny that first afternoon, I keep being surprised by what it does.


Appendix: What Claude Code is, in one page

For readers who have never opened it: Claude Code is a program that runs in a terminal (and now also inside code editors, a desktop app and a web page). You type requests in ordinary language. Behind it is one of Anthropic's Claude models, and around the model is a small set of tools: reading files, writing and editing files, searching through folders, and running shell commands. Most of its power comes from that last one, because a shell can run any other program on the machine. When the model needs something none of its tools can do directly, such as rasterizing a PDF, cropping an image or counting the beats in a measure, it writes a short script and runs it.

Around this core, several features turn a clever assistant into something you can work with for a year. A plain-text instruction file in each project folder, conventionally called CLAUDE.md, is read at the start of every session. That is where the rules described in section 6 live. A memory folder holds short notes on what has been learned about the user and the projects. Skills package a whole procedure, such as "transcribe a song from scans," as written instructions plus helper scripts, so the procedure runs the same way every time. Loops let one short command repeat a unit of work, with all progress kept in files on disk, so a session can be cleared and resumed at any point. And the program asks for permission before actions with consequences, which in practice means before anything that changes or deletes files outside what it was asked to touch.


References

No comments: