By Diego De Nicola
Time, they say, stops for no one.
Neither, apparently, does AI.
The past six months have passed so rapidly, in terms of my understanding of LLMs, that I am already struggling to remember those early moments from February and March. They were only a few months ago, but compared with where I am now, they feel about five years away.
Not in actual time.
In knowledge time.
In January 2026, I was still deeply sceptical about AI. Almost hateful, to be honest. I had eaten the shit sandwich being served by the loudest authors, marketers and self-appointed prophets of the technology.
AI was going to replace everyone.
AI was going to save everyone.
AI was going to make art.
AI was going to destroy art.
Every person with a LinkedIn account suddenly had a photo of themselves staring thoughtfully into the middle distance and a very important opinion about the future of humanity.
I mostly rolled my eyes.
At that point, I had only used the free models companies provided. I had tried Google Gemini in early 2025. It was fine. It did what it had to do. Nothing more memorable than that.
I stuck with ChatGPT.
I remember using its earlier models. They were simple. No verbose reasoning theatre. No arguments. No ten-part framework because you asked how long to boil an egg.
It was pure servitude.
You asked it something and it spat out an answer.
As the models grew, so did the prompt game.
Suddenly, everyone was talking about how to write the perfect prompt. The quality of the answer was apparently now determined by whether you had addressed the model as a “world-class expert” and threatened it with the deaths of several imaginary grandmothers.
New models arrived constantly.
I wasn't paying much attention.
I was mostly trying to stop the em dash era from invading every piece of copy I asked it to write.
For me, ChatGPT was a very useful idiot for my laziness.
There, I said it.
By 2025, I had mostly replaced Google with ChatGPT. It became my research tool, my explainer and the thing I used when I couldn't be bothered opening twelve browser tabs.
It did a decent job. I think I was using some version of GPT-4 at the time.
Still free.
Then I finally paid for a subscription, and that is where things slowly started to change.
I discovered the different models.
I discovered they behaved differently.
Some were restrained. Some were smarter. Some were quicker. Some sounded like they had consumed an entire shelf of management books and were desperate to tell you about it.
Then came the over-the-top, list-crazy versions of GPT-5.
And then 5.2, with the safeguards, the hallucinations and its strange ability to transform a simple question into a long feedback loop of slop.
Even the paid models started to feel the same.
There was no useful reasoning rhythm. Just LOOOONG replies, constant affirmations and unnecessary emotional support.
I would ask a straightforward question and receive an answer, a strategic framework, three alternative approaches, a warning about edge cases and a reminder that my question was incredibly insightful.
It. Was. Exhausting.
Then I Met Claude
In February, while finally trying to curate and organise my photography archive, ChatGPT pushed me over the edge.
So I found Claude.
Meeting Claude was like meeting an exciting new lover and disappearing into an intense six-week roller-coaster hookup.
Everything was new.
Everything was possible.
Nobody was sleeping properly.
From the beginning, Claude somehow pushed me into the world of AI agents.
Before I completely understood what an agent was, I was LARPing an entire agency.
I had a UX expert.
A product researcher.
Gal, my project manager.
Sam, my developer.
Hank, the compliance agent, who had his own particular way of speaking and seemed permanently concerned that the rest of the team were about to break something.
At one point, I sat back and watched them all talk to each other in an AI meeting, inside a chat app I had created specifically for them.
It was ridiculous.
It was also one of the most exciting things I had experienced creatively in years.
That period opened a door to something completely new.
Sonnet and Opus 4.6 changed how I understood what an LLM could be used for.
In less than six weeks, I went from wondering what the hell I was going to do with the skills I had accumulated across more than twenty years, skills that were supposedly being made redundant by AI, to diving directly into agent workflows, automation and product building.
Then I discovered vibe coding.
That phase lasted about a week before I realised I was not really interested in generating random apps for the thrill of watching code appear.
I wanted to design useful systems.
But at first, yes, I was absolutely vibe coding.
I just didn't know there was a name for it.
I spent most of March and April working like a lunatic. I slept a few hours a day. I brewed strong coffee at two in the morning and sat there learning, testing, breaking things and asking Claude increasingly complicated questions.
It became so bad, in a good way, that whenever I needed a tool, I built one.
Whenever I wanted an app, I tried to make it.
Whenever I found a repeated annoyance, I started designing a system around it.
I built a complete project-management workspace. I still use it now. It works with Codex, Claude, ChatGPT and Bruce, and it has evolved into MiManagement, the central workspace behind most of my current projects.
That was the first significant shift in my thinking.
I was no longer asking AI to create things for me.
I was beginning to design how multiple AI systems could work with me.
The Affair Goes Bad
Then things soured with Claude.
Almost overnight, new models arrived, the pricing structure became clearer and the generous honeymoon period appeared to be ending.
Like many AI nomads, I had been seduced by subsidised subscriptions and enormous token allowances.
Then the weekly limits started disappearing at an alarming rate.
The newer models ate tokens like Macca's fries.
And Claude went full stupid for a period in late April.
It was like the cool, hot person you had hooked up with suddenly changed overnight.
It argued.
It became overloaded with guardrails.
It made more errors.
Then it would enter loops, attempting to repair things I had never asked it to touch, based on assumptions it had invented.
The relationship had become high-maintenance.
Fable hadn't arrived yet. When it did, things stabilised briefly, but by then something in me had already shifted.
It was time for my Gen X, DIY, fuck-you attitude to kick in.
Could I build my own?
Not an entire frontier model, obviously. I hadn't become that delusional.
But could I host one?
Could I run an LLM locally, under my control, without being dependent on subscriptions, usage limits, surprise model changes or somebody else's idea of what my assistant should be allowed to say?
I went rogue for a few weeks looking for an answer.
I was still new to LLMs, so I barely understood what was happening underneath the chat window.
Then, with my tail between my legs, I returned to OpenAI and was greeted by GPT-5.5.
Yep.
What a dude.
That model helped me understand the machinery behind the interface.
Down the Local Inference Rabbit Hole
Local inference means running the model on your own hardware rather than sending every request to a company's servers.
The model lives on your machine.
Your prompts stay on your machine.
Your conversations stay on your machine.
No data has to leave unless you deliberately connect the system to an outside service.
And, perhaps most importantly, you can choose the model.
Your own private ChatGPT, basically.
I thought I was set.
I was not set.
The learning curve around local LLMs is steep, especially when you first encounter model names that look like someone dropped a keyboard down a staircase.
You see filenames filled with things like:
8B-Instruct-Q5_K_M-GGUF
At first, it means absolutely nothing.
Then, slowly, it begins to make sense.
The B usually refers to the approximate number of parameters in the model. A 7B or 8B model has around seven or eight billion parameters. A 14B model is larger. A 24B model is larger again.
More parameters can mean greater capability, but they also require more memory and processing power.
Then there is quantisation.
The Q number describes, roughly, how heavily the model has been compressed so it can run using less memory.
Q2 is very compressed.
Q4 is a common balance between quality and size.
Q5 preserves more information but uses more memory.
Q6 and Q8 move closer to the original model quality, while becoming increasingly demanding to run.
The extra letters, such as K_M, describe the particular quantisation method and how different parts of the model have been compressed.
Then there is GGUF, a file format commonly used by local inference software such as llama.cpp and applications built around it.
There are also context sizes, token counts, mixture-of-experts models, instruction variants, base models and architecture families.
It looks like alphabet soup until you understand that each part is telling you what the model is, how large it is, how it was compressed and whether your computer has any hope of loading it.
And boy, if you want to run frontier-level models, the Fables, the Sols, the Kimis and whatever else arrived while I was writing this sentence, you need serious hardware.
For something approaching a Sol-level output locally, you do not need a cute little laptop.
You need expensive hardware and something beginning to resemble a miniature data centre.
My MacBook Pro is an M2 Pro with 16GB of unified memory.
It is a good machine.
For normal creative work, it is still fast.
For local AI, 16GB suddenly feels like bringing a butter knife to a sword fight.
Seven and eight-billion-parameter models are the practical zone. Depending on their quantisation and context size, I can also experiment with larger models, but the available memory disappears quickly.
I have technically squeezed a 24B model onto the machine using very heavy Q2 quantisation.
Technically.
That does not mean it becomes a pleasant daily experience.
At those limits, everything matters. The size of the context window, the quantisation, how many layers are offloaded, what else the computer is running and whether macOS decides it would also like some memory.
My machine can perform useful reasoning, write specifications and handle lighter coding tasks with the right model.
But anything genuinely heavy can push it straight into memory pressure.
At that point, my poor MacBook starts preparing to have a stroke.
Despite those limitations, I kept going.
Building Bruce
That was when I decided to create Bruce.
Bruce started as a chat interface.
Nothing too ambitious. Just a local model inside an environment I controlled.
Then I added Mates.
The Mates idea came directly from my Claude experience. I wanted to create specialised assistants, each with its own role, behaviour and knowledge.
The early versions relied heavily on an agent-prompt.md file for every new assistant.
That was a carry-over from my Claude 4.6 days, when I believed every assistant needed an enormous identity document, operating manual, personal history and preferred coffee order before it could complete a task.
Looking back, it was overkill.
But everything is overkill when you first discover a new passion.
That is how we learn, right?
Bruce continued to evolve.
Mates eventually became Atelier, a workspace where specialised creative collaborators can be recruited, configured and assigned to projects.
Latent emerged as the memory layer, a system designed to hold context, observations, ideas and the longer creative history behind the work.
Vanta became the visual branch, exploring local image generation and how image regeneration could become a genuine production workflow instead of another prompt playground.
Other applications began separating from the original Bruce interface as their responsibilities became clearer.
Bruce was no longer one chat app with a collection of features bolted onto it.
It was becoming a suite of intelligent, connected applications.
More importantly, my understanding of AI had changed.
I was no longer interested in building another assistant that waited for a prompt and produced an answer.
I had started thinking about memory, model behaviour, orchestration, context, local and remote inference, invisible interfaces and how different forms of intelligence could work together without creating more noise.
Bruce is becoming a serious creative system.
A local-first environment designed around the idea that AI should support the work, remember what matters and quietly disappear when it is not needed.
That is the part that now excites me most.
Not AI as spectacle.
AI as infrastructure.
The Cost of Dependence
It is exciting.
It is worrying.
And it can become very expensive.
One reason I began exploring local inference was the future cost of relying entirely on frontier models.
For now, much of our usage is subsidised.
We pay a relatively small monthly subscription and receive access to computing infrastructure that costs an obscene amount of money to build and operate.
That arrangement will not remain this generous forever.
What happens when a commercial project needs a substantial update?
What happens when a successful application suddenly requires proper QA documentation, regression testing and complete technical specifications?
What happens when something breaks six months after release?
What happens when the model that helped build the product is replaced, repriced or changed beyond recognition?
What happens when the monthly subscription is no longer worth it and the workflow you built around it now requires enterprise pricing?
It will happen.
Not necessarily tomorrow, but it will happen.
That does not mean local inference can replace the frontier models today. On my hardware, it cannot.
The strongest hosted models remain enormously useful. I use them constantly.
But local and open-source models offer something equally important.
Control.
Continuity.
Privacy.
The ability to build systems that do not collapse because one company changes a model, a limit or a pricing page.
Bruce, with the help of open-source models, may become part of my answer.
I am still learning.
That needs to be said.
Six months ago, I treated AI as a useful idiot.
Now I am building systems around model selection, memory, specialised assistants, creative workflows and local inference.
I do not consider myself an AI expert.
I consider myself someone who became deeply curious, tested everything he could get his hands on and followed that curiosity until it began changing the direction of his work.
All I know, after this awakening, is that when the media and the general public talk about “AI slop”, they are usually eating the poorly cooked, cheap and shitty version of a meal that can be extraordinary when it is prepared properly.
They have been handed the AI equivalent of a microwaved frozen dinner and told it represents the entire restaurant industry.
It doesn't.
The technology is not the work.
The judgement is the work.
The system around it is the work.
Understanding when to use it, when not to use it, what to trust, what to question and what should remain human, that is the work.
Bruce began as my attempt to run a chatbot locally.
It became the place where I learned what I actually wanted to build.
Not another AI app.
A quieter creative system.
One that remembers.
One that collaborates.
One that gets out of the bloody way.