A few days ago, I got it into my head to train a language model on Nabokov’s prose. The idea came from a desire to escape the stylistic cul-de-sac of current language models, which, through prompting alone, struggle to deviate from their usual mannerisms and offer limited linguistic freedom. Using material written with an LLM, however good it may be, condemns you to prose that oscillates between social media manager jargon and standard academic writing, with more or less variation depending on how well the person using it understands both the machine and language itself. And yet, just as an LLM learned these registers from us, it can learn others too. No one should flatter themselves that their language is impossible to imitate. Teaching it, however, is not particularly simple.
For a feasibility experiment (the ultimate goal would be to train one on my own prose and then play around from there), I chose an author I love whose style is highly recognizable and far removed from that of an LLM: Nabokov.
The process is called fine-tuning, and it consists in partially retraining an existing model on a specific corpus. It is one of the things that distinguishes an open system you can download onto your own computer from a commercial one you can only query remotely. But can it actually be done? And did I manage it?
Before answering, let’s start by clearing up a very common terminological confusion. When people say that a model is open source, meaning open and free, what they almost always mean is that it is open weight. Weights are the numbers a model has learned during training, billions of parameters encoding what it knows how to do; making them public means allowing anyone to download that file, run it on their own machine, modify it and redistribute it. The training data and the chain of operations that turned those data into weights, however, almost always remain proprietary. You are given the result without the recipe: you can bake the bread, but you will never know what grain the flour came from.
An open-weight model is a valuable gift to the community, albeit a partial one, because you cannot inspect the data that fed it and the choices made by those who trained it remain out of reach. But it is free and freely modifiable, which is no small thing. Compared with a proprietary model, the difference is enormous and touches on at least four major problems surrounding AI.
The first, and most important, is monopoly. Frontier models can be counted on the fingers of one hand and belong to a handful of companies; an open-weight model can be downloaded and used without a subscription, without anyone being able to change the contractual terms on you or withdraw the service. Open models are less powerful than proprietary ones, certainly, but ultimately not by much. Epoch AI estimates that since January 2026 the best open models have lagged behind the leading ones by an average of four months; the UK AI Security Institute puts the gap at four to seven months, down from six to ten in 2025. The gap is narrowing, and mainly concerns agentic tasks in which a model has to plan and execute on its own for hours. For translating, summarizing, reasoning about a text or writing ordinary code, the difference is often imperceptible.
A recent episode helps illustrate just how oblique this monopoly is. Nvidia offered almost thirteen billion dollars to acquire Hugging Face, the largest repository of open models. Nvidia’s main customers are five or six companies that are designing their own chips in order to stop depending on it, and for a supplier, having a small number of major buyers all trying to become independent is not exactly ideal. An open ecosystem, by contrast, multiplies the number of potential customers, because no tinkerer with a good gaming PC is ever going to open a semiconductor foundry, but they may very well buy Nvidia graphics cards. It is hardly surprising that some large companies are betting on this development model.
The second problem is control over what the tool agrees to do. The alignment that teaches a model to refuse certain requests creates circuits that are localized and separable from the rest of its capabilities, which makes them surgically removable; the technique is not particularly complex and is called abliteration, a blend of ablation and obliteration. A Financial Times journalist dismantled Llama 3.3’s safeguards in under ten minutes on local hardware; the creator of one such tool said he had done the same with Google’s latest model ninety minutes after its release. Hugging Face now hosts thousands of abliterated models.
What can be removed in ten minutes, however, is only the explicit block, while the disposition embedded during pretraining remains intact. Explicit censorship, in other words, is something like a switch, whereas the model’s underlying inclination is a gravity that is much harder to escape.
An open model with no safeguards will answer anyone about anything, including questions that should never receive an answer, which unquestionably represents a risk. I still believe it is the lesser evil, given that danger is the price of all knowledge. Writing, printing and libraries presented similar problems: knowledge increases power, and power increases danger. History, however, teaches us that distributed power is often preferable to power concentrated in the hands of a few.
The third problem is privacy. A model running on your computer sends nothing to anyone, and for anyone working with confidential material that is no minor detail, even though AI companies promise, and promise is precisely the word, the utmost confidentiality of user data. In May, for example, OpenAI reported to the FBI a user who had spent weeks on ChatGPT describing his intention to kill his ex-girlfriend, complete with weapons he had purchased and a murder plan; the man was arrested before he could act. It is difficult to disagree in a case like that. But the mechanism that flags a murder is the same mechanism that could flag a political dissident, and the only difference between the two cases lies in who gets to decide what counts as a threat.
The fourth problem is cultural diversity, which brings us back to the experiment I mentioned at the beginning. A proprietary model can be customized only within the limits offered by the company that makes it, whereas having the weights means being able to intervene in the very form of the “artificial mind.” A LoRA, meaning a small additional training process that modifies a model’s behavior without rewriting the whole thing, can be trained in a few hours on personal hardware and can shift its attractors toward a particular voice, language, style or tradition. My training experiment on Nabokov is only an experiment, but the mechanism that makes it possible is the same one that allows a minority language community to have a model that actually speaks its language instead of producing what often sounds like a rough translation from English.
To the political and ethical advantages, one might also add environmental ones, since a local model requires no datacenter except for its production, whose impact, although significant, very quickly becomes negligible for commonly used models compared with that of inference. Which is fairly obvious, if you consider that using it consumes very little energy but millions of people are doing so.
For the same amount of use, however, a datacenter consumes less. The advantage of the cloud lies in serving thousands of simultaneous requests on the same hardware, spreading the hardware’s energy cost across an enormous number of tokens; a home machine processing one request at a time at full power can end up consuming four to six times as much energy as a shared cluster.
But things are even more complicated than that, because efficiency per token is not the only variable that matters when assessing environmental impact. Global AI consumption, although growing, still represents a relatively modest fraction of worldwide electricity use; the more serious problem is local. A datacenter consuming hundreds of megawatts places its entire demand on a specific electrical grid and aquifer, putting them under such strain that conflicts over resources have already emerged in parts of the United States and Ireland. The same consumption spread across a few million computers already switched on and connected to domestic grids is less efficient, but also infinitely easier to absorb. It is somewhat like having many small heating systems instead of one gigantic centralized one consuming all the resources of the place where it happens to be located. Then there is the Jevons paradox, whereby making a resource cheaper multiplies its use until the original savings disappear; I suspect it applies here too, and that a world of local models would ultimately generate far more tokens than one based on rented models. Even so, it might still represent a more sustainable form of consumption because of its distributed nature.
The current ferocious race to build datacenters rests on an expectation of future returns, and if open models erode those returns, the economic justification for a considerable portion of those facilities disappears. The famous “AI bubble” might, in fact, turn out to be a datacenter bubble. Which is exactly what many companies fear when they describe open weights as inherently decelerationist, or “communist.”
The biggest limitation of open models has more to do with access than quality. To use open models, you have to be something of a tinkerer. Hardware is another obstacle, because you need high-end machines, although we are not talking about hundred-thousand-euro computers: depending on your needs, a good gaming PC may be enough. Hardware can at least be rented for a few euros an hour, though that inevitably brings some cloud computing back into the equation.
The skills barrier should not be underestimated either. Installing a local environment, figuring out why a driver is not responding, converting a model into the right format, connecting the nodes of an image-generation graph: all these things require a non-trivial level of computer literacy. They can be learned, but they are also things most workers have absolutely no desire to learn, for perfectly good reasons. Everyone has their own interests and their own time. I cannot code myself and have no intention of learning, because it requires a great deal of time that I would rather spend living elsewhere.
For years I thought the solution would come from interfaces, that sooner or later someone would build for open models the equivalent of what Photoshop did for photo editing. It is happening, in fact, and quite quickly; programs like Unsloth and even the hostile Comfy now offer fairly accessible prepackaged models. But it is not enough, because these are niche products built for users who already share their vocabulary. The gap between the interface and the moment something breaks remains impossible to bridge for anyone who has no idea where to start.
There is, however, an unexpected solution: if programs have not become more accessible, programmers have. Today anyone can have an expert available twenty-four hours a day at relatively modest cost, simply by using an LLM.
Let me give you an example. When my training process got stuck while importing a library, I had absolutely no idea what to do or even what the error message meant. I pasted it into the Claude chat I was using to assemble the project and received a correct diagnosis and three alternative solutions. I do something similar when building complex workflows in Comfy, a rather hostile image- and video-generation program. I described in ordinary language what I wanted to achieve and received the configuration file I needed to upload. It worked.
I went further and started building what industry jargon calls skills, meaning persistent instructions that teach the assistant how to behave within a specific domain. I have one that understands the program I use to generate images and builds its workflows, and another that understands the fine-tuning software and guides me through it step by step, explaining every technical term the first time it uses it. This way, not only can I work without the frustration of having no idea where to begin, I also learn along the way, because every explanation arrives at exactly the moment I need it and in relation to the specific problem in front of me.
I do not know whether the future will be open, closed or hybrid. We are still imagining software as something a human being uses through an interface designed for them; the workflows described so far suggest a different arrangement, one in which programs are designed to be operated by language models and we merely tell them what we want. At that point, the interface becomes superfluous, because between me and the machine there is a translator who speaks both languages. Not knowing how the things we use actually work can be frightening, but that is precisely what every driver who is not also a mechanic, or every graphic designer who is not also a programmer, has been doing for years, to give just two of a thousand possible examples.
If the trend of the past two years continues, meaning if open models become more capable while requiring less and less hardware, we could end up with a local assistant trained on our own texts, familiar with our procedures and working entirely in private. In that scenario, the hundreds of billions currently being poured into datacenter construction would turn out to have been a bad bet, or at least one dramatically oversized in relation to actual demand.
My artificial Nabokov, in any case, is pretty terrible. I tried training it locally using an old, small model (Llama 3.2 3B), and I did not have particularly high hopes. But the result should not be judged by comparing it with frontier models, but with its equivalent, and then imagining what might happen if it were possible to work with one of the most powerful models available. So I will try asking it to rewrite this brief conclusion.
Here is the fine-tuned version:
But my machine is a very mediocre one. I attempted to coach it, with the aid of a small but ancient model (Llama 3.2 3B), and I did not expect much from it, but then, after all, we cannot judge it by comparing it with those new frontier toys; no, we must compare it with its congeners or, still better, with its “sister-brothers.” And then we may dream of the wonders that would occur if one could work with one of those supermachines.
And here is the version without fine-tuning:
My artificial confidant, a creation so flawed, yet tantalizingly imperfect, like a bruised flower that still holds a whisper of beauty. I endeavored to instruct it, to cajole it, to coax forth some semblance of coherence, utilizing a modest, antiquated entity, this Llama 3.2 3B, a relic of bygone computational eras. My expectations, I confess, were as low as the fog that shrouds a forgotten garden on a winter’s eve.
To me, there is no comparison: the second sounds like a parody of Nabokov, while the first has at least a little of his flavor. It is a start.
Francesco D’Isa