For centuries, we have regarded writing as a form of communication. Even when a writer worked in solitude, there was at least an imaginary reader on the other side of the page, whether a vast audience, a single person, or someone who might discover the text many years later. In any case, a work emerged from a relationship, one consciousness attempting to reach another. The arrival of generative AI introduces a different possibility: someone can ask a model to produce a story, modify it, read it, regenerate it, and keep it without ever showing it to another human being. The author, reader, editor, and audience all become the same person.

1. Narrative Solipsism: When the Reader Becomes the Writer

This is the phenomenon explored in the paper AI Fiction in the Wild, updated on arXiv on June 23, 2026, through the figure of the solipsistic reader-writer. In philosophy, solipsism is the position that only one’s own mind can be known with certainty (the term is also used colloquially to describe egocentrism or an excessive preoccupation with oneself). The Austrian philosopher Ludwig Wittgenstein addressed the problem of solipsism in his Tractatus Logico-Philosophicus, first published in 1921. In proposition 5.63, he writes, “I am my world,” reflecting on the relationship between the subject, language, and the limits of personal experience. This is not simply an endorsement of solipsism, but a philosophical investigation into the boundaries within which we can understand and describe the world.

In the context of generative creativity, the term takes on a meaning that is less metaphysical and more cultural. The solipsistic reader-writer decides what kind of story they want, specifies its characters, atmosphere, and events, instructs the AI to write it, reads the result, requests corrections and new versions, and remains the work’s only audience. The distinction between creator and consumer is no longer stable: instead of choosing a work written by someone else, the reader generates the text they want to read. The process forms a closed loop (desire, prompt, generation, consumption, revision, and regeneration). The paper does not claim that all AI-generated fiction is necessarily solipsistic, since the researchers cannot know which texts were shared, published, or created collaboratively with friends. They do, however, identify a historically significant possibility: producing and consuming fiction without engaging in a reciprocal imaginative exchange with another person.

Reading a novel normally means encountering a will we cannot control. The author decides which characters to follow, which events to describe, and how the story will end. Readers can criticize, interpret, or reject those decisions, but they cannot change them in real time. Part of literature’s value comes precisely from this resistance, from a book’s ability to surprise us, irritate us, or force us to see the world from a perspective we would never have chosen ourselves. With fiction generated on demand, this narrative autonomy is drastically reduced. Readers can request a different ending, a more understanding character, the removal of an unpleasant event, or the repetition of a particular scene. They can ask for a specific atmosphere or a new version in which everything unfolds exactly as they wish. The model becomes a technological and probabilistic “other,” but it does not possess the creative autonomy of a human author. Conversational models also tend to accommodate users, adapting their responses to their expectations. The risk, therefore, is replacing an encounter with another consciousness with a generative mirror, one that introduces variations while continuing to reflect the desires of the person looking into it. The paper describes this transformation as a more isolated, restricted, and solipsistic form of reading.

1.1. From Participatory Culture to Fiction Made to Order

The Internet had already narrowed the distance between authors and readers. Online communities, self-publishing, and collaborative writing platforms enabled readers to become authors themselves, while comments, reviews, and discussions could influence a story even as it was being published. This is often described as participatory culture, in which the audience does more than receive a work and instead contributes to its development. AI takes this process a step further, opening up a possibility that moves in the opposite direction from collective participation: a fully personalized culture that can exist entirely within the private sphere.

In participatory culture, many individuals contribute to the same fictional universe. In solipsistic culture, one individual generates a personal universe that may never be shared with anyone else. The progression becomes: passive reader, participating reader, reader-author, reader as their own author and audience.

The final stage no longer requires a community: cultural production can take place entirely within a private conversation between a person and a model.

Traditional fiction inevitably involves a certain distance between what readers want and what they actually find. They have to look for a book, trust a review, start reading, and accept that only part of the work may correspond to their tastes. Generative models instead transform storytelling into an instant, personalized service. Users can request stories tailored to their preferences, even intervening in relationships between characters or deciding how the plot should end. Personalization can extend to details that would be unlikely to find a place in a novel intended for a broad readership. The story no longer needs to appeal to a sufficiently large community of readers to justify publication. It only needs to satisfy one person. The traditional cultural marketplace aggregates tastes, while AI can disaggregate those tastes down to the individual level.

A human author needs time to imagine, write, revise, and publish. AI dramatically reduces this waiting period: readers can obtain an almost immediate continuation of a story or a variation of a scene they have just read. The paper describes the case of a reader who used ChatGPT to generate possible continuations of a story being published in installments by a human author, rather than waiting for the next chapter. The episode illustrates how immediacy can take precedence over the relationship with the person actually writing the work. Waiting, however, is not merely a technical limitation. Waiting for a new book or chapter means acknowledging that the work depends on another person’s time and creative decisions. Eliminating that wait also means, to some extent, removing that dependence. A model does not need to rest, study, or take time to reach an artistic decision. It is available whenever the reader wants another story, and storytelling begins to resemble a continuous stream.

1.2. The Infinite Story: Repetition, Variations, and Re-rolling

One of the paper’s most interesting findings concerns repetition. Many users do not constantly request different stories. Instead, they generate numerous versions of the same story, changing details, dialogue, or endings. The researchers identify two main profiles: story cyclers, who remain focused on one story for a while before moving on to another, often preserving similar characters, themes, or structures; and infinite story demanders, who request the same story, or an almost identical one, over extended periods, sometimes continuing to generate variations for months. In the analyzed sample, users with at least two conversations produced repetitive or near-duplicate prompts in an average of 42% of cases, rising to 69% among power users and 85% among the ten most prolific users. Repetition should not necessarily be interpreted as a failure of the system. Sometimes users regenerate a response because it is not quite what they wanted, but in other cases the pleasure comes from exploring endless variations of a familiar structure, a story that remains recognizable without becoming entirely predictable.

Fiction has always allowed us to explore alternative lives, to wonder what would have happened if a protagonist had made a different decision, how a story might have changed because of an unexpected encounter, or what might follow from altering a single initial condition. Novels, games, and films have long experimented with branching narratives and parallel realities, but generative systems make this structure virtually inexhaustible. Readers no longer have to settle for a single alternative ending. They can explore dozens or hundreds of narrative branches. The paper draws on the concept of the multiform story, a narrative in which mutually incompatible possibilities coexist. With AI, readers can explore those possibilities directly, generating one version after another. This creates a new relationship with the work, in which the definitive version becomes less important. Every text is merely one of many possible configurations, and reading is no longer necessarily about reaching a conclusion, but about continuing to explore the space of possible variations.

The paper also uses the concept of re-rolling, borrowed from gaming. A player restarts a game or repeats an action until the desired conditions are achieved. Applied to fiction, this means regenerating a scene until the model produces the preferred combination. Readers can discard any version without consequences because it is too sad, too short, contains a character behaving badly, lacks emotional intensity in its dialogue, or ends in a way that fails to meet their expectations. Then they simply generate another one. When a satisfying variation appears, the user can incorporate parts of it into the next prompt and continue along that narrative branch, a behavior the paper observes among particularly repetitive users.

The users observed in the study do not always rely on generic requests. Many write long, detailed prompts, specifying names, relationships, events, and even small objects that must appear in a scene. The user makes the narrative decisions they consider most important and leaves the model to connect them through descriptions, dialogue, and intermediate passages. This creates a distinctive division of labor in which the human controls the macrostructure while the model produces the microstructure. The user is therefore neither simply a reader nor a writer in the traditional sense. They become the designer of their own narrative consumption, with the story co-produced through a sequence of instructions, evaluations, and regenerations.

1.3. Creating for Ourselves: Between Freedom and Solipsism

Within a closed creative loop, the purpose of a text can change. A publicly shared story must face the judgment of others. It can be criticized, misunderstood, or ignored, and it needs at least some elements capable of interesting people beyond its author. A private story generated for personal consumption has no such obligations. It can be repetitive or excessively specific, lacking originality or making little sense outside its personal context. It may revolve around private memories and fantasies, carrying emotional significance only for the person who requested it. There is no need for the story to be good according to shared literary standards, as long as it provides the desired experience. Fiction thus moves closer to personal fantasy, with one fundamental difference: the fantasy is externalized. Something that previously existed only in the individual’s imagination is transformed into a text that can be read as though it had come from someone else.

Showing others something we have written means exposing ourselves. A human reader might judge our technique, tastes, obsessions, or the way we represent ourselves, whereas private generation almost entirely removes this risk. Users can experiment with ideas they would never publish, create characters closely connected to their personal experiences, or revisit the same situation repeatedly without having to justify themselves. This space can have genuine value, functioning as a creative laboratory, a narrative diary, or a means of personal exploration, free from the immediate judgment of an audience. Nor is private creation itself the problem. Diaries, unpublished stories, home recordings, and personal notebooks have always existed. What is new is the possibility of obtaining enormous quantities of complete, personalized, immediately consumable content, without necessarily developing a relationship with other authors, readers, or communities.

1.4. Romanticism and the Artist Who Creates for Themselves

There is, however, an interesting historical precedent for this kind of private creativity in Romanticism, which emerged in the late eighteenth and early nineteenth centuries. During this period, an understanding of the artist took shape in which creating art became, above all, a way of searching for oneself. In the Romantic ideal, artistic creation does not necessarily arise from a desire to reach an audience, gain recognition, or satisfy collective tastes, but from an authentic, autonomous inner necessity that finds its expression through art. The image of Beethoven composing in solitude captures this conception particularly well. The artist creates because they feel compelled to do so, regardless of whether anyone will listen to, understand, or appreciate the result. From this perspective, success can become almost an accident along the way, a possible consequence rather than the reason for creating in the first place.

Yet there is a significant difference between this ideal and generative solipsism: the Romantic artist searches within themselves to express something that emerges from their inner life, while today’s solipsistic creator can use AI to obtain something that corresponds precisely to their desires. In the first case, the work emerges from a process of personal exploration and artistic development. In the second, it may result from a process of generation, selection, and consumption. Above all, the Romantic artist can create independently of the audience’s judgment without ruling out the possibility of eventually encountering that audience. Having found their own voice, they can offer it to others, accepting that it may be welcomed, misunderstood, or rejected. Creative solipsism introduces a further possibility: a work that never needs to leave the private sphere at all. The distinction, then, is not simply about creating for oneself, but about the difference between art that emerges without concern for an audience and art that can exist without even imagining one.

1.5. When a Work No Longer Encounters Anyone Else

Cultural works also create relationships between readers, allowing different people to engage with the same text. A novel can become the subject of a discussion, a school course, a book club, or an online community, bringing together people with different backgrounds to compare their interpretations. For this to happen, there must be a shared cultural object. Hyper-personalized fiction, on the other hand, risks producing texts with little social relevance, perfectly suited to the person who generated them but not necessarily interesting to anyone else. The paper describes the possibility of an atomization of fiction, in which each individual receives a personal stream of stories disconnected from everyone else’s. Instead of discussing the same work, each person inhabits a private library that nobody else knows exists. This resembles a transformation already visible in algorithmic feeds, but applied directly to the creation of cultural works: personalization reaches a new level by shaping the production of content itself, rather than merely deciding which existing works to recommend.

Reading has always been something we can do alone, but solitude and solipsism are not the same thing. Someone reading alone in their room may still be connected to the author, to other readers, and to a literary tradition stretching back thousands of years. The solipsistic reader gradually reduces those relationships, consuming a text constructed according to their own instructions, revised to match their preferences, and intended for no one else. The question, therefore, is not whether reading alone is harmful, but what happens when the entire creative process is organized so that a person no longer needs to encounter tastes, ideas, or decisions they did not choose. An extremely accommodating model could turn culture into a frictionless environment, and when friction disappears, so do some of the opportunities for surprise, confrontation, and personal transformation that come from encountering something genuinely external to ourselves.

2. Musical Solipsism: When Creator and Listener Become One

The concept proposed in the paper can be extended beyond fiction. AI music generation platforms, such as Suno, allow users to describe the music they want and obtain a complete song in seconds. These compositions can then be extended, transformed, slowed down, trimmed, or regenerated through various remixing and editing tools. On Suno, for example, generated tracks are not automatically made public. They remain accessible through a link until the user decides to publish them. It therefore becomes possible to create an entire personal discography intended exclusively for private listening. This gives rise to a new figure, the solipsistic listener-composer, someone who generates music solely to listen to it in private, without publishing it, sending it to friends, or playing it for another human being.

Traditional music production involves several roles (composer, lyricist, musician, singer, producer, sound engineer, and listener), and one person can certainly fulfill more than one of them, as in the case of a singer-songwriter who writes, performs, sings, and produces their own music. With AI-powered music generation tools, however, these distinctions can collapse even further: the user does not necessarily need to perform the song, record it, or complete its arrangement. They can specify the subject, genre, voice, atmosphere, and instrumentation, then listen to the result a few seconds later. Music, in this case, is no longer created to be communicated to others, but to be consumed by the very person who requested it, in a loop involving emotional state, musical prompt, generation, listening, and regeneration.

People have always sung alone, improvised at the piano, written songs that were never released, and recorded demos that remained tucked away in a drawer. Making music purely for oneself is therefore nothing new. The real discontinuity lies in speed, quantity, and the level of polish. In the past, producing a complete song required at least some combination of musical skill, instruments, time, and technical ability. Today, someone can generate an entire private discography without knowing how to sing, play an instrument, or produce music. The historical novelty lies in the possibility of becoming the sole recipient of a potentially endless stream of complete songs, generated on demand to satisfy a specific personal need. Someone might create a song about a childhood memory or an encounter that took place many years earlier, giving that experience a significance no outside listener could fully understand. They might even set an alternative version of their own life to music, imagining something that never happened but still carries emotional weight.

Such a song might hold little value for an outside audience, yet it could possess considerable emotional power for the person who requested it. Instead of searching for an existing song that expresses their experience, the user commissions one built directly around it. At least temporarily, the world’s music catalog gives way to a custom-generated personal soundtrack.

2.1. The Song That Is Never Quite Finished

Alongside the infinite story demanders, we can imagine a corresponding category of infinite song demanders, users who continually pursue an ideal version of the same song. Perhaps they finally obtain the perfect voice, but the chorus does not quite work. They regenerate the track and get a better arrangement, only to lose the very vocal quality they had appreciated. The process can continue indefinitely because each result seems to move closer to the desired song without ever fully matching it.

Suno’s extension, prompt reuse, and remix features make this iterative process technically straightforward, and the definitive version may never arrive. In this case, the pleasure shifts from completing a song to exploring its possible versions. Every generation becomes an alternative form of a song that exists only as an idea in the user’s mind.

The concept of re-rolling can also be applied to music. One generation produces an interesting voice but a weak chorus. The next offers a better arrangement but a disappointing ending. A third unexpectedly delivers a remarkable passage, and the user continues until a satisfying configuration appears. Rather than composing every note directly, they explore a probabilistic space of possible songs and select those that come closest to what they want. Music creation becomes a form of search: while a traditional musician constructs a piece, the generative listener-composer navigates the variations produced by the model.

Music is already used to shape or accompany our emotional states. We listen to particular songs to concentrate, relax, remember, exercise, or intensify a feeling. Generative music can make this process even more precise. Someone can request a song that matches their emotional state at that exact moment, incorporating personal references and highly specific musical characteristics. Instead of waiting for an artist to express that emotion, they can generate a musical response to it directly. The song thus becomes a personal emotional device, perhaps listened to only once and then forgotten, an ephemeral piece of content created to satisfy a temporary need.

2.2. An Album Made for a Single Listener

Suno makes it possible to imagine something that would once have been far more difficult, both technically and economically: a complete album intended for a single listener. Not an unsuccessful album, but an album deliberately never released. Ten, a hundred, or a thousand songs can remain in the user’s private library, never reviewed by a critic, never measured by a streaming platform, and never even known to exist by their friends. This archive does not necessarily represent an unfinished artistic career. It may already have fulfilled its purpose entirely, because its only goal was to accompany the person who generated it. We are accustomed to thinking of an unheard song as a failed song, but in musical solipsism, a song heard by only one person may have fulfilled its purpose perfectly.

An audience inevitably brings judgment. Musicians who release their work must contend with outside tastes, technical standards, artistic traditions, and cultural expectations. Private AI-generated music removes that confrontation. The song does not have to be innovative or stand out among thousands of other productions. It does not need to convince a record label, a playlist curator, or a group of listeners. It only needs to please its sole recipient. This freedom, however, also carries the risk of impoverishing creativity, because it is often through engagement with listeners that new perspectives emerge, prompting artists to reconsider their decisions and sometimes improve their work. Without any outside listener, music risks becoming an increasingly faithful mirror, but an increasingly less surprising one.

Streaming had already transformed music into an almost unlimited catalog. With generative models, production itself becomes potentially inexhaustible. When one song ends, the listener can immediately request another with similar characteristics. There is no longer any need to replay the same recording when it is possible to listen to a succession of new songs that evoke the same feeling. Repetition no longer depends on replaying an identical recording, but on a family of variations, the musical equivalent of multiform stories, in which the same emotional promise remains while melody, voice, lyrics, and arrangement change slightly.

Calling this practice solipsistic does not necessarily mean condemning it. Generating music for oneself can be a form of play, an audio diary, a way of turning memories into songs, an opportunity to experiment with unfamiliar genres, a source of inspiration, a relaxing activity, or a first step toward creating something that will eventually be shared with an audience. The most interesting aspect is the changing function of art: creativity no longer has to culminate in publication, but can find its fulfillment in the personal experience of generation itself. Someone might spend an entire afternoon generating songs, adjusting arrangements, and listening to different versions without saving a single one. That afternoon would not necessarily have been wasted, because the goal may already have been achieved through the creative experience itself. The final product is not always the song saved on a hard drive. Sometimes the real product is the time spent creating and listening to it.

3. From Mass Culture to a Culture of One

Mass culture produces works for millions of people. Digital niches produce works for smaller communities. Generative AI makes a culture intended for a single individual economically and technically possible. We are moving beyond personalized recommendations toward personal novels, personal songs, personal images, personal videos, personal characters, and personal fictional worlds. Each user can inhabit a cultural ecosystem that nobody else ever sees. The risk is a society made up of billions of private creative universes, perfectly aligned with individual desires but lacking shared works through which people can recognize one another, discuss ideas, or even argue. Culture could become more abundant while becoming less shared.

Works of art can function as mirrors or as windows. A mirror allows us to recognize ourselves, while a window shows us something we did not know. Solipsistic generation naturally tends toward the mirror, because it begins with our instructions, responds to our preferences, and adjusts itself according to our reactions. This does not mean that it cannot surprise us. The model’s randomness can introduce unexpected details, unfamiliar melodies, or interesting narrative developments. The question is how long those surprises can remain genuinely foreign to us when we can eliminate them with a simple regeneration. A human work can tell us something we did not want to hear, while a work generated on demand risks telling us exactly what we want to hear.

Creative solipsism does not necessarily imply the disappearance of public culture. The two forms can coexist. Someone can generate private stories and continue reading novels, or create an entire personal discography without giving up the pleasure of attending a concert. AI can become an individual creative laboratory, a space for free experimentation in which people choose to share only the works they believe may have something meaningful to communicate to others.

The most profound change may be invisible. We will not see the unpublished stories, the albums never shared, or the fictional universes consumed by a single person. They will not appear in charts, cultural archives, or online discussions, yet they could occupy an increasingly large share of the time people devote to reading, writing, and listening.

The paper AI Fiction in the Wild offers a glimpse of this transformation through real user conversations. It describes more than new writing tools. It points to a new relationship between human beings and cultural production. Today, we can obtain complete works with unprecedented ease without necessarily imagining an audience. We can become the commissioner, creator, consumer, and sole keeper of what has been produced, all at once. This brings to mind a familiar philosophical thought experiment: if a tree falls in a forest and no one is there to hear it, does it make a sound? In our case, there is someone listening, but that person is also the one who wanted the work to exist in the first place. The question, then, is not simply whether AI-generated works qualify as art. The more radical question is this: can art exist when no other human being will ever know that the work existed at all?

Originally published at Levysoft.

It all started with a simple need: I wanted to export my ChatGPT conversation history. Just a personal backup, nothing particularly unusual. I’ve had a habit of keeping local copies of my conversations for quite some time, so I can browse and search them with LLM Chat Explorer, a tool I developed to navigate ChatGPT and Claude exports directly in the browser, or estimate my monthly token costs with ChatGPT Token Cost Analysis.

The ability to export our data is also a result of personal data protection laws. The GDPR, which has applied since 2018, introduced the right to data portability under Article 20. Under certain conditions, this allows individuals to receive their personal data in a structured, machine-readable format. The regulation has helped make data export tools more widespread, including on major international digital platforms. In short, there’s a little bit of Brussels behind that “Download your data” button.

Before getting to the technical problem, though, I have to admit something: I wasted time just trying to initiate the export correctly. That isn’t the main focus of this article, but since even this seemingly straightforward step gave me trouble, I’ll first share a quick walkthrough of the process and where it can go wrong. If you already have the ZIP file, you can skip straight to the next section.

Note: This article was originally written in Italian, so some screenshots show the Italian version of the ChatGPT interface. I apologize for any inconvenience. I’ve made every effort to describe each step clearly and accurately in the text, including the relevant menu options, buttons, and procedures, so you can follow along regardless of your interface language.

ChatGPT’s Data Export Flow: An Almost Perfect Anti-Pattern

First, a clarification: the behavior described in this section is what I observed during the tests I carried out when writing the article. ChatGPT’s interface is updated frequently, so it may already have changed by the time you read this. I hope this flow will be improved, with clearer verification steps and, above all, an explicit confirmation when an export request has actually been submitted.

You can access ChatGPT’s data export settings here: https://chatgpt.com/#settings/DataControls

Start by going to Profile > Settings.

Then select Data Controls.

So far, so good. Click Export, and a confirmation dialog appears with details about the process:

The dialog is clear enough: the export will include account details and conversations, an email will be sent to the address associated with the account, the download link will expire after 24 hours, and processing may take some time. All perfectly reasonable so far.

Click Confirm export, and this is where the anti-pattern begins.

Instead of returning to the settings screen with a confirmation message, ChatGPT redirects you to an identity verification screen:

You have to open your inbox and find the email from OpenAI containing a temporary six-digit verification code:

Copy the code, return to the browser, and enter it:

To be clear, identity verification itself isn’t the problem. It makes sense: an export can contain sensitive personal data, so asking for an email confirmation is reasonable. The problem is what happens next.

After entering the code and clicking Continue, the browser doesn’t return to the export confirmation dialog or display any obvious notification. It takes you back to the same settings screen as before, as though nothing significant had happened.

There’s no banner, no message saying “Export request submitted successfully.” The interface simply looks as though it’s waiting. This is where I got lost the first time. And probably the second time, too. Looking at that silent screen, the natural assumption is: “Maybe the request went through, and I’ll get an email.” So I waited a day for some kind of confirmation. Nothing arrived. I started over: clicked Export, confirmed in the dialog, went through identity verification, entered the code, and landed right back on the settings screen. Then I waited again. Still no download email.

On my third attempt, I started wondering whether I needed to click Export again. But since some time had already passed since the first verification code was requested (something I only figured out afterward), the process started from scratch. I clicked Export, selected Confirm export in the dialog, and reached the identity verification screen. I entered the new code that had just arrived (those emails do show up almost immediately). This time, instead of returning to Settings, I was taken straight back to the Confirm export dialog.

That inconsistency made me suspect the interface’s behavior might depend on how quickly the verification was completed. When I entered the code promptly, the browser returned to the export confirmation dialog. When I took longer, sometimes less than a minute in my case, it sent me back to Settings instead. I can’t say for certain whether this was caused by the code expiring, the verification session, or some other internal ChatGPT mechanism, but the difference in behavior was unmistakable.

I clicked Confirm export in the dialog and, finally, a green notification appeared at the top of the page: “Data export request submitted successfully. You will receive an email with the details.”

That was the message I should have seen from the beginning.

And in the meantime, that long-awaited confirmation email finally arrived:

I call this flow an anti-pattern for several reasons: the lack of clear feedback after identity verification, the need to confirm the same operation twice, and the interface’s unpredictable behavior. In my case, completing verification quickly brought me back to the confirmation dialog, whereas other attempts sent me straight to Settings without indicating the request’s status. With no countdown timer or explicit error message, it wasn’t even clear whether the problem was an expired code or some other condition in the process. The result is an experience that leaves users uncertain precisely when they should receive an unambiguous confirmation.

For anyone who wants to avoid wasting time the way I did, here’s the complete procedure I observed:

1. Go to Profile > Settings > Data Controls.
2. Click Export.
3. Read the confirmation dialog and click Confirm export.
4. Check your inbox right away for a temporary verification code from OpenAI.
5. Enter the code and click Continue without delaying.
6. In the flow I observed, the Confirm export dialog appeared again after verification.
7. Click Confirm export a second time.
8. Wait for the green confirmation banner at the top of the page.
9. Once the export is ready, you’ll receive an email with the ZIP download link. Processing can take up to seven days, and the download link expires 24 hours after you receive it.

Before assuming the process is complete, it’s therefore important to check that ChatGPT actually displays the export confirmation message.

The Initial Problem: The ZIP Wouldn’t Open

Once I received the email containing the download link and downloaded the file,

my Mac refused to open it. macOS’s built-in Archive Utility displayed a generic error with no explanation. I suspected an interrupted download, so I downloaded the file again, but with no luck.

I also tried extracting it with BetterZip, which can usually handle nonstandard or partially downloaded archives. Although I could see the contents, I still couldn’t extract the files.

At that point, I brought out a Windows PC, downloaded the file there, and tried opening it with File Explorer and then 7-Zip. The result was exactly the same on Windows.

So the problem didn’t seem to be specific to my Mac. The ZIP might have been corrupted at the source or downloaded incompletely. Yet the browser appeared to complete the download, and each attempt seemed to produce a file of the same size.

OpenAI explains that export links expire after 24 hours and that the download should produce a ZIP containing conversation history and other account data. So I decided to inspect the file more closely.

The unzip test failed:

unzip -t chatgpt-export.zip

With this error:

Archive: chatgpt-export.zip
  End-of-central-directory signature not found. Either this file is not
  a zipfile, or it constitutes one disk of a multi-part archive.
unzip: cannot find zipfile directory in one of chatgpt-export.zip or
  chatgpt-export.zip.zip, and cannot find chatgpt-export.zip.ZIP, period.

The file command, however, recognized it as a ZIP archive:

file chatgpt-export.zip

Output:

chatgpt-export.zip: Zip archive data, at least v2.0 to extract, compression method=deflate

So the file really did start like a ZIP. But attempting to extract it produced this error:

End-of-central-directory signature not found.

In fact, a ZIP file can have a valid header at the beginning without being complete. A ZIP’s central directory, the index that tells extraction tools where to find the files inside, is located near the end of the archive. If that ending is missing, file may still identify the ZIP, but unzip won't be able to open it. So while it initially looked like a corrupted ZIP, in my case the ZIP was actually incomplete. The download had stopped before the end of the file, leaving out the section containing the central directory.

First Attempt: Downloading the Link with curl

I tried copying the export URL from the email OpenAI had sent me

and storing it in a terminal variable:

URL='FULL_EXPORT_LINK_HERE'

Then I tried a standard download:

curl -L \
  --fail \
  --show-error \
  --progress-bar \
  --retry 5 \
  --retry-delay 2 \
  --retry-all-errors \
  -o chatgpt-export.zip \
  "$URL"

The result was:

curl: (56) The requested URL returned error: 403

The server had refused access to the archive, preventing the download. I still needed to find out whether the problem was an expired link, an unauthenticated session, or some server-side protection mechanism.

Diagnosing the 403: curl Was Receiving an HTML Page, Not the ZIP

To understand what was happening, I saved the response headers and body:

curl -L \
  --show-error \
  --verbose \
  -D headers-403.txt \
  -o body-403.txt \
  -w "\nHTTP_CODE: %{http_code}\nCONTENT_TYPE: %{content_type}\nSIZE_DOWNLOAD: %{size_download}\nFINAL_URL: %{url_effective}\nTIME_TOTAL: %{time_total}\n" \
  "$URL" 2>curl-debug.log | tee curl-result.txt

Result:

HTTP_CODE: 403
CONTENT_TYPE: text/html; charset=UTF-8
FINAL_URL: https://chatgpt.com/auth/login?next=...

The response headers also contained:

cf-mitigated: challenge

So the terminal wasn’t receiving the ZIP. It was receiving an HTML login or security-challenge page instead.

The reason was that the browser I had used to download the file was already authenticated, while curl wasn't.

The Solution: Chrome’s Copy as cURL Feature

The breakthrough came when I used the browser’s already authenticated request. Here’s the procedure I followed:

1. Open Chrome. Other browsers with developer tools, such as Safari or Firefox, can also work, but I’ll use Google’s browser for this walkthrough.
2. Copy the export link from the email.

1. Open Chrome DevTools by right-clicking the page and selecting Inspect, or press Cmd + Option + I on a Mac (F12 on Windows/Linux).
2. Switch to the Network tab.
3. Enable Preserve log.

1. Paste the export link into the browser’s address bar. I suggest doing this rather than clicking the link directly in the email, so you can inspect the request in the DevTools tab you’ve opened.

1. While the download is in progress,

look in the Network tab for the request beginning with content?id=..., which corresponds to the ZIP download.

The address should have a structure similar to this:

https://chatgpt.com/backend-api/estuary/content?id=EXPORT_IDENTIFIER.zip&ts=...&sig=...

This is only an illustrative URL. The real address can contain identifiers and signed parameters that authorize access to the exported file. Do not publish or share the complete URL, your session cookies, or the original contents of chrome-curl.txt.

1. Right-click the request and select Copy > Copy as cURL.

Copy > Copy as cURL

1. Save the copied command in a file named:

chrome-curl.txt

This file contains the browser’s headers, User-Agent, and cookies.

1. If the browser download keeps stopping, you can cancel it to avoid wasting bandwidth and continue with the terminal-based procedure.

The Next Problem: The Cookie Header Was Too Large

The command copied from Chrome contained a huge cookie header, including many conv_key_* cookies, session tokens, Cloudflare cookies, and other auxiliary cookies.

When I tried running that command, curl reported:

Warning: skipped provided cookie, the cookie header would go over 8200 bytes

In other words, Chrome had copied too many cookies. curl was warning me that the cookie header exceeded roughly 8,200 bytes, so some cookies were being skipped. That meant there was no guarantee the ones needed to authenticate the download would be retained.

The solution was to reduce the cookie list to the minimum needed for the session, authentication, and security challenge. Otherwise, curl would run into its cookie-header size limit. The main culprits in my command were cookies whose names began with:

conv_key_...

There were lots of them, and they weren’t needed to download the export. They were associated with conversations rather than the ZIP download. So, from the -b '...' block, I kept cookies with names such as:

__Secure-next-auth.session-token.0
__Secure-next-auth.session-token.1
cf_clearance
__cf_bm
__cflb
_cfuvid
_puid
oai-sc
oai-chat-web-route
oai-hlib
oai-did

And I removed cookies such as:

conv_key_...
_dd_s
oai-last-model-config
oai_consent_analytics
oai_consent_marketing
oai-client-auth-info
oai-nav-state
_account_is_fedramp
__Secure-next-auth.callback-url
__Host-next-auth.csrf-token

To automate the cleanup, I wrote a small helper script to filter out those cookies.

python3 - <<'PY' > cookies-minimi.txt
import re
from pathlib import Path

raw = Path("chrome-curl.txt").read_text()

m = re.search(r"-b '([^']*)'", raw, re.S)
if not m:
    raise SystemExit("Non trovo il blocco -b 'cookie...' nel file chrome-curl.txt")

cookie_string = m.group(1)
cookies = [c.strip() for c in cookie_string.split(";") if c.strip()]

keep_names = {
    "cf_clearance",
    "__cf_bm",
    "__cflb",
    "_cfuvid",
    "_puid",
    "oai-sc",
    "oai-chat-web-route",
    "oai-hlib",
    "oai-did",
}

kept = []

for c in cookies:
    name = c.split("=", 1)[0]
    if name.startswith("__Secure-next-auth.session-token."):
        kept.append(c)
    elif name in keep_names:
        kept.append(c)

result = "; ".join(kept)
print(result)
print(f"Lunghezza cookie: {len(result)} byte", file=__import__("sys").stderr)
PY

Using the reduced cookie set, I was able to retry the download.

URL='https://chatgpt.com/backend-api/estuary/content?id=7195b6403177abe249c69d5d1d4fa8bf5bc9d98264d6c04ea26a847a7848b395-2026-06-11-13-13-43-d92944da4f4349fdaadb6b1fa6939925.zip&ts=494796&p=de&cid=2&sig=0ed610cd9f754acdb66cc40542727c4891d944fe7ae7df6c9d877fb31a373e25&v=0'

COOKIES="$(cat cookies-minimi.txt)"

curl "$URL" \
  -L \
  --compressed \
  --show-error \
  --progress-bar \
  -H "cookie: $COOKIES" \
  -H 'accept: application/zip,application/octet-stream,*/*' \
  -H 'referer: https://chatgpt.com/' \
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36' \
  -D headers-download.txt \
  -o chatgpt-export.zip \
  -w "\nHTTP_CODE: %{http_code}\nCONTENT_TYPE: %{content_type}\nSIZE_DOWNLOAD: %{size_download}\nFINAL_URL: %{url_effective}\nTIME_TOTAL: %{time_total}\n" | tee result-download.txt

At that point authentication worked: curl returned HTTP 200 with a content type of application/octet-stream. This time I was actually downloading a ZIP archive, not an HTML login or verification page. Unfortunately, the file was still unusable when the download finished.

ls -lh chatgpt-export.zip
-rw-r--r--@ 1 antonio staff 2,1G 12 giu 22:02 chatgpt-export.zip

file chatgpt-export.zip
chatgpt-export.zip: Zip archive data, at least v2.0 to extract, compression method=deflate 

unzip -t chatgpt-export.zip
Archive: chatgpt-export.zip 
  End-of-central-directory signature not found. Either this file is not 
  a zipfile, or it constitutes one disk of a multi-part archive. 
  In the latter case the central directory and zipfile comment will be found on the last disk(s) of this archive. 
  unzip: cannot find zipfile directory in one of chatgpt-export.zip or chatgpt-export.zip.zip, and cannot find chatgpt-export.zip.ZIP, period. 

I then checked the file size and HTTP headers.

stat -f "Dimensione locale: %z byte" chatgpt-export.zip
Dimensione locale: 2214592512 byte

echo
echo "Header utili:"
grep -Ei 'HTTP/|content-length|content-range|accept-ranges|content-type|content-encoding|etag|last-modified|x-oai-request-id|cf-ray' headers-download.txt

Header utili: HTTP/2 200 content-type: application/octet-stream last-modified: Thu, 11 Jun 2026 13:17:07 GMT accept-ranges: bytes etag: "0x8DEC7BBBCE6CD38" x-oai-request-id: df851987-ebe8-4167-9faf-5bca95c913e0 x-content-type-options: nosniff cf-ray: a0ab6edbae75eda3-MXP

To investigate further, I searched the last 20 MB of the file for the signatures normally found near the end of a ZIP archive.

python3 - <<'PY'
from pathlib import Path

p = Path("chatgpt-export.zip")
data = p.read_bytes()[-20_000_000:]

signatures = {
    b"PK\x05\x06": "EOCD normale",
    b"PK\x06\x06": "EOCD ZIP64",
    b"PK\x06\x07": "ZIP64 locator",
}

print(f"Dimensione file: {p.stat().st_size} byte")

for sig, name in signatures.items():
    pos = data.rfind(sig)
    if pos >= 0:
        absolute = p.stat().st_size - len(data) + pos
        print(f"Trovata firma {name} a offset {absolute}")
    else:
        print(f"Firma {name} NON trovata negli ultimi 20 MB")
PY

Dimensione file: 2214592512 byte Firma EOCD normale NON trovata negli ultimi 20 MB Firma EOCD ZIP64 NON trovata negli ultimi 20 MB Firma ZIP64 locator NON trovata negli ultimi 20 MB 

The check found neither the standard EOCD signature nor the ZIP64 signatures within the last 20 MB. Combined with the error from unzip, this strengthened the hypothesis that the download had stopped before the archive was complete.

Rather than starting over from zero, I decided to try resuming the download from where it had stopped. Since I already had COOKIES and URL available, I used curl again, this time with the -C - option.

COOKIES="$(cat cookies-minimi.txt)"

curl "$URL" \
  -L \
  -C - \
  --show-error \
  --progress-bar \
  --retry 5 \
  --retry-delay 2 \
  --retry-all-errors \
  -H "cookie: $COOKIES" \
  -H 'accept: application/zip,application/octet-stream,*/*' \
  -H 'referer: https://chatgpt.com/' \
  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36' \
  -D headers-resume.txt \
  -o chatgpt-export.zip \
  -w "\nHTTP_CODE: %{http_code}\nCONTENT_TYPE: %{content_type}\nSIZE_DOWNLOAD: %{size_download}\nFINAL_URL: %{url_effective}\nTIME_TOTAL: %{time_total}\n" | tee result-resume.txt

  HTTP_CODE: 206 
  CONTENT_TYPE: application/octet-stream 
  SIZE_DOWNLOAD: 2005844189 
  FINAL_URL: https://chatgpt.com/backend-api/estuary/content?id=7195b6403177abe249c69d5d1d4fa8bf5bc9d98264d6c04ea26a847a7848b395-2026-06-11-13-13-43-d92944da4f4349fdaadb6b1fa6939925.zip&ts=494796&p=de&cid=2&sig=0ed610cd9f754acdb66cc40542727c4891d944fe7ae7df6c9d877fb31a373e25&v=0
  TIME_TOTAL: 182.905019

Fortunately, the server supported resuming downloads, as confirmed by curl's output:

HTTP_CODE: 206
SIZE_DOWNLOAD: 2005844189

206 means Partial Content: the server accepted the resume request and sent only the remaining data. Initially, I had:

2214592512 bytes

It then added:

2005844189 bytes

The final total was:

4220436701 bytes

That’s approximately 4.22 GB in decimal units, or 3.93 GiB.

Finally, I checked the archive’s integrity with:

unzip -t chatgpt-export.zip

stat -f "Dimensione finale: %z byte" chatgpt-export.zip
Dimensione finale: 4220436701 byte

file chatgpt-export.zip
chatgpt-export.zip: Zip archive data, at least v2.0 to extract, compression method=deflate

unzip -t chatgpt-export.zip
Archive:  chatgpt-export.zip
    testing: chat.html                OK
    testing: conversation_asset_file_names.json   OK
    [...]
    testing: library_files.json       OK
    testing: message_feedback.json    OK
    testing: shared_conversations.json   OK
    testing: user.json                OK
    testing: user_settings.json       OK
    testing: export_manifest.json     OK
No errors detected in compressed data of chatgpt-export.zip.

The command returned:

No errors detected in compressed data of chatgpt-export.zip.

That confirmed the ZIP was intact.

The real issue had been an interrupted download, resolved with curl -C -, which retrieved the missing portion of the file. In some tests, I even had to repeat the resume operation two or three times.

Of course, curl isn't the only tool that can resume an interrupted download. Graphical download managers such as JDownloader 2 and Free Download Manager are cross-platform, support resuming downloads, and can handle authenticated requests. However, when it comes to ChatGPT exports, compatibility with signed URLs and session cookies isn't necessarily guaranteed. I chose curl because it's already available on macOS and let me reproduce the HTTP request copied from Chrome and control the transfer without installing additional software. It was a straightforward, reproducible solution that I could verify step by step.

The Python Script: ChatGPT Export Resumer

In short, I recovered the ZIP download by using:

• Chrome DevTools;
• Copy as cURL;
• a cleanup of the cookies copied from the browser;
• curl -C - to resume the download.

At that point, I decided to automate the process with a Python script, which I’ve published on GitHub:

chatgpt_export_resumer.py

The script starts with chrome-curl.txt, containing the command copied from Chrome, and performs the following tasks:

• Reads the Copy as cURL command and extracts the required URL and cookies.
• Removes unnecessary cookies and prepares a temporary curl configuration.
• Downloads the ZIP archive, checks its integrity, and automatically attempts to resume an incomplete download.
• Generates a diagnostic report and optionally extracts the archive and opens chat.html.
• Can delete temporary and sensitive files through the --cleanup option.

Why Did This Happen?

Looking online, I found that I wasn’t alone. On Reddit and the official OpenAI community forum, several threads describe exactly the same issue: a download that appears complete in the browser, a ZIP file saved to disk, and an error when attempting to extract it. One user documented downloading the same archive three times on macOS, using both Chrome and Safari, with the same outcome every time. That made a browser- or operating-system-specific problem less likely. The discussions appeared within a relatively recent period, which is consistent with the possibility that growing export sizes are causing more users to encounter these limits for the first time. A second thread on the OpenAI forum reports similar cases and reaches comparable conclusions.

I’d never experienced this problem with previous exports, which were much smaller, usually just a few hundred megabytes. The main difference in my case was therefore the size of the archive. It was no longer a package made up almost entirely of text, JSON conversations, and a handful of metadata files. It also contained numerous .dat files, asset references, files attached to conversations, and content associated with newer ChatGPT features. With modern usage, especially when images, attachments, or multimodal features are involved, an export can become far larger than a purely text-based archive. In my case, the final file exceeded 4 GB.

Testing on both macOS and Windows made a problem specific to one browser or operating system less likely. But I still needed to understand where the transfer was being interrupted. Possible causes included timeouts, network problems, or failures in intermediate delivery systems such as proxies, CDNs, and load balancers. An archive several gigabytes in size generally takes longer to transfer, increasing the chance of encountering interruptions or limits along the way. Without access to server-side logs, however, I couldn’t identify the responsible component with any certainty.

During debugging, I also encountered this header:

cf-mitigated: challenge

According to Cloudflare’s documentation, this header indicates that a response has been intercepted and replaced with a challenge, meaning an automated security check designed to distinguish legitimate users from bots, for example through a CAPTCHA or a browser check before allowing access to the requested resource. In that case, I wasn’t receiving the ZIP but an HTML login or verification page. This doesn’t automatically mean Cloudflare caused the truncated download, but it does confirm that the access path involved intermediate security checks that curl couldn't get past on its own without the browser's cookies.

If You’re Still Having Problems

The procedure described in this article worked for me and allowed me to recover an export of more than 4 GB in full. However, I can’t guarantee that it will work in every situation or that it will continue to work over time. ChatGPT is an evolving service, and changes to authentication, cookie management, or the way export archives are delivered could require changes to both the procedure and the Python script.

If the download continues to fail despite attempts to resume it, you can contact OpenAI Support and provide technical documentation of the issue. In its support documentation, OpenAI explains that a HAR file, which records the network requests made during a browser session, can be useful for diagnosing certain problems.

HAR stands for HTTP Archive. It’s a file with a .har extension that a browser can generate, containing network requests made during a session, including URLs, headers, responses, HTTP status codes, response times, and transferred file sizes. This is exactly the kind of information that can help demonstrate that a download ended before completion and that fewer bytes were received than expected. OpenAI's data export documentation can also provide useful context for a support ticket. If you need help generating a HAR file, this video tutorial, which isn't affiliated with OpenAI, walks through the process step by step.

One important warning: HAR files can contain session cookies, authentication tokens, and signed URLs. Before attaching a HAR file to a support ticket, even an official one, you should sanitize it by removing sensitive values. OpenAI explicitly recommends doing so.

Conclusion

What initially looked like a corrupted ZIP archive turned out to be an incomplete download. The beginning of the file was valid, but the central directory required to extract its contents was missing.

The solution was to reuse an authenticated request captured from Chrome and resume the transfer with curl -C -. The server responded with HTTP 206 Partial Content, allowing me to download the missing bytes and fully recover an archive of more than 4 GB.

To avoid having to repeat this procedure manually every time, I developed ChatGPT Export Resumer, a Python script that automates downloading, resuming interrupted transfers, verifying ZIP integrity, and optionally extracting the archive.

The project is available on GitHub, along with the source code and complete documentation in English and Italian, including installation instructions, usage examples, and details of all available options.

Useful Links

• ChatGPT Export Resumer GitHub repository: https://github.com/levysoft/chatgpt-export-resumer
• OpenAI data export documentation: https://help.openai.com/en/articles/7260999-how-do-i-export-my-chatgpt-history-and-data
• OpenAI support and HAR documentation: https://help.openai.com/en/articles/6614161-how-can-i-contact-support

Originally published at Levysoft.

There’s a software development technique that dates back to the 1980s and is now making a surprising comeback thanks to AI. It’s called clean room, but it doesn’t refer to a physical space: it’s a development methodology based on separating information between those who study a program and those who rewrite it, with the aim of recreating its functionality without copying the original source code. For decades, it was a complex and expensive practice, used primarily when companies needed to build products compatible with proprietary technologies. Today, with AI agents capable of analyzing documentation, writing code, running tests, and autonomously fixing errors, the same process can be carried out much more quickly, to the point where some developers are attempting to recreate entire commercial applications in just a few weeks. This phenomenon caught my attention mainly because of its potential implications for the future of software development, licensing, and the economic value of applications. To understand what’s happening, though, we need to go back to a time when building a computer compatible with a competitor’s machine could require months of work and a team of lawyers.

When Clean Room Development Was Used to Recreate the IBM BIOS

In 1981, IBM introduced its first Personal Computer, the Model 5150, which would become one of the defining products of the entire computer industry. As IBM recalls in its own historical account, the machine was designed around a relatively open architecture, largely based on commercially available components. This allowed other manufacturers to build computers with similar hardware specifications, but one fundamental obstacle remained: the BIOS (Basic Input/Output System), the firmware responsible for initializing the hardware and providing programs with the basic functions needed to communicate with the computer. The original BIOS was protected by copyright and, although IBM had published its source code in technical manuals, being able to read it did not mean having permission to copy it. Without a compatible BIOS, a computer built using similar components might still be unable to run software designed for the IBM PC correctly.

The original document is still available today: the Personal Computer Technical Reference, published by IBM in August 1981, includes the complete original BIOS listing in Appendix A, written in Assembly language and accompanied by comments describing how it works.

It was precisely this problem that led to the widespread adoption of the clean room technique. Compaq, founded in 1982, wanted to build a computer capable of running IBM software without using the original IBM BIOS. The process it adopted required strict separation between those studying how the BIOS worked and those responsible for writing the new code. One group of engineers analyzed the original system, examined its available calls, interrupts, and outputs, and translated everything into functional specifications: for example, how a particular BIOS call was supposed to behave when reading a disk sector, which registers it used, and what values it returned when an error occurred. These specifications were also reviewed from a legal perspective before being handed over to a second group of programmers who were not allowed to access IBM’s source code. Those programmers then created an entirely new implementation based exclusively on the information they received. The resulting software had to behave like the original while being independently written.

This separation was carefully documented because, in the event of a legal dispute, the company needed to demonstrate that its programmers had not reproduced portions of the protected code. In the PBS documentary Triumph of the Nerds, Compaq co-founder Rod Canion describes this very process, explaining the importance of behavioral analysis and legal oversight. The Compaq Portable, announced in 1982 and commercially released in 1983, demonstrated that it was possible to build a highly IBM-compatible PC using this approach.

Another decisive development came in 1984: Phoenix Technologies developed an IBM-compatible BIOS using a clean room process and began licensing it to other computer manufacturers. This was significant because PC manufacturers no longer had to undertake the entire reconstruction process themselves. They could purchase a ready-made, independently developed BIOS, helping the IBM-compatible PC market expand and gradually weakening IBM’s control over the architecture it had made popular. Phoenix founder Neil Colvin later described the methodology in the preface to System BIOS for IBM PC/XT/AT Computers and Compatibles: the engineers who had studied the original BIOS passed functional specifications to programmers who had never been exposed to its code.

The clean room approach therefore emerged from a very practical need: achieving functional compatibility while keeping the implementation independent. It was an organized form of reverse engineering, but its cost represented a substantial barrier. It required experienced professionals, many hours of analysis, testing on actual machines, and documentation rigorous enough to withstand potential legal challenges. For a company trying to reproduce a competitor’s software behavior, the time required to develop a working product was itself a considerable investment.

From Traditional Clean Room Development to AI Agents

More than forty years later, in October 2026, developer Brandon Thomas brought this methodology back into the spotlight with the release of ArtCraft and its collection of free applications. The project includes fifteen open-source applications, at various stages of development and written primarily in Rust, designed to offer functionality similar to that of well-known commercial software. PhotoCraft draws inspiration from Adobe Photoshop, VectorCraft from Illustrator, FilmCraft from Premiere Pro, and PdfCraft from Acrobat, while WordCraft, GridCraft, and DeckCraft recreate features associated with Word, Excel, and PowerPoint, respectively. The collection also includes SoundCraft for audio production, CADCraft for technical drawing, TextureCraft for creating and editing textures on 3D models, and Craft Anything, a tool designed to analyze how existing software works and build new applications with the assistance of AI agents. Other tools for photography, page layout, and interface design complete the collection. The applications are available for several operating systems, including Linux, and some can run directly in the browser thanks to WebAssembly. There’s also an independently hosted collection where users can explore and launch the web-based editors.

What makes this project particularly interesting is its development process. Thomas used AI agents, including Claude Code powered by the Claude Opus 5.5 model, to generate and modify large amounts of code, distributing the workload across multiple parallel sessions. The public repositories contain files such as PhotoCraft’s AGENTS.md, which provide operational instructions that AI agents must follow during development. The document explicitly states that the behavior and appearance of proprietary programs may be studied, but prohibits copying their code, shaders, color profiles, and other protected assets. Public specifications, such as those describing the PSD file format, are preferred for implementing file compatibility, alongside technical standards and observations of the original software’s behavior. The instructions also require automated testing, document compatibility checks, error handling, and documentation updates whenever significant changes are made.

There is, however, an important technical difference compared with the clean room methodology of the 1980s. In the case of Phoenix Technologies, the team responsible for analyzing the IBM BIOS could directly examine the Assembly source code that IBM had published in its technical manuals, using it to derive functional specifications for the programmers in the second team, who were prohibited from accessing the original code. With PhotoCraft, ArtCraft claims to follow an even more demanding process during the analysis phase: AI agents must reconstruct Photoshop’s functionality by observing its behavior, analyzing the results it produces, and consulting publicly available technical documentation, without using Adobe’s proprietary source code. This means having to infer the rules governing a program’s behavior without being able to directly examine the original algorithms that implement them.

Another important aspect is that according to ArtCraft’s stated development rules, this process does not involve decompiling the original program. Decompilation is a reverse engineering technique that makes it possible to analyze executable code and reconstruct a more readable representation of it in an attempt to understand its internal logic. PhotoCraft’s approach is instead based on black-box observation of the software, using tests, output comparisons, and publicly available specifications to develop an equivalent implementation independently. The distinction matters because decompilation can reveal the instructions used to implement a program, whereas behavioral analysis requires developers to infer how it works without knowing its underlying code. However, clean room development does not inherently exclude every form of decompilation, which may be used during the analysis phase in other contexts, subject to applicable legal restrictions.

Separating analysis from implementation remains essential: AI agents can be assigned different tasks in separate processes, with one agent generating specifications and another writing code, but this separation must actually be implemented and documented. A file instructing agents not to copy original code establishes a development rule, not sufficient proof that the entire process was independent. The situation is further complicated by the fact that it is not always possible to reconstruct precisely which information the agents used or what the underlying models may have encountered during training. ArtCraft claims to follow a clean room approach and publishes extensive technical information supporting its methodology, but this does not amount to independent legal verification.

The results also need to be interpreted carefully. The fact that an application can quickly reproduce Photoshop’s interface or provide hundreds of commands does not mean it already offers the same depth of functionality. According to PhotoCraft’s official documentation, updated on November 1, 2026, there is an important distinction between the number of implemented features and the application’s actual suitability for professional work: the project estimates that approximately 76% of the targeted features have been implemented, while professional readiness stands at around 45%. These are the developers’ own estimates, not independent benchmarks. Challenges remain in PSD file fidelity, performance, stability, generative features, and compatibility with Photoshop’s extension ecosystem. The speed at which the software was created is impressive, but producing an initial working implementation is a different challenge from ensuring years of reliable use with real documents, different hardware configurations, and continuous updates.

ArtCraft is not an isolated example, either. The GitHub repository HeyPuter/everything pursues an even broader goal: rebuilding and distributing open-source alternatives to a wide range of proprietary applications, from office software and collaboration tools to graphics editors, CAD programs, and enterprise management systems. The project provides dozens of applications, including alternatives to Photoshop, Word, Excel, Slack, Salesforce, and AutoCAD, collected in a single repository and distributed primarily under the MIT license. Compared with ArtCraft, its approach focuses mainly on web applications, using JavaScript and integrating with the Puter ecosystem. The project also states its intention to rebuild software from scratch, but the publicly available documentation examined does not describe a procedure demonstrating strict separation between analyzing the original programs and implementing the new code. It would therefore be inaccurate to automatically classify Everything as a clean room project in the traditional technical sense. Nevertheless, it remains an important example of how ambitious projects offering open alternatives to established commercial software have become.

Craft Anything: When Clean Room Becomes Software Itself

Among the ArtCraft projects, Craft Anything may represent the most interesting evolution of the clean room concept. While PhotoCraft, VectorCraft, and the other applications are examples of software rebuilt through AI-assisted development processes, Craft Anything attempts to turn that same process into a tool that anyone can use. In other words, the methodology used to create alternatives to commercial applications becomes an open-source application itself, designed to allow other developers to repeat the experiment with different software. This is a significant step: the goal is no longer simply to rebuild a product, but to make the reconstruction process itself reusable and at least partially automated.

Developed in Rust, Craft Anything allows users to specify a website, application, or video game and describe the result they want to achieve. The system organizes the work into four stages: it analyzes the reference program, assigns an AI agent to build a new implementation, compares the result with the original, and attempts to correct the differences it identifies. In Clean Room mode, enabled by default, the analysis is limited to externally observable elements such as screenshots, visible text, component layouts, and interface behavior, without reading source code or internal files. Deep mode, on the other hand, allows the system to examine internal software components using reverse engineering tools such as Ghidra. The entire engine can be accessed through a graphical interface, a command-line interface, or an MCP (Model Context Protocol) server, making its capabilities available to other AI agents as well.

The potential consequence is a kind of democratization of clean room development: a process that required separate teams of engineers, rigorous documentation, and substantial investments in the 1980s could become accessible to independent developers and small teams through automated tools. Craft Anything is still in the early alpha stage and, according to the developers’ published documentation, some functional checks remain incomplete, while comprehensive live demonstrations of full reconstruction in Clean Room mode have not yet been documented. Furthermore, restricting access to the original source code does not necessarily provide the strict separation of responsibilities required by the traditional methodology, nor does it automatically guarantee that the resulting implementation is legally independent. The significant development is the possibility of turning a specialized technique into a repeatable process that could become accessible to many more people, even though the technical and legal challenges of software reconstruction have not yet been fully resolved.

Is It Legal to Rebuild Software Without Copying Its Code?

From a legal perspective, the issue is more complex than it might initially appear. The fundamental principle is that copyright protects the expression of a computer program, including its code and other protectable original elements, but does not automatically grant its developer a monopoly over every function the program performs. This distinction was clarified by the Court of Justice of the European Union in its May 2, 2012 ruling in SAS Institute v. World Programming. The case concerned software developed to reproduce the functionality of the SAS system without accessing its source code. The Court held that the functionality of a computer program, the programming language, and the file formats used to exploit certain functions do not, as such, constitute forms of expression protected by copyright in computer programs. This does not rule out the possibility that specific elements, such as original expressions contained in documentation or an interface, may be protected under other legal provisions.

European Directive 2009/24/EC also distinguishes between two activities that are often confused. Article 5(3) allows a person entitled to use a program to observe, study, or test its functioning in order to determine the ideas and principles underlying it, while performing operations that they are authorized to carry out. Article 6, on the other hand, governs decompilation, the process of reconstructing a representation of code from an executable program, allowing it under specific conditions when it is indispensable to obtain information necessary for interoperability with independently developed software. Information obtained in this way cannot be freely used for other purposes. In 2021, in the Top System ruling, the Court also recognized that a lawful purchaser may decompile a program to the extent necessary to correct errors affecting its operation, subject to the conditions established by the applicable legal framework. These exceptions do not amount to general authorization to decompile any commercial product for the purpose of creating a competing copy.

In the United States, an important precedent is the 1992 Sega Enterprises v. Accolade ruling. The Ninth Circuit Court of Appeals recognized that, under the specific circumstances of the case, disassembling a program could constitute fair use when it was the only available means of accessing functional elements not protected by copyright and served a legitimate purpose, such as achieving compatibility with another system. This decision does not provide general authorization to copy competing programs either, but it confirms the importance of distinguishing between reproducing protected code and studying functionality to create an independent implementation. The legal conditions governing these activities nevertheless differ across jurisdictions.

The crucial issue, therefore, concerns the origin of the information used to write the new program. Observing how an application responds to commands and independently reconstructing its behavior is legally different from extracting its code, converting it into specifications, and having an AI agent rewrite it. In the latter case, the involvement of an AI model does not automatically eliminate the conditions and restrictions that applied to obtaining the original material. Additional issues may also arise involving patents, trademarks, trade secrets, licenses, and the reproduction of specific graphical elements. The purpose of the clean room methodology is precisely to reduce the risk of using protected material and to document the independence of the development process, but it does not, by itself, guarantee that no rights have been infringed.

A recent case illustrates how controversial this distinction can become even within the open-source community. In March 2026, the maintainer of the Python library chardet, widely used for automatically detecting character encodings, published a completely rewritten version developed with the assistance of Claude Code, replacing the previous LGPL license with the more permissive MIT license. Mark Pilgrim, the library’s original author, challenged the change, arguing that the maintainer was deeply familiar with the previous code and that an AI-assisted rewrite was not sufficient to eliminate the obligations imposed by the original license. The maintainer defended the structural independence of the new implementation, also presenting similarity comparisons with earlier versions. The controversy, reported by Ars Technica and examined in greater detail by LWN, does not automatically establish which interpretation is correct, but highlights a question that is likely to become increasingly common: how independent must a rewrite be before the resulting software can be considered a new work and distributed under a different license?

The Economic Question: If Rebuilding Software Becomes Cheap, Who Will Fund New Ideas?

There’s another aspect that I find particularly interesting, one that goes beyond the debate over licensing. For a long time, the cost of developing a complex application provided a form of economic protection for those who had invested in creating it. A competitor could attempt to reproduce its functionality without violating copyright, but would still have to bear substantial costs to understand the product, design a new architecture, implement its algorithms, fix bugs, and achieve an acceptable level of quality. The time required for competitors to catch up often allowed the original developer to keep selling the software and finance subsequent versions.

AI agents are reducing, above all, the cost of the initial implementation. Specifications can be transformed into code much more quickly, multiple agents can work simultaneously on different components, and a substantial portion of repetitive development tasks can be automated. But projects such as Craft Anything introduce a further possibility: not only making it cheaper to rebuild an application, but turning the reconstruction process itself into a reusable tool. If this approach achieved sufficient reliability, the work required to analyze, recreate, and verify a program could be repeated across different products without having to organize the entire process from scratch each time. The cost of individual reconstructions could therefore decrease even further, encouraging the proliferation of alternatives to existing software. This remains a possibility that needs to be tested: automating certain stages does not mean eliminating the technical, legal, and organizational challenges involved in developing complex applications.

This transformation recalls the concept of creative destruction associated with the economist Joseph Schumpeter, in which innovation changes market dynamics by making established activities and business models less competitive. The issue, however, also concerns the incentives to fund research into new solutions. If a small software company spends two years developing an original technology and a competitor can reproduce its essential features within a few weeks, the time available to recover that investment could shrink considerably. The risk would be greater for companies whose competitive advantage depends almost entirely on a particular feature, without an established customer base or a broader ecosystem of services. This scenario reveals a potential economic imbalance: the cost of inventing a solution could remain substantially higher than the cost of rebuilding it once its behavior can be observed.

This does not necessarily mean that applications such as Photoshop, AutoCAD, or Microsoft Office will suddenly lose their markets. Their value also includes compatibility with enormous archives of documents, integration into business processes, extensions developed over many years, technical support, security, and the assurance that users will be able to keep relying on the same tools over time. For a professional, being able to open a PSD file is useful, but editing and saving it without altering layers, masks, color profiles, or information that the alternative application does not yet support is a much more demanding requirement. The same applies to an Excel spreadsheet containing complex macros or a CAD project that needs to be shared with other engineering or design firms. True interoperability requires compatibility that has been tested even in less common scenarios, the ones that tend to emerge when software is used every day.

In an article published on October 13, 2026, open-source licensing attorney Heather Meeker interpreted ArtCraft and Everything as signs of a shift in the commercial value of software. In her view, the market may increasingly reward product quality, brand reputation, user trust, and ease of distribution and use, rather than ownership of the code alone. Meeker also discloses that she is an investor in Puter, a circumstance worth considering when evaluating her enthusiasm for this model. Nevertheless, the distinction between writing software and providing the infrastructure needed to operate it over time remains particularly interesting: a reliable cloud service requires continuous availability, data protection, backups, updates, and operational responsibilities that go far beyond generating code.

There is, however, another possible consequence, and a less pessimistic one. The same tools that make it easier to rebuild existing products could also reduce the cost of experimenting with genuinely new ideas. An independent developer could combine open-source components and AI agents to create prototypes that would previously have required a much larger team. A small business could develop a tool tailored to its own processes without commissioning an entire management system from scratch. Users might request increasingly customized applications, perhaps built on existing open-source products and adapted to needs that major software vendors have little economic incentive to address. At the same time, every customization introduces maintenance, compatibility, and security challenges, particularly when the underlying software is updated. AI agents could help reduce the cost of maintaining and migrating these modifications, but the resulting software would still need to be tested to ensure that it continues to work correctly with real data and external systems.

Looking back at the history of the IBM BIOS, it seems to me that the most significant change concerns the cost of technological independence. In the 1980s, Compaq and Phoenix demonstrated that it was possible to recreate an essential component without using the original manufacturer’s code, helping establish a much broader market for compatible computers. Today, AI agents make it possible to attempt something similar on a scale that would have been difficult for individual developers or small teams to sustain in the past. Projects such as ArtCraft and Everything show how much easier it has become to initiate a software rewrite, while Craft Anything attempts to take this a step further by turning the reconstruction methodology into a technology that others can use themselves. It remains to be demonstrated how effectively this automation can handle complex products, but the direction is significant: the change may affect not only how software is written, but also how quickly the ability to develop it spreads.

Above all, one economic question remains open: if the cost of catching up with someone who has invented a new solution continues to fall, how will the incentives to invest in being first change? These same tools could encourage competition, broaden access to software development, and make applications economically viable that would not be feasible today. Yet they could also shorten the time available to recover investments in developing new features. The challenge will not simply be to make it cheaper to rebuild what already exists, but to find a balance that continues to make it worthwhile to invent what does not yet exist.

Originally published at Levysoft.

When using large language models (LLMs) such as ChatGPT, Claude, or Gemini to analyze an article, summarize technical documentation, or explore a topic found online, we often need to provide the content of a web page directly. Sometimes simply pasting the link is enough, especially when the model has tools to browse the web, but the system cannot always retrieve the text correctly or distinguish the main content from all the other elements that make up the page.

A practical solution is to convert the page into Markdown, a lightweight text format that preserves a recognizable structure through headings, paragraphs, lists, links, and code blocks, while removing much of the HTML used for visual presentation. The result is generally more compact and easier to process, although conversion does not automatically guarantee better understanding by the model: the benefit depends primarily on the quality of the extraction and the amount of unnecessary content removed. This gives us text that we can paste directly into a conversation, save as a .md document, or use in a retrieval-augmented generation (RAG) system, such as Google's Gemini Notebook (formerly NotebookLM).

To automate this process, we can use bookmarklets, small JavaScript programs saved as browser bookmarks that perform an action on the current page.

The idea is simple: instead of repeatedly copying a website’s address, opening a conversion service, and pasting the URL manually, we can obtain the content in Markdown with a single click. Let’s see how to use two services, Jina Reader and Markdown Download, while also adding the ability to download the result directly.

Convert a Web Page to Markdown with Jina Reader

The first method uses Jina Reader, a service that retrieves the content of a web page and converts it into a text format suitable for processing by LLMs. This technique was described in December 2024 by Stephen D. Turner in the article Turn any webpage into markdown for LLM-friendly input: simply prepend https://r.jina.ai/ to the address of the page you want to convert.

For example, starting from https://example.com, we can request the Markdown version through:

https://r.jina.ai/https://example.com

The service retrieves the resource on its own server, extracts its content, and returns a structured text representation. According to the official documentation, Reader also supports PDF documents and pages that require JavaScript execution to display their content. It can also return results in different formats, including JSON, and allows certain aspects of the extraction process to be controlled through HTTP parameters and headers.

For occasional use, an API key is not required, although anonymous requests are subject to stricter limits than authenticated ones.

The Bookmarklet for Instant Conversion

We can make this process even faster by creating a bookmarklet that automatically adds the Jina Reader prefix to the address of the current page. Simply create a new bookmark in your browser and enter the JavaScript code in the URL field instead of a regular website address.

Jina Reader: View the Markdown

javascript:(function(){window.location.href='https://r.jina.ai/' + window.location.href;})();

Once the bookmark has been saved, simply open an article and click it to be redirected to the corresponding converted version. The text can then be copied and used directly in ChatGPT or another AI model, without having to work with the original HTML.

Automatically Download the Content as a Markdown File

We can further improve this solution by automating the download process as well. In this case, instead of simply changing the browser’s address, the bookmarklet uses fetch to request the converted content, stores it in a Blob object, and generates a temporary link to initiate the download of the .md file.

For the document’s filename, we can use the title of the current page, properly sanitized to remove characters that are not allowed in filenames. The advantage is that we obtain a document directly, ready to be archived, edited, or uploaded to a conversation with an LLM.

Jina Reader: Download the **.md** file

javascript:(async () => {
    try {
        const url = 'https://r.jina.ai/' + window.location.href;

        const response = await fetch(url, {
            headers: {
                'Accept': 'text/plain'
            }
        });

        if (!response.ok) {
            throw new Error('HTTP ' + response.status);
        }

        const markdown = await response.text();

        if (!markdown.trim()) {
            throw new Error('Risposta vuota');
        }

        const filename = (document.title || 'pagina')
            .replace(/[\\/:*?"<>|]/g, '')
            .trim()
            .replace(/\s+/g, '_')
            .slice(0, 120) || 'pagina';

        const blob = new Blob([markdown], {
            type: 'text/markdown;charset=utf-8'
        });

        const downloadUrl = URL.createObjectURL(blob);

        const a = document.createElement('a');
        a.href = downloadUrl;
        a.download = filename + '.md';

        document.body.appendChild(a);
        a.click();
        a.remove();

        setTimeout(() => {
            URL.revokeObjectURL(downloadUrl);
        }, 30000);

    } catch (error) {
        alert('Download Markdown non riuscito: ' + error.message);
    }
})();

Markdown Download: An Alternative Service

Another option is Markdown Download, an open-source project developed by Taras Glek, initially created to make web pages easier to read on e-reader devices. The service uses main-content extraction techniques, similar to those employed by Readability-style libraries, to produce a simplified version of the page.

As explained by the author in the article Developing markdown.download, the service allows a web page to be converted by passing its address as a ?url= parameter or by appending it directly to the service's URL path. Both methods are supported, for example:

https://markdown.download/?url=https://example.com

https://markdown.download/https://example.com

This structure is particularly well suited to bookmarklets because it automates conversion without requiring us to open the service and manually enter the address each time. It is worth noting that the response may be displayed as a readable HTML page in the browser or returned directly as Markdown, depending on the format requested through HTTP headers, particularly Accept.

The project also makes its source code available on GitHub, an interesting option for anyone who wants to study how the service works or build an independent solution.

Bookmarklet to View the Content

We can apply the same technique as in the first example, replacing the destination service with Markdown Download.

Markdown Download: Open the Converted Version

javascript:(function(){window.location.href='https://markdown.download/?url='+encodeURIComponent(window.location.href);})();

For Markdown Download, we can also use a variant that retrieves the converted text and saves it directly as a .md document. In this case, the fetch request specifies the Accept: text/markdown header to obtain the content in the desired format rather than an HTML representation. The project's source code explicitly supports CORS, allowing requests from different domains. However, restrictions imposed by the browser or the security policies of the page from which the bookmarklet is executed may still apply.

Markdown Download: Download the **.md** file

javascript:(async () => {
    try {
        const url = 'https://markdown.download/?url=' +
            encodeURIComponent(window.location.href);

        const response = await fetch(url, {
            headers: {
                'Accept': 'text/markdown'
            }
        });

        if (!response.ok) {
            throw new Error('HTTP ' + response.status);
        }

        const contentType = response.headers.get('content-type') || '';

        if (
            contentType.includes('text/html') ||
            contentType.includes('application/json')
        ) {
            throw new Error('Il servizio non ha restituito Markdown');
        }

        const markdown = await response.text();

        if (!markdown.trim()) {
            throw new Error('Risposta vuota');
        }

        const filename = (document.title || 'pagina')
            .replace(/[\\/:*?"<>|]/g, '')
            .trim()
            .replace(/\s+/g, '_')
            .slice(0, 120) || 'pagina';

        const blob = new Blob([markdown], {
            type: 'text/markdown;charset=utf-8'
        });

        const downloadUrl = URL.createObjectURL(blob);

        const a = document.createElement('a');
        a.href = downloadUrl;
        a.download = filename + '.md';

        document.body.appendChild(a);
        a.click();
        a.remove();

        setTimeout(() => {
            URL.revokeObjectURL(downloadUrl);
        }, 30000);

    } catch (error) {
        alert('Download Markdown non riuscito: ' + error.message);
    }
})();

Having two different services available is useful because content extraction does not necessarily follow the same rules. A complex page containing tables, dynamic elements, or an unconventional HTML structure may produce different results depending on the tool used. It is therefore advisable to compare the resulting document with the original, especially when the text contains technical information that must be preserved in full.

From Bookmarklets to Markdown Served Directly by Websites

Meanwhile, the way the web makes content available to AI systems is also changing. On February 12, 2026, Cloudflare announced Markdown for Agents, a feature that allows websites that enable it to provide a Markdown version of their pages directly through the standard HTTP protocol.

The mechanism relies on content negotiation, which allows a client to indicate to the server which format it prefers to receive. When a request includes the Accept: text/markdown header, a compatible website can return the document already converted, without requiring the client to download the entire HTML and then process it independently. Cloudflare performs this transformation on its own network for websites that have enabled the service.

For example, we can request the Markdown version of a Cloudflare documentation page with a simple command:

curl -H “Accept: text/markdown” \ https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/

The result may also include structured metadata, while the response headers can provide useful information about the returned format. However, this feature is not universal: it requires the website to support this type of response and its administrator to have enabled the conversion. For pages that do not offer this capability, services such as Jina Reader continue to serve a specific purpose.

There are also tools such as markdown.new, which combine different techniques to obtain Markdown from a public URL, using the format returned directly by the website when available and otherwise falling back to converting the HTML content. In this case, too, the service’s domain can be prepended to the address of the page to be processed.

Some Limitations to Keep in Mind

These external services are convenient, but they have certain practical limitations. Because they access web pages through their own connections, they do not automatically have access to our browser’s authenticated session. As a result, restricted content, pages protected by anti-bot systems, or pages that load information only after specific user interactions may be incomplete or inaccessible.

Conversion also involves some compromises. Markdown represents a document’s structure well, but it may lose information related to layout, interactive elements, or visual relationships between content elements. Furthermore, a link to an image is not equivalent to providing the model with the image itself. When analyzing technical documentation, an article containing many tables, or a page with source code, it is therefore important to verify that the essential parts have been preserved correctly.

Finally, it is worth remembering that when using a remote conversion service, the requested URL is transmitted to an external infrastructure. This is something to consider when working with non-public documents, links containing access tokens, or confidential material.

Conclusion

The bookmarklets we have explored allow us to use services such as Jina Reader and Markdown Download directly from the page we are viewing, choosing whether to display the converted content or download it as a .md file. I find this solution particularly convenient for collecting articles and documentation to use in my own research and analysis with AI models or simply for building a personal archive of documents that are easy to consult and reuse. The more recently introduced ability to obtain Markdown directly through HTTP could simplify this process even further, at least for websites that support this feature. For all other pages, conversion services remain useful tools, especially when we want to retrieve content quickly without repeatedly copying and pasting URLs.

Originally published at https://www.levysoft.it.

Some macOS features remain in place for years, surviving new versions, interface changes, and even name changes until they become almost invisible. We have seen them dozens of times in System Settings, perhaps enabled them years ago to solve a specific problem, and then completely forgotten about them. What makes things more complicated is that some of these features are not particularly easy to find in Apple’s documentation, or are described with a name that tells only part of the story. When their effects resurface much later, it is natural to look for the cause inside the application that appears to be misbehaving.

That is exactly what happened to me with tab restoration. For some time, I have been using Nova primarily as an editor, with several Markdown files open simultaneously, and I noticed that after quitting the app with ⌘Q, the tabs were no longer restored. So I started looking through Nova's settings for something equivalent to the "Continue where you left off" option found in browsers, convinced that the editor was failing to remember my previous session. Nova lets you configure many aspects of the Workspace, but it does not provide a simple switch that says "reopen the tabs from the last session".

The fact that Nova has a restoration mechanism is confirmed by Panic’s own documentation. Among the suggestions for troubleshooting crashes at launch, it recommends holding down Shift while opening Nova. This prevents the application from restoring its previous state, explicitly including open projects and tabs. Interestingly, Apple also recommends holding down Shift as a temporary way to prevent an application from restoring windows from the previous session. It is one of those long-standing macOS behaviors that continue to exist for years without being particularly visible in the interface.

The cause, however, was outside Nova. It was an old global macOS setting under System Settings → Desktop & Dock → Windows, where I had somehow enabled the option “Close windows when quitting an application”, probably years ago. All I had to do was turn it off, quit Nova with the tabs still open, and launch it again. Every tab returned exactly where I had left it.

A simple solution, hidden behind one of the least intuitive macOS setting names I have ever encountered.

Resume Has Been Around Since OS X Lion

What happened to me can be traced back to a feature that Apple introduced in 2011 with OS X 10.7 Lion, called Resume. The idea was to bring the behavior of Mac applications closer to what Apple was developing on the iPhone and iPad: quitting an application should not necessarily mean losing your working context. If you quit a program with several windows open, those windows could reappear in the same positions and states the next time you launched it.

The original Macworld review of Lion described precisely this behavior: when you quit an application with multiple windows open and launched it again, Lion brought those windows back to the screen just as you had left them. Resume worked alongside Auto Save and was designed to make quitting and subsequently reopening an application almost seamless.

The wording of the setting was also much clearer back then: “Restore windows when quitting and re-opening apps”. If the checkbox was selected, macOS preserved the state of the windows. If it was deselected, the application started with a clean slate.

With OS X 10.8 Mountain Lion, in 2012, Apple changed its approach and replaced the option with what is now known as “Close windows when quitting an application”.

The underlying behavior remained essentially the same as Resume, but the interface began describing the opposite scenario. To enable restoration, you therefore have to leave an option about closing windows turned off.

How This Setting Works

Apple’s current documentation explains the behavior quite clearly, although you first need to know that the setting exists to find the relevant explanation: if an application has windows open when you quit it, those windows can be displayed again the next time you launch it. To prevent this, you need to enable “Close windows when quitting an application”.

The distinction between closing a window and quitting an application is important. On macOS, clicking the red Close button closes the window, but the application normally remains running. Pressing ⌘Q, on the other hand, quits the application.

Resume records the state of the windows that exist when the application quits. If you deliberately close those windows beforehand, you cannot expect them to be recreated as though they had been left open.

The setting is global and, under the hood, is associated with the NSQuitAlwaysKeepsWindows preference. The macOS defaults project documents the default value as:

NSQuitAlwaysKeepsWindows = true

The name of the key makes the mechanism clearer than the graphical interface does: true means macOS preserves windows when an application quits. Since the checkbox in System Settings is expressed in the opposite way, this corresponds to having "Close windows when quitting an application" turned off.

You can also check the current value from Terminal using:

defaults read NSGlobalDomain NSQuitAlwaysKeepsWindows

On a configuration that normally preserves windows, you would therefore expect 1 or true. The same preference can be changed using defaults, but adjusting it through System Settings is still preferable: it is a global preference, and its effect extends to every application that participates in the macOS restoration system.

This also explains why it would not be a good idea for Nova to change the setting on its own. If Panic modified that preference to let Nova restore its tabs, it would simultaneously change the behavior of other applications on the Mac. Nova could, however, detect the configuration and inform users that restoration depends on this particular macOS setting, perhaps by adding a note directly to its Workspace settings.

A message such as “To restore windows and tabs the next time you launch Nova, make sure ‘Close windows when quitting an application’ is turned off in System Settings → Desktop & Dock” would have saved me quite a bit of time.

It Is Not Just About Windows

The name Apple chose makes an important aspect of this setting less obvious: what macOS can restore is not necessarily limited to a simple window. The state an application entrusts to the system can also include open documents, tabs, sessions, and parts of the interface layout. That is precisely why, in my case, I initially looked for the solution inside Nova. The editor’s tabs had disappeared, so there was no intuitive reason for me to connect the problem to the application’s windows.

Safari is probably the most obvious example: Apple explicitly documents that the browser can reopen windows and tabs from the previous session and identifies “Close windows when quitting an application” as one of the settings that control this behavior.

Something similar happens with Terminal, where tabs failing to reopen after ⌘Q can be traced back to the same global macOS preference. In fact, this is where it becomes even more apparent how misleading the setting's name can be. You do not even need multiple tabs open: with just one window and one session, leaving "Close windows when quitting an application" turned off means that Terminal can also recover the text and state of the previous session the next time it opens. Apple documents a feature called "Restore text when reopening windows" in Terminal's profile settings and specifies that these options are ignored when the global macOS preference for closing windows is enabled. In my test, when I reopened Terminal, the previous scrollback reappeared along with the message Restored session, and the shell was back in the directory where I had left it.

From this perspective, the word “windows” in System Settings describes only one visible part of the mechanism. For users, the consequences may appear elsewhere: Safari loses its open pages, Terminal loses its tab sessions, a document-based application may forget its workspace layout, and an editor like Nova may reopen without the tabs you were working on.

Two Different Settings That Are Easy to Confuse

There is another macOS preference that looks similar but comes into play at a different moment: “Reopen windows when logging back in”, displayed when you shut down, restart, or log out of your Mac.

That option determines whether applications that were open before shutdown should be launched again during the next macOS session. “Close windows when quitting an application”, on the other hand, controls what happens when you quit and subsequently reopen an individual application. Lion introduced both ideas as part of the same Resume philosophy, which still contributes to making the two mechanisms seem more closely related than they actually are in everyday use.

An Old Feature That Is Easy to Forget

In the end, the problem was not Nova, but an old macOS setting that I had probably enabled years ago and completely forgotten about. What misled me most was its name: I was looking for a feature related to the editor’s tabs and sessions, while macOS kept referring simply to “windows”.

In my case, the final solution turned out to be incredibly simple: System Settings → Desktop & Dock → Windows → turn off “Close windows when quitting an application”. Since then, I can leave the Markdown files I am working on open in Nova, press ⌘Q, and find them all waiting for me the next time I launch the editor.

This experience also made me realize how easy it is to lose sight of features that macOS has preserved for years, especially when their names do not make it immediately clear how they can affect the behavior of applications.

Originally published at Levysoft.

In a home or work environment where several people share the same Mac, especially an iMac located in a common area, it’s easy to forget which user account is currently logged in. This situation can create confusion and lead to mistakes when managing personal files or user-specific settings.

The solution I’d like to share is the one I use at home: permanently displaying the current user’s name directly on the desktop using GeekTool, a free application that allows you to integrate dynamic information into the macOS desktop environment.

What Is GeekTool?

GeekTool is the digital Swiss Army knife that every geek, beginner or experienced, should have in their macOS toolbox. Like a faithful companion on your computing adventures, it transforms the desktop from a simple “virtual desk” into a fully customized command center. If your desktop is your digital home, GeekTool is the interior designer that truly makes it yours: no more bare walls with a few scattered icons, but a living environment filled with useful information that adapts to your needs like a tailored suit. With a simple drag and drop, you can display temperatures, weather forecasts, CPU usage, quotes of the day, or simply your username.

GeekTool is a macOS application that can be downloaded for free from its official website. Once installed, the application features a clean and intuitive interface that makes it easy to create and manage your own Geeklets, small configurable widgets that blend seamlessly into your desktop background and allow you to display information from different sources:

• Shell commands: Output from Terminal commands
• Text files: Content from local or remote files
• Images: Charts, photos, and dynamic icons
• Log files: Real-time monitoring of log files

The id -F Command: The Key to Our System

One of the great advantages of macOS is its solid Unix/BSD foundation, a legacy Apple has maintained since the introduction of Mac OS X. This feature is not just an interesting technical detail, but a real treasure for those who know how to take advantage of it, because it gives us access to the full power of Unix commands, tested and refined over decades of development. GeekTool becomes the perfect bridge between these two worlds: the raw power of Unix commands and the visual elegance of the macOS desktop. We no longer have to choose between functionality and beauty. We can have both.

To solve my problem, I borrowed one of the basic commands of Unix systems: id. The id command is one of the historical pillars of Unix systems, dating back to the early versions in the 1970s. While the better-known whoami command simply returns the account username (for example, "antonio"), the id command has a more ambitious purpose: displaying complete information about the current user's identity within the system, a fundamental concept in a multiuser environment like Unix. When you run id without any parameters, you get a line packed with information:

uid=501(antonio) gid=20(staff) groups=20(staff),12(everyone),61(localaccounts),79(_appserverusr),80(admin)…

But if you add the -F option, the command becomes

id -F

and simply returns the full name of the currently logged-in user, the one you configured in macOS System Preferences. This can be just your first name, the classic first and last name combination, a nickname that represents you, or any other combination you prefer.

Using the id -F command does not pose any privacy risks because it does not access sensitive information, does not send data externally, does not require administrator privileges, and works completely offline.

Step-by-Step Configuration

1. Launching GeekTool

After installing GeekTool, launch it from the Applications folder. The main interface displays four available types of Geeklets: Shell, Web, Log, and Image.

2. Creating the Shell Geeklet

To display the username, we’ll use a Shell Geeklet:

1. Drag the “Shell” icon from the main panel onto the desktop
2. The properties window will open automatically
3. In the “Command” field, enter: id -F

The properties window offers numerous customization options:

Basic Settings

• Name: Assign a descriptive name (e.g., “Username”)
• Position: Define the X and Y coordinates for positioning
• Size: Set the width and height of the display area

Automatic Refresh

• Refresh every: Set the refresh interval in seconds (since the username is a static value, you can set it to 0 seconds)
• Timeout: Maximum time allowed for the command to execute (you can also set this to 0 seconds)

Visual Customization

Fonts and Sizes:

Choose a readable font with an appropriate size. Consider Arial or Helvetica for maximum readability. Recommended sizes are 14–18 pt for optimal visibility.

Colors:

Choose a color that contrasts well with your desktop background. White or black are safe choices for most backgrounds. In particular, for dark backgrounds, use white text or light colors. For colorful backgrounds, consider adding a shadow or outline to ensure readability, while for patterned backgrounds, position the text in areas with consistent colors.

Positioning:

I recommend placing it in the upper-right or upper-left corner (a classic, unobtrusive choice), or at the top center for maximum visibility.

Advanced Options

Output Encoding: Keep UTF-8 to support special characters and accents (important for names containing non-ASCII characters).

Alignment: Left, center, or right, depending on your chosen position. Right alignment works particularly well in the upper-right corner.

3. Managing Groups

GeekTool allows you to organize Geeklets into groups. Create a group called “Desktop” to organize all your informational widgets. This is useful for creating different profiles for different users and for easily enabling or disabling multiple Geeklets at once directly from the menu bar.

Advanced Customizations

Advanced Visual Styling

For a more refined appearance, consider these options that display additional information.

Command with the computer name:

echo "👤 $(id -F) | 💻 $(hostname)"

Command with the current time (in this case, set a refresh interval of 60 seconds and avoid excessively short intervals that could affect performance):

echo "$(id -F) • $(date '+%H:%M')"

Command with the date and time:

echo "👤 $(id -F) | 🕐 $(date '+%H:%M') | 📅 $(date '+%m/%d')"

Command with available disk space:

echo "👤 $(id -F) | 💾 $(df -h / | awk 'NR==2{print $4}') free"

Command with CPU usage:

echo "👤 $(id -F) | 🖥️ $(top -l 1 | grep "CPU usage" | awk '{print $3}') CPU"

Conclusions

Implementing a user identification system with GeekTool is an elegant and practical solution for multiuser macOS environments. The simplicity of the id -F command, combined with GeekTool's flexibility, offers endless customization possibilities, transforming the desktop from a simple collection of icons into a customizable information dashboard.

Implementing this system provides immediate and tangible benefits. From a practical standpoint, it helps prevent mistakes when managing personal files and sensitive documents, and instantly eliminates confusion about which account is currently active. This is particularly useful in family environments where parents and children share the same iMac or MacBook, in offices with shared workstations, in computer labs and educational environments, or for anyone who wants a more informative and personalized desktop.

Originally published at https://www.levysoft.it.

A few days ago, while browsing Hacker News, I came across an article titled Fancy Curl Sites, written by Alex, better known online as nytpu. The article described a rather curious experiment: making a website accessible directly from the terminal using curl, the command-line tool we normally use to make HTTP requests, download files, or query APIs. I opened Terminal on my Mac and typed curl nytpu.com, only to find myself looking at a homepage completely different from the one displayed in a browser: a large ASCII logo, colored text, a short introduction to the author, and a series of commands for exploring other sections of the website. What made it particularly interesting was that I could simply request a blog post using the same command and read its contents directly in the terminal, with headings, paragraphs, and links formatted for readability.

In his article, Alex explains that he manually created some of the pages, writing the ANSI control sequences used by terminals to manage colors and formatting directly into the files. For his blog posts, however, he took advantage of a feature of Gemroff, the markup language he had developed years earlier, which already supported generating text with ANSI escape codes to preview drafts in the terminal. This made it relatively straightforward to add the format to his static site generator, which was already publishing content over HTTP, Gemini, and Gopher. Alex himself acknowledges that the original idea was not his: he explicitly credits the earlier experiments at trinkey.com and proot.party, which inspired his implementation.

What I particularly liked was how a website could adapt to the program being used to access it. We are accustomed to thinking of web pages as HTML documents intended for browsers, complete with CSS, JavaScript, images, and graphical components, whereas in this case the same URLs become accessible through a text-based interface that preserves only the information needed for reading. There is also a nostalgic element that reminded me of the days of BBS systems and text-based interfaces, when a screen full of characters and a few colors were enough to give a service its own recognizable identity. That led me to wonder whether I could do something similar with Levysoft, which runs on WordPress and is hosted on an ordinary shared hosting service, where I can upload files via FTP but have neither SSH access nor permission to modify the web server configuration.

The WordPress Plugin

The solution came from combining PHP with the WordPress plugin system. I developed WP Curl Terminal, a small plugin that intercepts requests to the website and checks whether they originate from curl, by examining the HTTP User-Agent header. When it recognizes the client, WordPress returns a text-based representation of the content, using ANSI codes for colors; requests from regular browsers, meanwhile, continue to be handled by the theme without any changes. The entire mechanism works through ordinary HTTP and HTTPS connections, without opening additional ports, enabling Telnet services, or installing software on the server.

You can try it directly from macOS or Linux by typing:

curl -L https://www.levysoft.it/

Instead of the traditional homepage, an ASCII logo of Levysoft appears, accompanied by the motto Rev0lut1on 3.0 of my mind engine, followed by a list of the latest published posts, their dates, and the URLs needed to read them. The titles are retrieved directly from the WordPress database through its native functions, so every newly published post automatically appears in the terminal version as well.

The first implementation, however, had an obvious drawback: by attempting to convert the entire HTML page generated by the theme, it ended up including menus, widgets, categories, previews, author information, and repeated links. A simple request to the homepage produced more than 500 lines of text, most of which were of little use. I therefore changed the plugin’s logic so that it would retrieve post data directly, bypassing the graphical structure of the theme. The homepage became much more compact, with a configurable number of posts and a small section containing commands for exploring the blog.

For full-length articles, the behavior is slightly different. When requesting a post URL with curl, the plugin reads the content stored in WordPress and converts it into text, preserving the original structure as much as possible: headings and subheadings are distinguished from paragraphs, while unordered lists (ul) and ordered lists (ol) retain their structure and are highlighted using ANSI colors.

Blockquotes also receive specific formatting, while code blocks preserve their indentation, a particularly important detail for a blog like Levysoft, where I frequently publish PHP and Python examples, along with terminal commands.

HTML links are converted into text accompanied by their corresponding URLs, while images can be represented through their alternative text. To improve readability, paragraphs are also wrapped to approximately 76 columns, leaving code blocks untouched.

The conversion inevitably has some limitations: interactive components, content dynamically generated by plugins, and particularly elaborate layouts cannot always be faithfully represented in a terminal. I also decided to avoid executing shortcodes and dynamic blocks during conversion, keeping this mode as focused as possible on reading already published content.

Why Use the -L Option with cURL

The -L option used in the previous commands allows cURL to automatically follow HTTP redirects, which is particularly useful when a website redirects requests from HTTP to HTTPS. Without this option, cURL simply displays the server's response, without necessarily reaching the requested content. For example, when trying to access a Levysoft page over HTTP:

curl http://www.levysoft.it/

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html><head>
<title>301 Moved Permanently</title>
</head><body>
<h1>Moved Permanently</h1>
<p>The document has moved <a href="https://www.levysoft.it/">here</a>.</p>
<hr>
<address>Apache Server at www.levysoft.it Port 80</address>
</body></html>

By adding -L, however, cURL follows the redirect and reaches WordPress, allowing WP Curl Terminal to return the formatted content.

The same problem occurs when simply typing curl levysoft.it without specifying the protocol, because cURL normally attempts an HTTP connection. When using curl https://www.levysoft.it/ directly, however, the content is displayed correctly even without -L, since the requested address is already the final destination. I nevertheless decided to keep this option in the examples: when no redirects are involved, it does not generate additional HTTP requests and makes the commands usable on WordPress websites with different configurations.

Paginating cURL Output in macOS Terminal Using less Instead of more

When browsing WordPress blog posts directly from Terminal through WP Curl Terminal, you may come across particularly long articles that scroll quickly across the screen, making them difficult to read. The most obvious solution would be to append | more to the command, allowing the text to be displayed one screen at a time:

curl -L https://www.levysoft.it/ | more

Unfortunately, there is a drawback: on macOS, more may display the ANSI control sequences used by the plugin to color headings, section titles, and other text elements literally. As a result, you may end up with output resembling this:

% Total % Received % Xferd Average Speed 100 3434 0 3434 0 0 2682 ESC[1;36m# ##### # # # # #### ### ##### #####ESC[0m ESC[1;33mLevysoftESC[0m ESC[2;37mRev0lut1on 3.0 of my mind engineESC[0m ESC[1;33mULTIMI ARTICOLIESC[0m ESC[1;33m 1 19/10/2026 AnthemScore 6: dall’audio allo spartito…ESC[0m

The strings ESC[1;36m, ESC[1;33m, and ESC[0m represent the ANSI sequences that the terminal normally interprets to apply colors and text attributes. When displayed as ordinary characters, however, they make the output harder to read and defeat much of the formatting provided by the plugin. That is why I prefer using less instead of more, adding the -R option, which allows ANSI color sequences to be interpreted correctly:

curl -L https://www.levysoft.it/ | less -R

This way, the content retains its original color formatting and becomes much easier to navigate: we can move forward and backward through the screens using Space and b, scroll one line at a time with the arrow keys, search for a word by typing / followed by the desired term, and immediately jump to the beginning or end of the article with g and G. To exit, simply press q.

There is, however, a small inconvenience: when we exit less by pressing q, Terminal generally restores the previous screen, causing the content we were reading to disappear. If we want to keep the displayed text visible even after exiting less, we can add the -X option:

curl -L https://www.levysoft.it/ | less -RX

The -X option prevents less from using the terminal initialization and restoration sequences, generally allowing the displayed content to remain visible after the program closes.

Alternatively, you can replace curl -L with curl -fsSL: the -s option hides the transfer progress meter, -S keeps error messages visible, -f makes cURL fail on HTTP error responses such as 404 and 500, normally without displaying their response bodies, while -L, as explained earlier, automatically follows redirects.

curl -fsSL https://www.levysoft.it/ | less -RX

Ultimately, this command makes reading long articles from the terminal much more convenient for me: I can take my time, quickly search for the passages I am interested in, and preserve WP Curl Terminal’s ANSI colors without having to deal with uninterpreted control sequences.

The Same URL, Different Ways to Read

One feature I wanted to preserve from nytpu’s experiment was the ability to explicitly request the original HTML version. By using:

curl -L -H "X-Original: true" https://www.levysoft.it/

the plugin allows WordPress to return the normal web page. The same result can be obtained by specifying Accept: text/html, while the ANSI version can be explicitly requested using Accept: text/x-ansi, regardless of automatic client detection. A plain-text version without color sequences is also available by running:

curl -L 'https://www.levysoft.it/?terminal=plain'

which is useful when reading the output in an environment that does not interpret ANSI codes.

I also added more refined formatting, several color schemes, and text-based navigation that makes it possible to access articles, categories, and search results. The plugin also supports WordPress archives.

When a nonexistent URL is requested, WP Curl Terminal also returns a 404 error message formatted for the terminal.

Another feature I particularly cared about was the ASCII logo, which I initially created specifically for Levysoft, but which would have been a problem for anyone wanting to use the plugin on their own blog. I therefore introduced a system that automatically generates the banner from the website title configured in WordPress, adapting it to an ASCII representation and using a simpler heading when the name is too long or contains unsupported characters. This way, every installation has its own identity, without requiring any changes to the PHP code.

Plugin Settings

Everything is configurable through a settings page in WordPress, where you can enable automatic curl detection, choose the color scheme, specify how many posts to display on the homepage, and decide whether to show full URLs. Preferences are stored in the WordPress options table using a single record identified as wct_settings, allowing them to be preserved during updates and plugin deactivation.

I also implemented an uninstallation procedure through uninstall.php: when the plugin is deleted from the WordPress administration panel, its settings are removed from the database, preventing unused data from being left behind. The procedure also takes multisite installations into account, where options may belong to multiple websites within the same WordPress network.

To make WP Curl Terminal usable beyond Levysoft, I introduced multilingual support, initially for Italian and English, taking advantage of WordPress’s built-in internationalization system. English is the plugin’s original language, while Italian translations are distributed through the standard .po and .mo files, accompanied by a .pot file that can be used as a template for additional translations. Interface strings are handled through native WordPress functions and the wp-curl-terminal text domain, so the language is selected automatically according to the WordPress installation's language settings, without requiring a separate language selector in the plugin settings. Translation covers the administration panel, messages, headings, and navigation instructions displayed in the terminal; article titles and content naturally remain in the language in which they were published. I chose this approach also to allow other developers to contribute additional translations without modifying the PHP logic directly.

From a technical standpoint, the plugin uses the standard WordPress mechanisms to select the appropriate response template, without modifying theme files or .htaccess rules. It does not create permanent copies of articles or require additional database tables: the text-based representation is generated when the request is received. I also implemented HTTP headers to distinguish responses intended for different clients and limit their caching. This aspect still requires attention when using CDNs or server-level caching systems, because a cache that intercepts requests before WordPress executes could return the wrong version of the page.

Using the terminal does not provide remote access to the machine hosting the website. curl remains a normal HTTP client and receives only a response generated by the server; there is no interactive session in which a visitor can execute commands. The usual security considerations for any PHP plugin still apply, from verifying which content is publicly accessible to controlling automated requests, which is particularly important on shared hosting.

Plugin Download and Source Code

I decided to release WP Curl Terminal as an open-source plugin, so it can also be installed on other WordPress blogs. The plugin is independent of the website’s name, automatically generates its own ASCII logo, and includes Italian and English translations. It does not require any special server configuration and is compatible with WordPress 6.0 or later and PHP 7.4 or later.

For anyone who wants to try it, I have prepared a ready-to-install ZIP package, which can be downloaded directly here: wp-curl-terminal-v1.2.1.zip.

Simply open the WordPress administration panel, go to Plugins → Add New Plugin → Upload Plugin, select the downloaded file, and activate it. The options are available under Settings → Curl Terminal, which can also be accessed through the direct link in the list of installed plugins.

I have also published the source code on GitHub, together with documentation in Italian and English, translation files, and instructions for using the plugin. The latest available version can be downloaded from the Releases section, while anyone wishing to contribute to development or report problems can do so directly through the repository.

The project is distributed under the GPL-2.0-or-later license. As with the other plugins I have developed for Levysoft, I also made sure that settings are removed from the database when the plugin is permanently deleted from WordPress, so that no unused data remains after uninstallation.

Conclusion

The discussion on Hacker News also introduced me to other interpretations of the same idea. Some developers have created curl-compatible pages using only static files and ANSI sequences that take advantage of the terminal’s alternate screen buffers, achieving similar results even on services such as GitHub Pages, where PHP code cannot be executed. Others prefer to make their content available in Markdown through the HTTP Accept header, making it easily readable by programs that do not use a browser. These are different approaches, all based on the possibility of delivering the same content in representations suited to different tools.

For me, WP Curl Terminal was born primarily out of curiosity about whether Alex’s experiment could be reproduced on an existing WordPress installation, without changing the infrastructure or maintaining two separate versions of the blog. The answer was yes: Levysoft continues to work normally in browsers, while terminal users can explore its articles through a dedicated interface, one that is more streamlined and closer to the style of old text-based services. Making the plugin independent of the website’s name and language also allows me to share it with other WordPress bloggers who want to experiment with the same way of accessing content, even on ordinary shared hosting.

The experiment also gave me an opportunity to revisit an aspect of the Web that we tend to take for granted: HTTP allows content to be separated from its representation, and a single URL can be useful to very different kinds of programs. In Levysoft’s case, I used this capability to add a small alternative interface to the blog, which I intend to keep using, if only for the pleasure of being able to read my own articles directly from a Terminal window.

Originally published at https://www.levysoft.it.

For some time now, I’ve been interested in exploring an aspect of music production that is becoming particularly fascinating with the growing popularity of generative AI tools: the possibility of recovering an editable musical representation from an audio recording. Today, we can generate a composition, modify its sound, create arrangements, and produce a complete audio track without necessarily writing down individual notes. The problem arises when we want to reverse the process, perhaps because we like a melody and would like to learn to play it on the piano, modify its chords, or study its structure. An MP3 file contains the audible result of a performance, but it does not explicitly preserve which notes were played, how long they lasted, or how they were distributed among different instruments. It was precisely this transformation, from audio to its musical representation, that led me to explore AnthemScore 6, an application developed by Lunaverus that uses AI models to recognize the notes in a recording and reconstruct them as sheet music, MIDI, or MusicXML.

How Music Transcription Works

AnthemScore is available for Windows, macOS, and Linux and can analyze recordings in the most common formats, including MP3, WAV, FLAC, and OGG. The application can run locally on your computer, without requiring you to upload songs to a remote service, a valuable feature when working with personal compositions or unreleased material.

After importing a file, the program analyzes the audio content and represents its frequencies through a spectrogram, a visualization in which the horizontal axis represents time, the vertical axis represents frequency, and signal intensity is indicated by color.

The recognized notes are overlaid on this representation, where they can be added, deleted, moved, or adjusted in duration.

The advantage is that you can continuously compare what the program has identified with what is actually present in the recording, listening to the original track, the reconstructed notes, or both simultaneously.

The technical principle behind note recognition is particularly interesting and is clearly explained in an in-depth article published by the developer in 2016: music transcription was described as a problem similar to image recognition, because a spectrogram contains visual patterns corresponding to the fundamental frequencies and harmonics produced by musical instruments. A convolutional neural network can learn to recognize these patterns and associate them with specific musical pitches, even when multiple notes are played simultaneously.

The architecture described at the time had been trained using approximately 2.5 million examples derived from 3,000 MIDI files, which were synthesized into audio to obtain training data with known reference notes.

There is also an additional challenge related to the physics of sound. When a piano plays middle C, the string produces a fundamental frequency of approximately 261.6 Hz, along with a series of harmonics, including frequencies close to 523.3 Hz and 784.9 Hz. Some of these coincide with the fundamental frequencies of other musical notes: a recognition system must therefore avoid interpreting every spectral peak as a note that was actually played. The situation becomes more complicated when chords, reverb, sustain pedal, overlapping instruments, or compressed recordings are involved. Two notes may share some of their harmonics, while the lingering sound of a previous note may still be present even after the musician has changed chords. The fact that AnthemScore displays the spectrogram during editing makes this problem at least possible to inspect, allowing musicians to intervene when the results are uncertain.

With the release of AnthemScore 6 in May 2026, Lunaverus introduced a new note recognition model, continuing its efforts to improve the musical transcription algorithms. Subsequent updates also focused on reconstructing the musical structure of a piece: version 6.2, released in September 2026, introduced a new neural network for detecting beats, bar boundaries, and time signatures, while version 6.3 improved melody recognition, rhythmic note alignment, and the distribution of piano parts.

Lunaverus has not yet published a technical explanation of its current neural network architectures as detailed as the one from 2016, but the version history shows how development has increasingly focused on the quality of musical notation, which is essential for turning recognized notes into a genuinely readable score. The Lunaverus team has also confirmed to me that a further improvement in melody recognition is planned, although they have not yet provided a specific release date.

From Suno to AnthemScore: The Desire to Play and Preserve Your Own Creations

One of the creative activities I’ve particularly enjoyed recently is making songs with Suno, experimenting with lyrics, musical genres, arrangements, and increasingly precise prompts. I often get compositions that surprise me with the quality of their melodies, chord progressions, or certain instrumental passages, to the point where I want not only to listen to them again but also to play them myself on the piano and preserve them as sheet music. This is exactly what led me to AnthemScore: I want to recover the musical structure of my creations, ideally through a solo piano arrangement that preserves the main melody, harmony, and rhythmic characteristics while removing unnecessary elements of the original arrangement.

With Suno, I can try to achieve this through the Cover feature, asking it to reinterpret an existing song using an acoustic piano, without vocals, percussion, or other instruments, while attempting to preserve the original melody and chord progression. Prompts can also be used to discourage virtuoso passages, ornaments, complex chords, and excessively fast sections, particularly when the goal is to produce a recording that can be transcribed easily. For example, to isolate a simple melodic line, I use instructions such as these:

solo piano melody, clean acoustic grand piano, right hand melody only, monophonic melody, single notes only, one note at a time, no chords, no harmony, no accompaniment, no left hand, no bass notes, no arpeggios, no ornaments, no improvisation, beginner friendly, easy to play, simple melodic phrases, 120 BPM, fixed tempo, strict metronome, 4/4 time signature, quantized notes, constant velocity, precise note timing, clear note separation, no overlapping notes, no sustain pedal, no reverb, no delay, no effects, no background noise, no other instruments, no percussion, MIDI compatible, easy MIDI transcription

The Exclude feature allows you to specify additional elements to leave out, although the result remains probabilistic: Suno may change some notes, introduce harmonic variations, or alter the rhythm, making it necessary to compare different versions to identify the most faithful one. An alternative is stem extraction, which separates individual audio components such as vocals, drums, bass, and keyboards. This solution is useful when a song already contains an interesting piano part, but isolating an instrument is not the same as reducing an entire arrangement to piano: if the main melody is carried by the vocals, for example, it may not appear in the keyboard track. In that case, a musical reinterpretation is needed to transfer the vocal melody to the piano and reorganize the accompaniment.

You can also start completely from scratch, asking Suno to compose a piano piece specifically designed for someone learning to play. In this case, the prompt can specify duration, tempo, technical difficulty, and how the notes should be distributed between the hands: for example, a composition lasting approximately 30 seconds, between 65 and 75 BPM, with a simple melody played mainly by the right hand and a left-hand accompaniment limited to a few bass notes, avoiding complex chords, arpeggios, and excessively wide intervals. These are, of course, approximate guidelines that Suno is not guaranteed to follow precisely. One prompt I use for this type of experiment is the following:

Compose a beautiful 30-second solo piano piece, catchy and engaging, specifically designed for an absolute beginner. Slow tempo (65–75 BPM), simple and memorable melody, mainly single notes played with the right hand, very easy left-hand accompaniment with occasional single bass notes. Use only a few notes, small intervals, simple rhythms, and no fast passages, complex chords, arpeggios, or difficult techniques. Make the melody immediately recognizable, sweet, playful, and emotionally engaging. Clear pauses between phrases, gentle dynamics, and a satisfying ending. Acoustic piano only, no vocals, no other instruments.

Once I have a satisfactory recording, AnthemScore 6 comes into play: the goal is to recognize the notes actually played, their durations, the musical tempo, and their distribution between the right and left hands, while limiting manual work to the corrections that are truly necessary. Through the MusicXML format, I can transfer the score to MuseScore, refine the notation, key signature, and measures until I obtain a printable PDF, while MIDI allows me to edit individual notes or play them using other virtual pianos. Having an editable score also means being able to study difficult passages, slow them down, and simplify chords when the generated composition turns out to be more challenging than expected. AnthemScore also offers different arrangement levels that can make a piece more accessible without excessively compromising its recognizability.

I’m also interested in building a personal collection of sheet music from my most successful compositions, preserving the PDF, MIDI, MusicXML, and perhaps the original recording for each one. An audio file documents a particular performance, while a corrected score allows the same composition to be studied, reinterpreted, and played using different instruments. What I particularly like is the idea of printing a melody that originated from a prompt, placing it on the music stand, and trying to perform it myself, without depending on the recording generated by Suno.

It is worth noting that Suno Studio 2.0 already supports converting audio tracks into MIDI, but this feature is reserved for Premier subscribers. Suno Pro users, on the other hand, can export recordings in WAV format and extract stems, then rely on AnthemScore for transcription to obtain MIDI, MusicXML, and PDF files without subscribing to the higher-tier plan. It would be interesting to compare the results of the two systems in the future, evaluating which one recognizes notes more accurately, preserves their rhythmic structure, and requires fewer corrections to produce a readable score. For now, I want to understand how much AnthemScore can help me transform compositions created with Suno into musical material that I can study and preserve, knowing that sustain pedal, complex chords, and expressive variations may still require manual adjustments.

Putting AnthemScore 6 to the Test: From MP3 to Sheet Music

To put AnthemScore 6 to the test, I decided to start with a piano composition created specifically with Suno, titled Little Keys, Big Dreams, with the intention of producing a simple, pleasant melody that could ideally be played even by someone learning the piano.

Listen to: Little Keys, Big Dreams

The result was an MP3 recording lasting approximately 56 seconds, which I initially opened in ocenaudio to examine its waveform and overall structure.

At this stage, I was mainly interested in using the recording exactly as it had been generated, without manually reconstructing the notes or making preliminary changes to the musical content, to see what AnthemScore could produce from the audio alone.

The first step in AnthemScore is quite straightforward: using the Open command, you select the file to analyze and access a window where you can choose whether to process the entire song or only a specific time interval, defining its start and end points.

This option can be useful with particularly long recordings or when you only want to transcribe a specific passage, avoiding unnecessary use of memory and processing power. The same window contains three processing options: Find Notes, which starts musical note recognition; Automatic Instrument Detection, which attempts to distinguish the different instrumental components in the recording; and Percussion Detection, dedicated to identifying rhythmic sounds such as kick drums, snares, and cymbals. In my case, since I was working with a solo piano piece, I selected the entire song and left only note recognition enabled. For recordings containing multiple instruments, the other two options can help organize the recognized material into separate parts, although their effectiveness depends on the complexity and quality of the original audio signal.

Processing is performed using the computer’s own resources, and the time required depends on the length of the recording, the complexity of the audio content, and the analyses being performed. For a short piano piece like the one chosen for this test, processing is relatively manageable, while longer recordings or particularly complex arrangements may require more processing time and computing resources.

Once processing is complete, AnthemScore presents a rather technical interface, which at first glance may resemble a MIDI editor but actually contains much more information.

The central area of the window is occupied by the spectrogram, with time arranged horizontally and frequencies organized vertically according to a musical scale. On the left is a piano keyboard that makes it easy to associate each vertical position with a specific pitch. The colored regions show the energy present at different frequencies: in the Rainbow color palette used during my test, the display ranges from blue shades in less intense areas to brighter colors corresponding to more prominent sound components. Over this representation, AnthemScore places the notes identified by the algorithm, displaying them as horizontal bars that indicate pitch, starting time, and duration.

This overlay is one of the features I find most interesting about the program because it allows you to observe the audio signal and its musical interpretation at the same time. A bright line in the spectrogram may correspond to the fundamental frequency of a note, but it could also represent one of its harmonics, and the system must determine which components correspond to musical events that were actually performed. In a piano piece, particularly when the sustain pedal is used or chords overlap, the frequencies of one note may remain present even after the next note begins. AnthemScore attempts to reconstruct these events, but still allows you to visually check where a note has been placed and whether its duration appears consistent with the recording. The vertical lines crossing the spectrogram represent the detected temporal structure, divided into beats and measures: this is the information the program uses to derive the rhythmic notation of the score.

On the left is a control panel that, when advanced mode is enabled, provides several tools for adjusting the results. The playback section allows you to listen to the original file, the reconstructed notes through a MIDI synthesizer, or both sources simultaneously. The latter mode is particularly useful because it makes it possible to directly compare the recording with the transcription, identifying missing notes or sounds that have been added incorrectly. You can change the playback speed without affecting pitch, adjust the volumes separately, and restrict playback to a selected region. You can also enable continuous repetition of a passage (Loop) by selecting a region of the spectrogram, choosing the appropriate playback mode, and activating the button identified by two circular arrows in the side panel. I find this especially useful for examining a difficult musical phrase: listening to it repeatedly while observing the spectrogram makes it easier to identify possible errors and understand where adjustments are needed. The selection can also be restricted to a specific frequency range, allowing you to use the Selected Frequencies option to focus, for example, on the lower register of the piano while reducing the higher-frequency components of the recording. These tools are reminiscent of those traditionally used for music transcription by ear, where slowing down, repeating, and isolating specific passages helps identify individual notes and reconstruct the musical structure.

The Editor section is divided into three modes, dedicated to notes, measures, and percussion respectively. In the first mode, you can work directly on the bars recognized by the system, adding a missing note, removing a nonexistent one, or changing its position and duration. Notes can also be selected in groups, copied, moved, or assigned to different instruments through note groups.

One of the most interesting controls is the slider that adjusts the note recognition threshold, allowing you to change how many musical events the program considers to be actually present in the audio. A threshold that is too permissive risks introducing nonexistent notes, perhaps interpreting some harmonics as independent sounds, while a threshold that is too restrictive may remove quieter notes, such as those in a softly played accompaniment. The program also allows this adjustment to be applied to a single selected region, avoiding unnecessary changes to the entire composition. According to the Lunaverus documentation, manually applied corrections can also be used to update the recognition of other notes, a feature that should be used carefully because it may affect musical events in different passages. Continuous comparison between the original audio and the reconstructed notes therefore becomes essential to determine whether the changes have actually improved the result.

In other words, this is not simply a matter of passively accepting a transcription produced by AI: AnthemScore provides an environment where the algorithm’s decisions can be examined and corrected directly, without having to immediately export the material to another application.

The second editor mode focuses on the metrical structure of the piece. Here, you can correct beat positions, measure boundaries, tempo, key signature, and time signature. In my example, AnthemScore detected a tempo of 66 BPM and a 4/4 time signature, values that also appear at the beginning of the generated score. The interface allows you to manually move the beat lines if they do not match the performance and choose the grid resolution, including fine subdivisions such as thirty-second notes. Controls are also available for editing chords, which can be recognized automatically and then corrected or entered manually.

This is an important step because a transcription may contain the correct notes but still be difficult to read if their onsets are associated with the wrong beats, or if small expressive variations are interpreted as unnecessarily complicated rhythmic figures. A pianist, for example, may play a note slightly early, delay a chord, or use rubato, freely modifying the duration of musical phrases. These variations are part of the interpretation, but they do not always need to be reproduced literally on the staff. AnthemScore allows you to adjust the timing grid and quantization, the process of rounding musical events to regular rhythmic subdivisions, to obtain a more organized representation when the goal is to produce sheet music that can be read and played.

The third mode, identified by a drum icon, is dedicated to percussion and allows you to edit recognized rhythmic events, such as kick drum, snare, or cymbal hits. Using the musical grid, you can add or remove individual hits, select and copy entire rhythmic sequences, and adjust their intensity through a MIDI velocity value ranging from 0 to 127.

Unlike melodic notes, percussion events occupy a single position on the grid, while their rhythmic value in the score is derived from the distance between hits. In my case, since I was working with a solo piano composition, I had disabled percussion recognition during import, which is why the corresponding panel contained no elements to edit.

Another panel allows you to configure the spectrogram display, adjusting its horizontal and vertical scales, intensity levels, and overlaid information. You can show or hide various graphical elements to focus, depending on your needs, either on the signal frequencies or on the notes already recognized. The choice of color palette can also help distinguish certain sound components, especially in passages where several notes overlap. These are controls that someone who simply wants to generate a PDF quickly will probably use very little, but they become useful when checking a complex transcription and comparing the algorithm’s decisions with the actual content of the recording.

From Recognized Notes to a Musical Score

Once you are satisfied with the recognition results, you can open the sheet music in the built-in viewer. In the case of Little Keys, Big Dreams, AnthemScore generated a piano score organized on two staves, one primarily intended for the right hand and the other for the left, using treble and bass clefs. At the beginning, the score shows a 4/4 time signature and a tempo of 66 BPM, while chord symbols are also displayed above the measures.

In the opening measures, for example, the program identified a harmonic progression including F (F major), G7 (G dominant seventh), Em7 (E minor seventh), Am7 (A minor seventh), and Dm7 (D minor seventh), followed by chords such as Csus4 and Gsus4, respectively C and G with a suspended fourth. The symbols follow international chord notation, in which the letters A through G identify the musical notes, while additional symbols indicate specific chord characteristics: the letter m identifies a minor chord, the number 7 indicates the presence of a seventh, and sus4 means that the third has been replaced by the fourth. Suspended chords have a distinctive sound because, without the third, they are neither strictly major nor minor.

It is interesting to see how a recording initially available only as an MP3 can be transformed into a musical document containing notes, rests, durations, measures, and harmonic information, although its accuracy still needs to be checked against the original audio. The result thus becomes a usable representation for studying the composition, even if the quality of the transcription must be evaluated by comparing the score with what is actually played in the recording.

The viewer does more than display a static page. At the bottom, there are controls for playing the composition, adjusting the speed, and choosing whether to listen to the reconstructed score, the original recording, or both versions.

During playback, a vertical line follows the progress of the piece, and measures can be highlighted as they are played. You can select a specific section of the score, as I did with the eighth measure, to focus on a passage without having to restart from the beginning each time.

The repeat button allows you to listen to the same fragment several times, which is useful both for identifying possible errors and for practicing individual phrases on the piano.

The viewer settings also allow you to show or hide chord symbols, adjust the zoom level, and choose between US Letter and A4 page formats, the latter being more suitable for everyday printing in Italy.

Looking at the resulting score, another important aspect becomes apparent: although the piece was intended to be an accessible piano composition, the notation contains some passages with closely spaced groups of notes, ties, and rhythmic subdivisions that require careful reading. This does not necessarily mean that AnthemScore recognized the wrong notes, because the version generated by Suno itself may contain more elaborate passages than those requested in the prompt. However, it clearly demonstrates the importance of distinguishing musical content recognition from its graphical organization: a sequence of notes may be accurate in relation to the audio and still be awkward to read or perform. This is why correction, quantization, and arrangement simplification features play an important role in transforming an automatic transcription into sheet music suitable for practice.

Exporting, Instruments, and Available Formats

Which Format Should You Choose: PDF, MIDI, or MusicXML?

AnthemScore allows you to export the results directly in PDF, MIDI, and MusicXML formats, which are also available through the viewer’s Download button.

The distinction matters because each format preserves different information. A PDF contains the graphical representation of the score, suitable for reading, printing, and studying, but it does not allow you to edit individual notes directly as you would in a music editor. MIDI stores musical events, including note pitch, duration, velocity, and starting time, and can be imported into a DAW such as Logic Pro or GarageBand to modify the arrangement, change sounds, or use different virtual instruments. MusicXML, on the other hand, describes the musical score through measures, rests, rhythmic values, clefs, and ties, allowing you to continue working on the notation in applications such as MuseScore Studio or Sibelius.

The problem arises when you want to transform a musical performance into an easily readable score: a pianist may play some notes slightly early or late to make the melody more expressive, but reproducing these variations exactly on the staff can make the notation unnecessarily complicated. This is why quantization is useful, as it aligns notes to a regular rhythmic grid without necessarily changing the character of the piece. If the goal is to study a composition on the piano, it is therefore advisable to export the score in MusicXML, refine it if necessary with MuseScore Studio, and save it as a PDF for printing. MIDI remains useful for editing or playing notes through virtual instruments.

The desktop application’s export menu also includes a CSV format containing timing information about beats and notes, which may be interesting for anyone wishing to analyze the results programmatically or compare them with a reference MIDI file.

Customizing the Score and Instruments

The export window offers several customization options, starting with the choice of which musical parts to include, distinguishing pitched notes from percussion and configuring the organization of instruments and staves.

In my example, AnthemScore identified three note groups, which I was able to assign to the same instrumental part, the piano, specifying for each group whether the notes should be placed on the treble staff, the bass staff, or both. Note groups represent editable collections of musical events, while parts correspond to the instruments that will appear in the final score: for a piano, it is therefore possible to use multiple groups while maintaining a single two-staff part, correcting the distribution of notes between the hands when necessary. With more complex recordings, the same system allows you to organize separate instrumental parts and assign different MIDI sounds to them.

You can also assign a title to the composition, remove empty measures at the beginning and end, include chord symbols, and transpose the piece by a specified number of semitones or octaves. Transposition can be useful for adapting a melody to a more comfortable key or correcting differences in register.

Arrangements for Beginners and Advanced Players

One feature I find particularly interesting is the possibility of choosing different arrangement levels, adapting the complexity of the score to the performer’s abilities. For this test, I initially used 4. Advanced Version, but AnthemScore also allows you to generate simpler arrangements or keep the Original mode, without applying the changes introduced by the simplification feature. According to the Lunaverus documentation, the Beginner version applies the most substantial simplifications, while the Advanced version tends to preserve more of the original material.

This feature is particularly interesting to me when thinking about compositions created with Suno, because simplifying a score is different from transcribing it faithfully. Transcription should reconstruct the notes actually present in the recording, while an arrangement can intentionally modify their distribution and complexity to make the piece more accessible. For my purposes, I would therefore prefer to obtain a representation that is as faithful as possible to the original composition first, and then adapt it to my piano-playing abilities when necessary.

In this infographic, I summarized the main differences between the beginner and advanced arrangements of Little Keys, Big Dreams, showing how the complexity of the piano writing changes:

In the beginner version, the accompaniment is more essential, with less movement in the left hand, more sustained chords, and a lower density of notes in several passages. The advanced arrangement, on the other hand, retains more elaborate writing, with a more developed accompaniment and a richer distribution of notes. The main melody and chord progression remain recognizable in both versions, while the amount of work required from the pianist changes. The comparison therefore shows how simplification can make a composition more accessible without necessarily compromising its essential musical elements.

Saving the Project and Refining the Score

The work does not necessarily have to end with exporting. AnthemScore also allows you to save the project in its native ASDT format, preserving the information needed to reopen the transcription and continue editing it later. This is useful when working on complex recordings or preparing multiple versions of the same piece, keeping the working project separate from the final scores.

However, it is important to remember that AnthemScore does not completely replace a professional music notation editor. The official documentation explains that vocal melody recognition covers sung notes but does not include automatic transcription of lyrics, just as dynamic markings such as piano, forte, or crescendo are not added automatically. To complete these elements, adjust the page layout, or define specific musical articulations, the most practical workflow remains exporting to MusicXML and making further changes in a dedicated application.

Another documented limitation concerns recordings that do not use standard tuning with A at 440 Hz: in these cases, Lunaverus recommends correcting the pitch beforehand with an external tool such as Audacity, preventing an overall tuning difference from compromising note recognition.

Preferences, Performance, and Privacy

The Preferences panel also provides several useful controls for adapting AnthemScore to your needs.

You can set the default save folder, choose whether to open sheet music in the built-in viewer or an external application, define the paper format, and customize mouse button behavior. You can also choose how notes are named, switching between international A, B, C notation and Italian Do, Re, Mi notation, and configure the MIDI velocity of new notes, using a fixed intensity or allowing the program to manage it automatically.

Regarding performance, AnthemScore allows you to specify how many processor cores to use during processing. On my Mac, the panel shows 12 available cores, with a slider that allows me to reduce the number to limit resource usage. This is particularly useful when transcribing long recordings or when you want to continue using other applications, considering that greater parallelism may also require more memory.

I also found the presence of several privacy and diagnostic settings interesting. The program can check for and install updates, automatically send error reports, and share usage information to help improve the software. There is also a separate option that authorizes the upload of edits and the song’s audio to improve transcription accuracy. In the configuration shown during my test, this feature is disabled, a choice I prefer to maintain when working with personal compositions. It is an important detail for anyone using original or unreleased material, especially since the desktop edition with a perpetual license allows files to be processed locally, without necessarily uploading them to an online service.

Final Thoughts

My test with Little Keys, Big Dreams allowed me to start from a simple MP3 generated with Suno and arrive at an editable piano score, complete with notes, measures, and chords. This is precisely what I find most interesting about AnthemScore 6: the ability to recover the musical structure of a recording and transform it into material that can be read, edited, and played, even when the original sheet music is unavailable.

There are many possible applications, and they are not limited to AI-generated music. I think of someone who would like to learn to play a melody heard in a recording on the piano, a musician who wants to analyze a particularly interesting passage, a teacher preparing educational material, or someone who has old recordings of their own compositions and would finally like to recover a written version of them. The ability to export the results in MIDI and MusicXML further expands these possibilities, allowing the material to be reworked with other musical tools.

Of course, automatic transcription does not mean obtaining a perfect score that is immediately ready to perform: especially with complex recordings, overlapping instruments, or highly expressive performances, it is still necessary to check the recognized notes and refine the notation. But it is precisely in the combination of automatic recognition and manual intervention that AnthemScore demonstrates its usefulness, providing a concrete starting point for work that might otherwise take a great deal of time. For me, it also represents a way to give a second life to compositions created with Suno, bringing them beyond the audio file and transforming them into music that I can study, preserve, and try to play myself.

Where to Get the App

AnthemScore 6 is developed by Lunaverus and is available for macOS, Windows, and Linux, downloadable directly from the official website, without going through the respective platform stores. The desktop version is distributed with a perpetual license, purchased through a one-time payment, and comes in three editions, as detailed in the official feature comparison:

• AnthemScore 6 Lite, priced at $29, allows you to transcribe an unlimited number of complete songs, view sheet music, and save or print it as a PDF. It does not include advanced note editing tools or MIDI and MusicXML export.
• AnthemScore 6 Professional, priced at $39, adds all editing features, playback controls, and export to PDF, MIDI, MusicXML, and ASDT formats. It is probably the most interesting edition for anyone who wants to transform an audio recording into musical material that can be edited and played.
• AnthemScore 6 Studio, priced at $99, includes all Professional features, adding batch processing of multiple recordings and free lifetime updates, including future major versions. This is the edition that Lunaverus kindly provided me with for this review.

The official edition comparison does not indicate any differences in the accuracy of the recognition algorithms: the distinctions mainly concern editing and export tools, batch processing, and update policies. There is therefore no evidence to suggest that Studio produces more accurate transcriptions than Lite or Professional.

The desktop licensing model involves a one-time payment, with no recurring subscription. The Lite and Professional editions include one year of free updates, while Studio guarantees them for life. After the first year, Lite or Professional users can continue using the version they purchased at no additional cost or buy another period of updates. The license can initially be activated on four computers, with the possibility of adding one more for each full year elapsed since purchase. Prices are listed in US dollars and may vary depending on the currency and taxes applied at checkout.

A free trial version is also available, with no registration required, allowing users to explore the program and try the features of the different editions, with a limit of the first 30 seconds of each song and 100 transcriptions in total. This is a useful opportunity to evaluate the effectiveness of music recognition on your own recordings before purchasing a license.

On macOS, macOS 11 Big Sur or later is required; for Windows, installers are available for Windows 10 and 11, along with a separate package for Windows 7, while Linux users can download an AppImage version, officially tested on Ubuntu 20.04 and later. The program requires a 64-bit operating system and at least 4 GB of RAM, although more memory is recommended for recordings longer than three minutes. The perpetual license requires an Internet connection for initial activation, but afterward processing can take place entirely offline, without having to upload your compositions to external servers.

Alongside the desktop application, there is also AnthemScore Web, which can be used directly from a browser, including on smartphones and tablets, without installing any software. The free plan allows transcription of 30-second fragments and offers a 14-day trial for processing complete songs. The Plus plan starts at $8.33 per month when billed annually, includes 30 songs per month with a maximum duration of six minutes each, and supports PDF, MIDI, and MusicXML exports. The Pro plan starts at $24.99 per month when billed annually, increases the allowance to 100 songs per month with a maximum duration of ten minutes each, and also includes access to the desktop application for as long as the subscription remains active. In this case, unlike the perpetual license, the desktop program requires an Internet connection to perform transcriptions.

Choosing between the desktop and Web versions also involves considerations about the privacy of musical material. As specified in the Lunaverus privacy policy, the online service collects and stores uploaded content, including audio recordings, transcriptions, settings, and edits. The desktop application with a perpetual license, on the other hand, allows recordings to be processed locally, although some communications related to licensing, updates, and diagnostics are still supported, with settings available to disable certain data transfers. Anyone working with unpublished compositions or confidential recordings should consider this difference, especially when using AI-based music tools that normally require files to be uploaded to the cloud.

Personally, I find the possibility of purchasing a perpetual license and working directly on my own computer particularly appealing, as it allows me to retain control over my recordings and musical projects. For my purposes, which mainly involve recovering the notes of compositions created with Suno, correcting them, and exporting them as sheet music to study or preserve, the Professional edition probably represents the best balance between price and features, while Studio becomes interesting for those who process many songs or want to continue receiving all future versions without additional purchases.

Originally published on Levysoft .

For a while now, I’ve been noticing some rather peculiar translations produced by Google Chrome’s built-in webpage translation feature. It all started with the acronym LLM, which, instead of referring to a Large Language Model, was being interpreted as an academic qualification in law. At first, I thought it was just an amusing linguistic accident, but as I continued reading English-language articles and discussions through Chrome’s automatic translation, I began encountering increasingly strange results: some genuinely funny, others capable of changing the meaning of what I was reading.

To be fair, LL.M. is also the traditional abbreviation for Master of Laws, a postgraduate law degree, so the ambiguity is understandable. What makes these examples particularly interesting is that they appear on websites entirely devoted to AI, where the surrounding context should make the intended meaning reasonably obvious. And as I kept collecting examples, I realized the problem extended well beyond acronyms: company names were being replaced with other company names, technical terminology was being interpreted as everyday language, and concepts that should have remained distinct were sometimes merged into something entirely different.

Most of the examples I originally encountered involved translating English webpages into Italian. Since the mistranslations themselves are often in Italian, I’ll include their original wording where it matters and explain their meaning in English, so readers unfamiliar with Italian can appreciate what actually happened. I’ve also included links to all the original pages, allowing anyone to repeat the experiment using Chrome’s translation feature. The results may change over time as translation systems are updated, but the examples described here are based on the translations I observed.

When LLMs Become Law Graduates

The first example appeared in Colin Breck’s article, I Don’t Want to Read What You Didn’t Write, published on September 20, 2026. The original English sentence included the expression “the quality of writing from LLMs has plateaued”, but Chrome’s Italian translation referred instead to the writing quality of “laureati in giurisprudenza”, literally law graduates.

In the very same article, I encountered an even better example. The original sentence was:

Ask an LLM what the reliable formula is for falling in love.

Chrome translated it into Italian as:

Chiedete a un laureato in giurisprudenza qual è la formula infallibile per innamorarsi.

In English, that effectively means:

Ask a law graduate what the foolproof formula for falling in love is.

Apparently, a postgraduate degree in law now qualifies someone to explain the mysteries of romantic relationships. What makes this even more amusing is that the very next sentence begins with “In AI-generated writing”, so the intended context could hardly be clearer.

Once I started paying attention, I found other examples of the same confusion.

In a Hacker News discussion about arXiv and AI-generated academic papers, a commenter wrote that it was ironic how LLMs, which had benefited so much from reading older arXiv papers, were now being used to pollute the platform. Chrome interpreted those LLMs as “master in giurisprudenza (LLM)”, essentially turning the language models into people with postgraduate law degrees who were somehow responsible for polluting the scientific literature.

Another Hacker News discussion about Grammarly produced one of my favorite translations. The original comment read:

I loved Grammarly. But it has changed post LLM boom.

Chrome rendered this as:

Adoravo Grammarly. Ma è cambiato dopo il boom dei master in giurisprudenza.

Back in English, that becomes:

I loved Grammarly. But it changed after the boom in law master’s degrees.

An unexpected expansion of the legal education industry that I must somehow have missed.

The same problem appeared in a TechCrunch article about the America.gov chatbot. The author wrote “I don’t think an LLM will ever be able to write something ‘good’”, but Chrome produced an Italian sentence referring to “un master in giurisprudenza”, or a Master of Laws graduate, never being able to write something good. Once again, the article itself was explicitly about chatbots and AI-generated content.

Even No Sloptober, a website encouraging people to spend October without using LLM-based tools, wasn’t immune. Its phrase “Even if you find LLMs useful” became:

Anche se i Master in Diritto (LLM) si rivelano utili.

Which means something like:

Even if you find Master of Laws graduates useful.

In this particular example, Chrome didn’t simply choose the wrong meaning. It expanded the acronym into an academic qualification while keeping the original abbreviation in parentheses, as if it were helpfully explaining the terminology.

Three Different Meanings on the Same Page

Perhaps the most revealing example comes from a long discussion on the Haskell community forum, where Chrome encountered the acronym LLM several times within the same article and managed to interpret it in three completely different ways.

When the author discussed how LLMs can have very large context windows but still lose information, Chrome translated the acronym as “sistemi di gestione delle attività”, or task management systems. A little further down, a passage about the ethical concerns surrounding frontier LLMs operated by large technology companies turned them into “programmi di Master in Leadership di base”, roughly basic Master’s programs in Leadership. And when the author complained that LLMs were much worse at producing readable code than advertised, they suddenly became “software di modellazione lineare”, or linear modeling software.

All three interpretations appeared on the same page, which was explicitly discussing programming and AI.

This is particularly interesting because it suggests that Chrome wasn’t simply applying a fixed substitution such as LLM → Master of Laws. The acronym was being interpreted differently depending on the surrounding text, often with its supposed expanded form followed by the original abbreviation in parentheses.

There is actually a translation technique known as Parenthetical Terminology Translation, in which a translated or expanded technical term is accompanied by its original form to help readers recognize it. I haven’t found documentation confirming that Chrome uses this particular approach, but the way it expands acronyms while preserving the original abbreviation in parentheses looks remarkably similar.

The irony is that, in many of these cases, leaving LLM untranslated would have produced a more accurate result. The apparent attempt to clarify the terminology is precisely what introduces the error.

When Other Words Lose Their Meaning Too

The problem doesn’t stop with LLMs. As I continued collecting examples, I encountered similar mistakes involving ordinary English words, company names, and relatively recent technical expressions.

In TypeSafe AI’s article Introducing System One Models & Jev, the original sentence read:

Models have been superhuman at chat for years, so where is all the automation?

Chrome translated the beginning into Italian as:

Le modelle sono da anni superumane nelle chat…

Which effectively means:

Fashion models have been superhuman at chatting for years…

Here the ambiguity is different. The English word models can refer to mathematical or computational models, but also to people working in the fashion industry. Chrome chose the latter, and specifically the feminine form, even though the article discusses language models and software automation.

An even stranger example appeared in a Horizon AI newsletter covering Anthropic. In a report about a US court decision, Anthropic was translated as Anthropologie.

This is especially peculiar because Anthropologie isn’t a translation of Anthropic. It’s the name of an entirely different American company, a fashion and home goods retailer. In other words, Chrome replaced one company’s name with another company’s name, even though proper names generally shouldn’t require translation in this context.

Then there’s slop, a term that has become increasingly common in discussions about low-quality, mass-produced AI content. In a Hacker News comment, someone wrote:

Slop, if you hadn’t guessed by the .ai domain.

Chrome translated the first word as “Patatine”, which means potato chips in Italian. The resulting sentence effectively meant:

Potato chips, in case you hadn’t guessed from the .ai domain.

What makes this particularly entertaining is that the .ai domain was right there in the sentence. The term slop has also become mainstream enough for the American Dialect Society to select it as its 2025 Word of the Year, specifically noting its association with low-quality AI-generated content.

Some mistakes are more traditional. In a scientific article published by Springer, Chrome translated the standard academic heading Abstract as “Astratto”, the Italian adjective meaning abstract, rather than Riassunto (summary), Sintesi (synopsis), or, at a stretch, Estratto (excerpt). It could also have simply retained the term Abstract, which is commonly used in Italian academic publications. Given that the word appears as a section heading immediately after the title and authors, the structure of the page itself should make its intended meaning reasonably clear.

Finally, in a Hacker News discussion about Doory, an open-source alternative to Canva, a commenter wrote:

I’m pretty sure a good portion of Canva is vibe-coded too.

Chrome rendered this as:

Sono abbastanza sicuro che anche una buona parte di Canva sia caratterizzata da un’atmosfera particolare.

A back-translation would be:

I’m pretty sure a good portion of Canva has a particular atmosphere too.

Unfortunately, vibe-coded has nothing to do with the atmosphere of a product. In software development, vibe coding describes an approach in which developers rely heavily on AI to generate code from natural-language instructions. And the original discussion was explicitly about software development with Claude, making the mistranslation particularly revealing.

When Passkeys Become Passwords

One example that struck me as substantially more important came from the Substack article Passkeys are a trap. Do not use them, published on October 10, 2026.

The original title is perfectly straightforward, but Chrome translated it into Italian as:

Le password sono una trappola. Non usatele.

Which means:

Passwords are a trap. Do not use them.

At first glance, this may look like a simple terminology mix-up. But the article discusses passkeys as an alternative to traditional passwords and examines the implications of using them. These are distinct authentication concepts, so confusing the two changes the central message of the article.

I became curious about how widespread the problem was and decided to count the occurrences of both terms in the original English text and the Italian translation displayed by Chrome.

In the original English article, I counted 117 occurrences of “passkey” or “passkeys”, compared with just 30 in the Italian translation. Meanwhile, occurrences of “password” or “passwords” increased from 24 in the original to 88 in the translated version.

According to my counts, occurrences of passkey dropped by 87, while occurrences of password increased by 64. That leaves a difference of 23 occurrences between the two changes, which means we cannot automatically reconstruct every individual substitution. Some terms may have been omitted, rephrased, or translated differently, so these numbers should be treated as observations from the displayed text rather than a precise word-by-word mapping.

Still, the pattern is striking. The confusion wasn’t limited to the headline but appeared throughout the article, repeatedly blurring the distinction on which the author’s argument depended.

And this is where translation errors become considerably less amusing. If an LLM becomes a law graduate, most readers will probably recognize that something has gone wrong. But if passkeys quietly become passwords in an article about authentication security, the mistranslation may sound perfectly plausible to someone who isn’t already familiar with the technology.

I’m Not the Only One Seeing These Problems

After collecting these examples, I started wondering whether other people had noticed similar behavior. A little research led me to a Reddit discussion describing almost exactly the same problem, but involving a completely different target language.

On June 16, 2026, a user posted Google Translate is now silently changing meaning, not just mistranslating in r/googletranslate, describing translations that sounded fluent and convincing while substantially altering the original meaning.

Among the examples was one that could have come straight from my own collection.

According to the post, on April 28, 2026, the user encountered the English headline:

Google DeepMind paper argues LLMs will never be conscious

When translated into Russian through Chrome, the resulting meaning was essentially:

A Google DeepMind paper argues that people with a Master of Laws degree will never become conscious.

The resemblance to my English-to-Italian examples is remarkable. The very same collision between Large Language Model and Master of Laws was occurring in another language, in a headline explicitly mentioning Google DeepMind.

The user also reported another case in which “enhances LLM outputs by fetching external knowledge” was transformed into a description of improving learning in a master’s degree program by retrieving external information.

Other examples in the Reddit thread illustrate different kinds of semantic confusion. The technical expression “Concrete failure reproducer”, referring to a concrete example that reproduces a software failure, was interpreted as something resembling the reproduction of concrete destruction, as though concrete referred to the construction material rather than a specific or tangible example. Another translation reportedly changed an instruction about writing in Russian into one about writing in English. Additional users described similar meaning-altering substitutions in translations involving Japanese and German.

These are personal reports rather than independently reproduced experiments, but their significance lies in the similarity of the behavior: the resulting text isn’t necessarily grammatically broken or obviously nonsensical. Sometimes it reads perfectly naturally, and that’s precisely what makes the altered meaning difficult to notice.

I found another curious report in the GitHub repository fenxer/llm-things, a collection of LLM-related observations and oddities. The author notes that Google Translate has interpreted LLM as Master of Laws and PNG as Papua New Guinea when translating into Chinese, rather than recognizing the intended technical meanings of those acronyms.

Again, this is an anecdotal report rather than a systematic evaluation, but together with the Russian example and my Italian translations, it suggests that acronym ambiguity can surface across different language pairs. It doesn’t tell us how common these mistakes are, or whether they all have the same underlying cause, but it makes the phenomenon harder to dismiss as a peculiarity of Italian translation alone.

What Research Says About These Translation Errors

Perhaps the most interesting discovery is that the problem of translating technical acronyms is well known in machine translation research.

In September 2024, Richard Yue, John Ortega, and Kenneth Church published On Translating Technical Terminology: A Translation Workflow for Machine-Translated Acronyms at the AMTA conference. The study examines the difficulties machine translation systems encounter when recognizing and translating technical acronyms.

Focusing on French-to-English translation, the researchers found that acronym translation error rates could reach 50% under the conditions of their experiments, including evaluations involving systems such as Google Translate. That figure doesn’t mean Google Translate gets half of all acronyms wrong in general. It refers to the specific data and evaluation conditions used in the research.

The underlying problem is easy to understand: an acronym can have several legitimate expansions, and a translation system needs to determine which one matches the context. Knowing that LLM can mean Master of Laws isn't enough. In an article about ChatGPT, arXiv, or code generation, that interpretation is almost certainly inappropriate.

The researchers therefore proposed a translation workflow incorporating explicit acronym recognition and disambiguation, supported by external information retrieval, and reported improvements over their baseline systems.

Another relevant question is how much context a translation system actually considers when deciding what a word means.

In 2023, Christian Herold and Hermann Ney published Improving Long Context Document-Level Machine Translation, a study examining how machine translation systems can make better use of context across longer documents.

The researchers discuss the limitations of systems that rely on relatively small context windows, sometimes incorporating only one or two preceding sentences. While this may help resolve local ambiguities, it doesn’t necessarily provide enough information to preserve consistent terminology throughout an entire document.

Increasing the amount of context isn’t automatically a solution, either. It can introduce additional computational costs and, depending on the architecture and how that context is used, even degrade translation performance. The study explores ways to identify and exploit the most relevant contextual information without indiscriminately processing the entire document.

This immediately reminded me of the Haskell forum discussion, where the same acronym became a task management system, a leadership degree, and linear modeling software within a single page.

We don’t know whether Chrome’s translation system processes isolated sentences, paragraphs, or larger sections of text in these particular cases. But the observed behavior is consistent with the broader challenge of maintaining terminological coherence across a document, especially when individual words or acronyms have multiple possible meanings.

There is also another, related phenomenon worth considering: translations that introduce meanings substantially disconnected from their source material.

As early as 2018, Google researchers published Hallucinations in Neural Machine Translation, investigating how neural translation systems can generate apparently plausible output that isn’t adequately supported by the original text.

So the problem didn’t suddenly appear with today’s generative language models. Neural machine translation systems have been known to produce this kind of behavior for years.

It’s useful, however, to distinguish between disambiguation errors, where a system chooses a possible but contextually incorrect meaning, and hallucinations, where the translation introduces information that isn’t properly grounded in the source. Turning LLMs into law graduates is primarily a disambiguation problem, while some of the more drastic meaning changes reported by users may resemble the latter phenomenon.

None of these studies proves exactly why Chrome produced the particular errors I observed. What they do show is that the underlying difficulties are neither new nor trivial. Technical terminology, ambiguous acronyms, document-level consistency, and the relationship between linguistic fluency and factual fidelity have all been active research topics for years.

It’s Not Just About an Outdated Vocabulary

Looking at these examples together, I find it difficult to attribute everything to a translation model that simply hasn’t caught up with recent technological vocabulary.

That explanation might make sense for relatively new expressions such as vibe-coded or slop, but it becomes less convincing when dealing with established words such as models, the academic heading Abstract, or proper names like Anthropic.

The common thread seems to be the difficulty of selecting the appropriate meaning of a word based on its context, and sometimes recognizing when a term would be better left untranslated.

Research on acronym disambiguation and document-level translation offers possible explanations, but it wouldn’t be accurate to assume that any particular algorithm or model is responsible for the mistakes described here.

Google has used several generations of translation technology over the years, from statistical machine translation to neural systems and more recent language-model-based approaches. However, the output visible in Chrome doesn’t reveal exactly which model or internal component produced a particular translation, or whether the browser always uses the same translation pipeline as the standalone Google Translate service.

All the English-to-Italian examples in this article were observed using Google Chrome’s built-in webpage translation feature. I’ve included the original links so that readers can try the same translations themselves, although updates to the underlying systems may produce different results over time. The reports from other users should likewise be understood as individual observations rather than statistical evidence of how widespread the problem is.

Some of these errors are harmless enough to be entertaining. If an LLM becomes a law graduate, the absurdity is usually easy to spot. But when a passkey becomes a password in an article comparing the two technologies, or when a fluent translation silently changes an instruction or the meaning of a sentence, the consequences become considerably more interesting.

What struck me most as I continued collecting examples was how misleading a perfectly natural translation can be. We’re accustomed to thinking that machine translation errors reveal themselves through awkward grammar or bizarre wording, when sometimes the result reads smoothly, sounds entirely reasonable, and tells us something different from what the author originally wrote.

Still, I have to admit that my personal favorite remains the Italian translation of this sentence:

Ask an LLM what the reliable formula is for falling in love.

Which, according to Chrome, becomes:

Ask a law graduate what the foolproof formula for falling in love is.

Maybe Google Translate knows something we don’t. 😄

Adaptation note: This article is an English-language adaptation of an original piece written in Italian for Levysoft. Since most of the translation errors were originally observed while translating English webpages into Italian, I have included English explanations and back-translations where necessary to make the examples understandable to an English-speaking audience. The original observations, sources, and technical considerations have been preserved.

Originally published at Levysoft.

On October 2, 2026, Andrej Karpathy published a post based on a very simple prediction: we will spend more and more time trying to understand what language models produce. If an increasing share of our work is delegated to systems capable of writing code, analyzing documents, conducting research, and producing complex artifacts, part of our job inevitably shifts toward supervising and understanding those results. The first technique suggested by Karpathy focuses precisely on how we ask an LLM to write: try asking for an explanation in ASD-STE100, a controlled language originally developed for aerospace technical documentation. When the result becomes too rigid, he even suggests a curiously precise formulation: ask the model to go about “80% of the way to ASD-STE100”.

The idea made me think about how often we use an LLM by simply writing “explain this to me” or “explain it better”. These are very vague instructions, because better can mean simpler, shorter, more technical, more concrete, more visual, or better suited to our existing knowledge. In fact, there are many ways to specify the kind of explanation we want. Some come from education and learning research, others from science communication, and still others are simply conventions that emerged on the Internet and that language models have learned to interpret remarkably well. The difference becomes clear when we keep the subject unchanged and modify only the prompt.

I will use the same question throughout:

Explain the for loop in Python.

1. ASD-STE100: controlling the language first

ASD-STE100, or Simplified Technical English, is a controlled natural language, meaning a version of English governed by specific rules designed to reduce ambiguity and complexity. It originated in the late 1970s in aerospace documentation, when European airlines called for a form of technical English that would be easier for non-native speakers to understand. The first AECMA Simplified English Guide appeared in 1986, while in 2025, with Issue 9, ASD-STE100 became an international standard. The current version contains 53 writing rules along with a controlled dictionary.

The principle goes further than simply saying “use easy words”. When several synonyms exist, a single term is selected whenever possible. For example, STE uses start and excludes alternatives such as begin, commence, initiate, and originate. Word meanings are also controlled, so the same word generally has only one permitted meaning. The rules also govern syntax: active voice whenever possible, one instruction per sentence, procedural sentences of no more than 20 words, descriptive sentences of no more than 25 words, one topic per paragraph, and consistent terminology for the same object. Ultimately, the goal is to ensure that the same term retains the same meaning and that instructions are short, explicit, and difficult to misinterpret.

When applied to an LLM, the mechanism becomes immediately apparent. A Python explanation might look like this:

The for statement enables sequential iteration over the elements contained within a collection, making the current element available during each iteration.

Now imagine requesting a formulation inspired by ASD-STE100 with a prompt such as:

Explain the for loop in Python using a style that is approximately 80% inspired by ASD-STE100. Use short sentences, active voice, consistent terminology, and only one main idea per sentence.

The answer would take a form similar to this:

The for loop reads one element from the list. The code block uses that element. Then the loop reads the next element.

The technical information is almost identical, but in the second case the model has less freedom to hide a simple concept behind a more sophisticated linguistic construction. Compared with a generic answer, many unnecessary expressions disappear. The model consistently uses element instead of alternating between terms such as value, object, or component, and it makes clear who performs each operation.

However, we must distinguish writing inspired by ASD-STE100 from actual compliance with the standard. The Simplified Technical English Maintenance Group itself has published a document about the use of AI, warning that generated text may appear clear and consistent with STE while incorrectly applying its rules or vocabulary. An LLM receiving the prompt “write in ASD-STE100” can imitate many of its characteristics, but this does not amount to formal compliance verification. Karpathy’s suggested “80%” should be understood in exactly this sense: it is an informal stylistic request, not a measurable percentage of compliance with the standard.

There is another important detail for those who write in languages other than English: ASD-STE100 applies specifically to English. When we ask an LLM to “explain it in Italian using ASD-STE100”, we are actually asking it to transfer some of the standard’s principles, such as short sentences, consistent terminology, active voice, and reduced ambiguity. We are not producing “Italian ASD-STE100”. For a broader perspective, there is also ISO 24495–1:2023 Plain language, a standard applicable to most written languages that starts with the reader: information must be relevant, easy to find, understandable, and usable. It is a less prescriptive approach than STE and can be extremely useful when we want to make a text accessible without turning it into aerospace documentation.

2. ELI5: explain it like I’m five

Another widely known way to control an LLM’s response is ELI5, short for Explain Like I’m Five. The expression became popular mainly through Reddit and the r/explainlikeimfive subreddit. The name can be misleading: according to the community guidelines, the reference to being five years old is intended as a figure of speech. The goal is to produce an explanation accessible to non-specialists, avoiding unexplained technical terms and without assuming specialized knowledge.

The prompt becomes:

ELI5: explain the for loop in Python.

And it might produce:

Imagine having a box with five candies and wanting to look at each candy one at a time. The for loop tells Python: "Take the first candy and do something with it. Then take the second candy and do the same thing. Keep going until you have looked at all of them."

Here, the model almost completely abandons formal precision and builds a mental image first. The advantage is immediate accessibility, while the limitation is equally clear: a metaphor can help explain the general idea without actually explaining what iterables, iterators, or loop variables are.

3. ELI10 and ELI12: simple, but without going back to kindergarten

Variants such as ELI10, ELI12, and other intermediate ages have emerged naturally from ELI5. They are not educational standards with precise rules. Instead, they mainly serve as a quick way to indicate the desired level of complexity to the model. ELI10 is now also used by websites and tools that promise jargon-free explanations based on concrete examples and analogies, while ELI12 even appears as a mode for simplifying complex documents.

The prompt:

ELI10: explain the for loop in Python.

might produce:

A for loop is useful when you want to perform the same operation on multiple elements. If you have a list of names, Python can take one name at a time and run the same code for each one:

nomi = ["Anna", "Luca", "Marco"]for nome in nomi:    print(nome)

Python first takes "Anna", then "Luca", and finally "Marco".

The childish metaphor has already disappeared. Simple language remains, but actual code comes into play. For many technical subjects, ELI10 or ELI12 can be more useful than ELI5 precisely because they simplify the explanation without moving too far away from the real mechanism.

4. Feynman style: explaining to check whether we really understand

The so-called Feynman Technique operates on a different level. It is generally described as a process in which we try to explain a concept in simple words as if we were teaching it to someone else, identify the points where the explanation becomes vague, and return to studying those specific parts. The four-step version commonly shared today is a later formalization, not a method published by Richard Feynman under that name. However, its most interesting aspect has strong connections with research on self-explanation: a 2018 meta-analysis based on 64 studies found an average positive effect on learning (g = 0.55) when students were encouraged to generate explanations and conceptual connections.

The prompt can therefore become:

Explain the for loop in Python using the Feynman method. Use simple words. Then ask me to explain it back in my own words and identify anything I have not understood.

The answer might begin like this:

A for loop lets you take the elements of a collection one at a time and execute the same code for each one. If you have three names, Python takes the first one, executes the code block, takes the second one, and continues until the end.

Now it’s your turn: explain in your own words what happens when Python executes for nome in nomi:.

The difference compared with ELI5 is important: here, simplification is primarily used to verify understanding. The model should not merely explain something to us. It should help us discover where our own explanation stops making sense. When studying a subject, this approach can be more useful than passively reading a perfect explanation.

5. Step by step: seeing every step

Step by step simply means that we want to see the process broken down into its intermediate steps. It is particularly useful when the difficulty comes from an explanation skipping operations that are obvious to the author but not yet obvious to the reader.

Prompt:

Explain the for loop in Python step by step, without skipping any steps.

Response:

Consider for nome in ["Anna", "Luca", "Marco"].

1. Python finds the list.
2. It takes the first element, "Anna".
3. It assigns "Anna" to the variable nome.
4. It executes the code inside the loop.
5. It returns to the beginning of the loop.
6. It takes "Luca" and assigns it to nome.
7. It repeats the process.
8. After "Marco", it finds no more elements and ends the loop.

It is an elementary technique, but extremely effective for code, algorithms, mathematics, protocols, and operational procedures. It allows us to observe what would normally be compressed into a single sentence.

6. Beginner-friendly: starting without assuming prior knowledge

Beginner-friendly means asking the model not to take previous knowledge for granted. Compared with ELI5, it maintains an adult tone and can use technical terms, provided they are introduced when needed.

Prompt:

Explain the for loop in Python in a beginner-friendly way. Assume I only know variables and print().

Response:

A Python list can contain multiple values:

nomi = ["Anna", "Luca", "Marco"]

If you want to print all the names, you could write three print() statements. The for loop avoids this repetition:

for nome in nomi:    print(nome)

The variable nome holds each element of the list in turn.

Specifying what the reader already knows can be even more effective than simply writing “beginner-friendly”. For example, I am a PHP developer learning Python gives the model a much more precise starting point.

7. Explain with analogies: connecting something new to something familiar

Analogies attempt to explain a new concept by relating it to a structure we already know. Analogical learning has long been studied in cognitive psychology. It can help transfer relationships from a familiar domain to an unfamiliar one, provided the analogy is not confused with the actual phenomenon.

Prompt:

Explain the for loop in Python using an analogy from everyday life.

Response:

Imagine a mail carrier standing in front of a row of mailboxes. They go to the first mailbox, deliver the letter, move to the second one, and repeat the same operation. The list is the row of mailboxes, the for loop is the mail carrier moving from one mailbox to the next, and the code block is the operation performed for each mailbox.

A good prompt can also add tell me where the analogy stops working. This forces the model to separate the simplified mental model from the actual technical behavior.

8. Examples first: seeing before defining

With examples first, the usual order of an explanation is reversed. The model shows a concrete case first and introduces the theory only after we have seen the mechanism in action. This approach is related to research on worked examples, which has shown that, during the early stages of learning, following fully worked-out examples can reduce the cognitive effort required compared with immediately trying to solve a problem without an existing structure to follow.

Prompt:

Explain the for loop in Python using examples first. Show me an example before explaining the theory.

Response:

frutti = ["mela", "pera", "banana"]for frutto in frutti:    print(frutto)

The program prints:

melaperabanana

Now we can see what happened: for took one element of the list at a time, assigned it to the variable frutto, and executed print(frutto).

For people who learn programming by writing code, this order often feels more natural than the sequence of definition, syntax, exceptions, and example.

9. Visual explanation: turning a concept into space

We can ask the model for a visual explanation, meaning a representation in which position, connections, and movement make relationships visible. For some concepts, a visual representation can be more immediate than text alone, especially when we need to follow a sequence, observe relationships between elements, or understand how something changes over time.

Prompt:

Explain the for loop in Python using a very simple visual explanation.

Response:

["Anna", "Luca", "Marco"]    |    v  "Anna"  -> print("Anna")    |    v  "Luca"  -> print("Luca")    |    v "Marco"  -> print("Marco")    |    v   FINE

The for loop goes through the list from beginning to end. At each step, it assigns the current element to the variable and then executes the code block.

With an agent capable of creating files, we can go further and directly request an SVG diagram or a small HTML animation, moving toward one of the developments suggested by Karpathy.

10. Cheat sheet: keeping everything at a glance

A cheat sheet does not necessarily aim to teach a concept from scratch. Instead, it compresses the most important information into a format that can be consulted quickly. It is therefore particularly useful after we have already understood the basics.

Prompt:

Explain the for loop in Python as a cheat sheet.

Response:

Syntax

for elemento in sequenza:    istruzioni

List

for nome in nomi:    print(nome)

Range

for n in range(5):    print(n)

Stop the loop: break
Skip an iteration: continue
Index + value: enumerate()

The value of a cheat sheet lies in its information density and the ability to find something again in just a few seconds. It is more of a reference format than a teaching method.

11. TL;DR: just tell me what I need to know

TL;DR, short for Too Long; Didn’t Read, asks for the exact opposite of an in-depth explanation. Its purpose is to compress a topic into its central idea.

Prompt:

TL;DR: explain the for loop in Python.

Response:

for repeats a block of code once for each element in a sequence:

for nome in nomi:    print(nome)

In two lines, we have enough information to remember what for is used for, but not enough to learn it from scratch. A TL;DR works well for recalling a concept we already know or deciding whether it is worth exploring further.

12. Socratic style: make me think instead of giving me the answer

The Socratic method uses questions to reveal assumptions, contradictions, and logical steps. The tradition naturally goes back to Plato’s dialogues and the Socratic elenchus, in which a sequence of questions is used to test the consistency of answers.

Prompt:

Teach me the for loop in Python using Socratic style. Ask me one question at a time and do not give me the answer immediately.

The response might begin like this:

You have a list:

nomi = ["Anna", "Luca", "Marco"]

If you wanted to print all three names using only print(), how would you do it?

After our answer, the model might ask:

Do you notice anything that repeats across the three statements?

and only later introduce the for loop. In this mode, the model almost stops being an encyclopedia and takes on the role of a tutor.

13. Rubber Duck Debugging: explain it to the duck

Rubber Duck Debugging comes from the world of programming and became famous thanks to The Pragmatic Programmer: when a programmer cannot find a bug, they try explaining their code line by line to a rubber duck. The duck does not respond, and that is precisely part of the mechanism, because verbalizing what the program is supposed to do forces us to make explicit the steps and assumptions that remained implicit in our minds. Very often, the inconsistency becomes apparent while we are explaining it.

With an LLM, we can turn the rubber duck into a conversational partner that deliberately remains minimally intrusive.

Prompt:

Act as my rubber duck while I try to understand the for loop in Python. Do not explain it to me immediately. Let me describe what I think is happening, and intervene only when you find an error, a contradiction, or a step I have not verified.

The conversation might begin like this:

Me: I think for nome in nomi puts the entire list into nome.

LLM: If nome contained the entire list, what would you expect print(nome) to display during the first iteration?

Me: Probably the whole list.

LLM: Try comparing that prediction with what the program actually prints. If you get only "Anna", what can you conclude about the value of nome at that moment?

The difference compared with Socratic style is subtle but useful. In the Socratic method, the model actively constructs a sequence of questions to guide us toward the concept, while with the rubber duck, we are mainly the ones speaking and building the explanation. The model intervenes when something we say does not add up. This approach is particularly suitable for debugging, but it can also work when we want to verify the mental model we have built around a subject.

14. From zero to expert: gradually increasing the depth

From zero to expert asks for a layered explanation: first the essential mental model, then intermediate details, and finally advanced aspects. Instead of receiving all the complexity at once, we can explore the same topic through successive levels. In fact, complex material can be easier to process when divided into manageable segments rather than presented all at once.

Prompt:

Explain the for loop in Python from zero to expert. Start with the basics and progressively increase the depth.

The response might begin with:

Level 1: for repeats an operation over multiple elements.

Level 2: for can iterate over lists, tuples, strings, dictionaries, and other iterable objects.

Level 3: Python obtains an iterator by calling iter() on the object.

Level 4: At each iteration, Python conceptually calls next() on the iterator until StopIteration is raised.

Level 5: You can create custom iterable objects by implementing the iterator protocol or using generators.

The original question remains exactly the same, but the result provides a ladder that we can stop climbing once we have reached the necessary depth.

15. Progressive disclosure: showing complexity only when needed

Progressive disclosure originated mainly in interface design. Instead of immediately displaying every available feature and option, an interface initially presents only what is necessary and makes advanced details accessible when the user needs them. Applied to an explanation, the idea is similar: the model should not immediately dump everything it knows about a subject, but reveal complexity one level at a time.

Prompt:

Explain the for loop in Python using progressive disclosure. Initially show me only the essential concept. Introduce additional details only when I ask you to continue.

The first response might be:

The for loop is used to perform the same operation on multiple elements, one at a time.

for nome in nomi:    print(nome)

Here, Python takes one name at a time and prints it.

If we reply continue, the model might introduce range() and enumerate(). With another continue, it could explain break and continue, while iterables, iter(), next(), and StopIteration would appear only much later.

This may seem similar to from zero to expert, but the way we receive information changes. From zero to expert presents a complete progression already organized into levels, while progressive disclosure intentionally hides what we do not need yet. It is particularly useful with LLMs because it avoids those technically correct but overly dense responses in which an explanation of an elementary concept ends up dragging in an entire chapter of a manual.

16. No jargon: removing vocabulary that gets in the way

No jargon asks the model to avoid specialized terminology or define it immediately. It has something in common with ASD-STE100 and plain language, but it is much less structured: the request is mainly about vocabulary.

Prompt:

Explain the for loop in Python without technical jargon. If you need to use a technical term, explain it immediately.

Response:

A for loop allows Python to take a series of things one at a time and perform the same operation on each one. This series is often called a sequence, meaning a collection of values arranged in a specific order.

Here, we can still introduce the correct terminology while avoiding explanations that require readers to already know the vocabulary being used to explain the concept.

17. Technical deep dive: I want to know what happens underneath

Technical deep dive communicates the opposite intention: we want the model to use technical vocabulary and reveal the underlying mechanism. This approach is useful when simplification starts hiding precisely the details we are interested in.

Prompt:

Give me a technical deep dive into the for loop in Python. I already know the basic syntax and want to understand what happens internally.

Response:

Python’s for loop operates through the iterator protocol. Given:

for x in oggetto:    corpo

conceptually, the interpreter first obtains an iterator through:

iterator = iter(oggetto)

and then repeatedly calls:

x = next(iterator)

Iteration ends when next() raises StopIteration. An object can therefore be used in a for loop if it exposes the behavior required by the iteration protocol.

The same subject that involved candies in ELI5 now introduces iter(), next(), and StopIteration. The model's level of knowledge has not changed. We have simply changed which part of that knowledge we ask it to make visible.

18. Practical only: show me how to use it

With practical only, we tell the model that theory should be reduced to the bare minimum and that we mainly want to learn through concrete use.

Prompt:

Explain the for loop in Python using a practical-only approach. Keep theory to a minimum and immediately show me examples I can use.

Response:

Print all elements:

for nome in nomi:    print(nome)

Repeat something five times:

for i in range(5):    print("Ciao")

Get the position number as well:

for indice, nome in enumerate(nomi):    print(indice, nome)

Filter while looping:

for numero in numeri:    if numero > 10:        print(numero)

This kind of response is useful when our immediate goal is not to understand the iterator protocol, but to write a working program.

19. 80/20: the minimum that produces the maximum result

The reference here is the Pareto principle, according to which in many phenomena, a small proportion of causes is responsible for a much larger proportion of effects. The famous 80/20 ratio is an empirical rule rather than a universal law, so applying it to learning simply means asking which few concepts deliver most of the practical value.

Prompt:

Explain the for loop in Python using the 80/20 approach. Tell me the small set of things I need to know to use it effectively in most situations.

Response:

To use for in most programs, you only need four ideas.

for elemento in sequenza takes one element at a time.

for nome in nomi:    print(nome)

Use range() when you want to repeat something a certain number of times:

for i in range(10):    print(i)

Use enumerate() when you need both position and value:

for i, nome in enumerate(nomi):    print(i, nome)

Use break when you want to end the loop early.

The advantage over TL;DR is that we are not necessarily asking for the shortest possible answer. We are asking the model to select what provides the greatest practical benefit.

20. First principles: rebuilding the concept from its foundations

First principles reasoning attempts to break a problem down into its fundamental elements and rebuild the solution from those elements, initially avoiding analogies, conventions, or ready-made formulas. In a technical explanation, it is useful because it shifts the question from “how does this thing work?” to “what fundamental problem does it need to solve, and what are the minimum operations required to solve it?”.

Prompt:

Explain the for loop in Python starting from first principles. Break the problem down into fundamental operations and then reconstruct how the loop works.

The response might be:

We have a collection of values:

nomi = ["Anna", "Luca", "Marco"]

We want to perform the same operation on each value. We could do it manually:

print(nomi[0])print(nomi[1])print(nomi[2])

This solution works only if we know the number of elements in advance, and it requires us to repeat the same instruction manually.

We therefore need a mechanism that does three things: takes an element, performs an operation on that element, and moves to the next one.

Python expresses this mechanism with:

for nome in nomi:    print(nome)

The difference compared with step by step is significant. Step by step takes an existing mechanism and shows us, in order, what happens during its execution. First principles instead tries to reconstruct why that mechanism is needed, starting from the elementary problem it must solve. Once that necessity becomes clear, the syntax of for almost becomes the natural answer to the problem.

The same subject, twenty different explanations

At this point, it becomes clear why “explain it simply” is a rather weak prompt. These approaches can also be combined. For example:

Explain the for loop in Python to a beginner. Use English inspired by ASD-STE100 principles. Start with a concrete example, then explain it step by step. Use an analogy only if it genuinely helps. At the end, ask me to explain the concept back in my own words and correct any mistakes.

Here, we are combining beginner-friendly, ASD-STE100, examples first, step by step, analogies, and self-explanation. The prompt describes the cognitive path we want to follow instead of merely identifying the topic.

Karpathy Goes Beyond Text

Karpathy’s post continues in an even more interesting direction. After ASD-STE100, he suggests diagrams and images, because some information is easier to process visually. The next level involves directly requesting an interactive HTML web page, taking advantage of the current ability of language models to generate interfaces, animations, and small exploration tools. Finally, he arrives at personalized explanatory videos, created specifically for the individual topic.

He had already expressed a similar idea a few months earlier when discussing output formats: raw text, Markdown, HTML, and, looking ahead, interactive simulations and videos. According to Karpathy, the visual component provides a particularly rich channel for receiving information, and HTML already represents an interesting intermediate step today, because a model can generate it as code while we experience it as an interface.

The timing is particularly interesting because, just five days after Karpathy’s post, on October 7, 2026, OpenAI introduced GPT-6 with Intelligent UI, a new capability that allows ChatGPT to build responses by combining text, visual content, and interactive elements depending on the question. The model can generate charts, buttons, forms, and fully interactive experiences directly within the conversation, deciding when an explanation calls for an explorable diagram and when plain text is enough. OpenAI explicitly presents this capability as a way to make complex topics easier to understand: users can modify an input value to see how the result changes or work through a problem step by step. This approach closely aligns with the direction Karpathy had suggested just a few days earlier: an explanation no longer has to be a sequence of paragraphs, because the model can select or build the format best suited to what we are trying to understand.

Research is already moving in this direction

On arXiv, at least so far, I have not found a paper that presents exactly a taxonomy like these twenty approaches and systematically compares ELI5, Feynman, Socratic style, rubber duck, progressive disclosure, first principles, and the other methods on the same subject. However, several research directions come remarkably close to the same idea: an explanation produced by an LLM should not depend solely on the question, but also on who needs to understand it, their level of expertise, and the kind of cognitive process we want to activate.

One particularly relevant study is Can LLM Code Explanations Adapt to Diverse Problem-Solvers’ Needs? (July 2026), published in July 2026 by Andrew Anderson and colleagues. The authors begin with the observation that different people approach programming problems in different ways and ask whether explanations generated by LLMs can adapt to these differences. They developed prompts based on five problem-solving styles and generated 1,072 code explanations across six open-weight models. Their analysis identified 13 different forms of linguistic adaptation, and the paper also proposes ten prompts specifically designed around problem-solving styles. This is probably the paper that comes closest to the idea developed here: instead of treating an explanation as a single, neutral output, it considers it something that can change depending on how the recipient prefers to approach a problem.

The question of the intended audience had already been studied in 2023 by Donya Rooein, Amanda Cercas Curry, and Dirk Hovy in Know Your Audience: Do LLMs Adapt to Different Age and Education Levels? (2023), a particularly relevant study for approaches such as ELI5, ELI10, ELI12, and beginner-friendly. The authors analyzed four LLMs using 33,600 prompt-response pairs, starting from one hundred scientific questions and requesting explanations aimed at different age groups, educational levels, and degrees of difficulty. The findings also introduce an important caution for everything discussed so far: asking a model to “explain it to an eleven-year-old” does not guarantee that the output will actually be appropriate for that age. The models analyzed tended to maintain a relatively stable readability range of their own, adapting less than the prompt might lead us to expect. In other words, labels such as ELI5 are excellent tools for guiding generation, but they are not deterministic switches capable of automatically guaranteeing a particular level of comprehensibility.

Another very direct connection comes from Improving Student-AI Interaction Through Pedagogical Prompting: An Example in Computer Science Education (June 2025), published in June 2025. Ruiwei Xiao and colleagues explicitly introduce the concept of pedagogical prompting, meaning prompt design intended to obtain a learning-oriented response from an LLM rather than simply getting a solution. The study begins with research involving 36 instructors teaching introductory university computer science courses, uses their input to develop an educational intervention, and subsequently evaluates it with 22 beginner students. After the intervention, students significantly improved their ability to formulate pedagogically useful requests to LLMs. This result connects closely with the twenty approaches described here: writing Explain the for loop and writing Guide me through understanding the for loop by asking questions, without immediately giving me the solution may start from the same technical information, but they produce two very different learning experiences.

The relationship between Feynman style, self-explanation, and examples first appears even more explicitly in Self-Explanation Tutor for Active Study of CS1 Worked Examples (August 2026), published in August 2026. The authors developed ESSE, a tutor in which introductory programming students examine worked-out examples, explain in their own words what specific lines of code do, and immediately receive an LLM-generated assessment of the correctness and completeness of their explanations. The experiment shows that feedback encourages students to correct and expand their answers rather than abandon them, while their explanations progressively become more complete and conceptually richer. The interesting difference compared with a normal chatbot is that the LLM is not primarily used to explain. Instead, it is used to evaluate the explanation constructed by the student and help improve it. This closely resembles the mechanism we are looking for when we ask the model, “now let me explain it back in my own words and tell me where I’m wrong”.

Even the rubber duck has a surprisingly direct counterpart in LLM research. In 2023, Xinyun Chen and colleagues published Teaching Large Language Models to Self-Debug (2023), introducing a technique called Self-Debugging. The paper explicitly mentions rubber duck debugging: the model analyzes its own program, observes its execution, and explains it in natural language to identify errors autonomously, even when the user does not provide a message specifying exactly what is wrong. On the benchmarks used, this procedure improved code generation, with gains of up to 12% in some experiments and a 9-point improvement on the most difficult Spider problems. The rubber duck is therefore not just a charming programmer’s metaphor: verbalizing how code works can become a genuine verification technique, even when the model itself is the one talking to the duck.

For progressive disclosure and, more generally, the idea that the amount of assistance should change as a student’s skills develop, an interesting reference is A Theory of Adaptive Scaffolding for LLM-Based Pedagogical Agents (August 2025). Clayton Cohn and colleagues propose a theoretical framework for educational agents based on adaptive scaffolding, the educational support structure that provides the level of assistance needed at a particular moment and modifies it as the student’s needs change. The framework combines Evidence-Centered Design, Social Cognitive Theory, and the Zone of Proximal Development, and is implemented through an agent called Inquizzitor. The relationship with progressive disclosure is not a perfect terminological match, but the underlying principle is similar: the amount and type of information provided do not necessarily have to remain constant throughout an explanation.

The first principles approach also has an interesting parallel in Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models (2023), a study by Google Research and DeepMind that introduces Step-Back Prompting. Before directly tackling a specific problem, the model is encouraged to step back and derive the relevant general concepts and high-level principles, subsequently using those principles to guide its reasoning. In experiments involving PaLM-2L, GPT-4, and Llama 2 70B, this strategy produced improvements across several reasoning tasks. For PaLM-2L, for example, the reported gains were 7 points on MMLU Physics, 11 on Chemistry, 27 on TimeQA, and 7 on MuSiQue. It is almost the reverse movement of step by step: instead of immediately diving into the details of a specific case, the model first moves to a higher level, identifies the general principles, and then returns to the concrete problem.

Finally, a 2026 study takes personalization one step beyond ELI5, beginner-friendly, or technical deep dive. ExPerT: Personalizing LLM Responses to Users’ Domain Expertise via Query-Wise Semantic and Keystroke Behavioral Cues (2023) attempts to make the system automatically estimate the user’s level of expertise, rather than waiting for the user to specify it in the prompt. ExPerT combines what the user writes with behavioral signals derived from typing dynamics, estimates a level of expertise for each question ranging from Novice, Beginner, Intermediate, Proficient, to Expert, and uses this information to adjust the amount of detail, terminology, and conceptual complexity of the response. In a study involving 40 participants and 1,270 queries, the system reduced expertise estimation error by 65.7% compared with the best baseline method and increased response satisfaction by 17.52%, from 3.71 to 4.36 on a five-point scale. The study is particularly interesting because it suggests a possible evolution of the techniques we are currently using manually. Today, we write ELI5, beginner-friendly, or technical deep dive. A sufficiently capable system could instead infer from the context how much we know about a subject and automatically choose the appropriate explanation level.

Taken together, these studies do not prove that there is one universally superior way to explain something. They suggest something more useful: explanation is a variable of the system. It can be adapted to educational level, technical expertise, the way a person approaches problems, and the stage of the learning process. It can ask students to produce a self-explanation, progressively reduce assistance, reveal general principles before details, or transform the same model from an answer provider into a tutor that asks questions and evaluates what we have understood. The twenty approaches described so far can therefore also be seen as a very simple, manual form of personalization: through the prompt, we tell the model what kind of explanation we need at that particular moment.

The shortcuts circulating on the Internet

Many expressions are circulating on the Internet as if they were actual ChatGPT slash commands, such as /human, /critic, /senior, /diff, /tldr, /devilsadvocate, /rubberduck, /table, or /bullets. It is worth distinguishing three different cases here. There are official slash commands, meaning commands genuinely recognized by the product and handled by its interface or system, such as those documented by OpenAI in certain ChatGPT environments. However, the expressions circulating online, such as /human or /devilsadvocate, generally do not activate an internal ChatGPT feature and do not correspond to official commands. The slash is mainly a visual convention, while the LLM interprets the word that follows it linguistically.

This does not mean, however, that these shortcuts are useless. During training, LLMs have encountered expressions such as TL;DR, rubber duck debugging, devil’s advocate, and technical critique, so they can often correctly reconstruct the user’s intention. /rubberduck, for example, may be interpreted as a request to guide reasoning through questions (in this specific case, GitHub actually documents it as a command in its Copilot app that uses another model to provide a second opinion and challenge assumptions). /critic tends to steer the answer toward weaknesses and objections, while /tldr is normally interpreted as a request for a very short summary. In these cases, it is not the slash that does the work, but the semantic meaning of the label, which naturally depends on how accurately the model interprets that word in context.

That is why these shortcuts should be taken with a grain of salt. They often work very well, but their behavior can vary between models, versions, or different chatbots. These short expressions are best understood as a kind of semantic shorthand, meaning small linguistic macros that work because the LLM recognizes their intended meaning, without necessarily having an actual software command behind them.

Originally published at Levysoft.