These are my questions about it

1. What can it actually do today for me?
2. How can it help me or make me worse at my job.
3. How could it disrupt the economy or cost us our jobs.

I wouldn’t say I’m an early adopter, but close enough considering how much time and energy I’ve invested in understanding what all this noise is about. In this article I’m going to explain why I think OpenAI and Anthropic are in trouble, they know they are, and all the money they are spending is mostly on pretending they aren’t worthless. By the end I hope you feel better about job security not because AI is useless, but because what’s replacing the hype is stuff you can build and control.

What an LLM actually is

All texts they generate are based on pre-existing text they’ve been fed, they look at those texts, create tables of resemblance, and figure what the next word might be based on statistics. These “words” units are called tokens and they aren’t necessarily words, they can be subdivisions of a word. So a modern chat model is a next-token predictor. It doesn’t care about truth, just probability of wording. It statistically continues patterns that looked plausible in training.

People call this a stochastic parrot. They just statistically predict and repeat patterns from their training data, mimicking human-like responses without real comprehension or intent.

When you enable thinking mode on some models all it does is use more text and fill the context window quicker. It can spend ten minutes discussing with itself whether its cutoff is 2024 or 2026. Every new line gives it more text to generate the next line. So it’s a glorified search engine where facts and accuracy don’t matter.

The weights don’t learn your project overnight. Anything that feels like memory or fresh facts usually comes from context you fed, tools, or external stores, not from the model silently updating itself.

What can AI do TODAY?

Briefly:

1. They can take questions written in natural language, even with some typos, and reply back with what looks like, increasingly less with every new version, human written text.
2. They can also generate images, sounds and video.
3. They can write code for multiple languages but specially Python and Javascript.
4. They can fool people into accepting as truths something that is just made up text.
5. They are all sycophants aiming to be agreeable or fake being right, none of them can distinguish truth from lie.

I’m going to focus on the ones that matter to me.

Where today’s stack fails

For me it breaks down into three kinds of problems: technical limits, economic structure, and product trust.

Technical limits

They cannot make something out of nothing. Everything they spit out comes from what they were trained on plus whatever prompt you hand them. Ask it to generate a frontend and you’ll usually get something generic and boring that you could do quicker in Bootstrap Studio. You’ll probably waste more time trying to fine tune the prompt to get what you want than if you’d just built it yourself.

Not to mention the royal pain in the arse of finding out whether the code you get is comes from others with licences that clash with your product (especially viral ones), given LLMs don’t spare a thought for the origins of any of their training data.

Ask the model its cutoff date and work backwards. Take Elixir as a good example. Most models I can download know nothing past version 1.16. Ask your model what it thinks of unless and if it believes it is deprecated. Most will fight you.

Ever growing models add absolutely nothing to software engineers using them if they are bad at coding in their language of choice. The languages they write “the best” are often flimsy Javascript (hundreds of versions, lots of low quality JS online) and Python (still fragmented on packaging, still carrying 2.x vs 3.x baggage). Try Kotlin Multiplatform or Elixir despite the existence of centralised Hexdocs and you still hit outdated code and silly mistakes.

Hallucinations are the model filling in instead of saying I don’t know, unless the harness stops it or grounds it with retrieval and citations.

So people bolt on RAG (retrieval-augmented generation, fetch relevant chunks then generate) or do a bit of fine tuning. You do not need OpenAI’s or Anthropic’s latest flagship for this. Nope. Another sign that the real product isn’t just the raw weights. And, crucially, there’s no magic button they can press to conjure up a GPT 7.0 or a Claude Popsicle that’s up to date with everything on the internet right now. The best they can offer is always a snapshot, always some version behind reality.

Economic and structural pressures

The most costly part of LLMs is not inference, it’s creating the model. Vast data, ever larger datacentres, chips, water, financial resources. And even then you get cutoff dates. Its knowledge is always frozen in time.

Oldest trick in the book, on Facebook YOU are the product, in Google your searches are the product. We never left the web 2.0 era. Your prompts are content. The pitch for chat.insertyourproviderofchoice.com is width of knowledge so you’ll type more about your life. Anyone on the receiving end can use that to push better ads on you, or worse.

Fediverse vs Twitter

You have seen this pattern before. One company owns the megaphone, the feed, the rules, and the ad layer. Mastodon and the wider fediverse are the opposite bet. Many servers, many communities, you can move instances, you can follow people across servers, and nobody in the middle is trying to turn your whole social graph into ad inventory by default. Twitter is still where people go for reach and one global scoreboard. The fediverse trades some of that discoverability for exit and community rulebooks you can actually read. Neither side is perfect. The point for this article is structural. Who runs the pipe, and who gets to read the stream. A glossy cloud chat product is Twitter in LLM form. A local model with your own RAG, MCP stack, and guardrails is closer to picking your own instance and owning more of the plumbing you even get to choose Mastodon, Pleroma, Akkoma, Sharkey, GoToSocial.

If the model can reach tools, search, APIs, MCP servers (Model Context Protocol, a standard way for assistants to call external tools and data), sheer memorised bulk matters less. Mistral Le Chat has stuff like searching PubMed and linking claims. A small model that queries sources beats a giant one that guesses citations. Tools turn the LLM into a front end for search and structured sources, often more accurate than a 500B-parameter memory of the internet that’s still wrong when it’s released.

Product fatigue and trust

They are so pervasive universities barely need Turnitin. Identifying AI prose is easy, think of… instead of…, em-dashes everywhere, first paragraph praises you, last paragraph open-ended so you burn tokens. Online communities notice. On Reddit people call it out so fast it’s become a sport. It’s a bit like the SouthPark episode where the kids were obsessed with a game until their parents liked it and the novelty vanished.

For search, every time you use Google you get AI generated crap at the top where half the time the summary contradicts the links. If that annoys me, imagine everyone else. I lean harder on DuckDuckGo even though they also do AI but it’s far less intrusive the more Google forces me to read Gemini responses before the actual results I am looking for. I can even achieve more accurate results using a simple MCP in LMStudio that uses DuckDuckGo and then fetches the results to give me a properly accurate answer.

Enter the room what makes a model interesting, the harness

I hate this word but have to use it to explain the immediate future.

Everything they are good at does not require renting the biggest proprietary model anymore when you get the harness right.

A harness is just a bunch of tools that combined make a model actually useful. You could say Cursor IDE is a harness, Zed Editor is a harness, Copilot, Claude Code, Pi dev, RooCode/ZooCode are all harnesses. Imagine the LLM as plutonium. The harness is the whole plant around it. The same kind of hot reactive core can either be the payload in a delivery system or fuel in a reactor hall. One story ends in a flash everyone remembers for the wrong reasons. The other is just containment, coolant, control rods, years of boring maintenance, and what you get out of it is power you can actually use, lights on, turbines turning, work getting done. Unless Homer Simpson is in charge of security.

They usually include a mixture of:

1. RAG: To some extent navigate your code to find where the lines are that perform some function, then depending on your question, feed those lines to the model prepending your prompt. In other words they add context the model wouldn’t be aware of otherwise. They can also navigate and catalogue external sources like documentation.
2. Guardrails: they define what the model is allowed to do with tools that need user privileges, from creating, editing or deleting files to accessing the internet or running commands in the shell. Rules and limits, not the thing that runs them.
3. MCPs: extra functionality that adds intelligence to the harness. They can allow the LLM to access your Obsidian notes, get the latest docs on some language, or control a browser.
4. A compactor: something that summarises the session, usually in an internal markdown file, that later is fed into a new session so the model maintains some memory of what it was doing. Because all models have context window limits and they are a lot shorter than our working memory.
5. An Agent: the part you actually interface with, chat surface, diffs, approve or reject, terminal output, all of it. The model outputs text, the agent is what turns that into real tool calls and runs them inside those guardrails from item 2. It is the loop that proposes an edit or a command, checks if it’s allowed, and executes or asks you, then feeds results back to the model. Without that agent you’re back to a plain chat window that can’t drive your IDE or your shell.

The two most important jobs of the harness are to cut hallucinations and to supply memory outside the context window. Both goals are interconnected.

Models do not learn

If you plug a tiny model like Gemma to an MCP that gives it memory you can tell it from LMStudio to remember your name, some crucial data you have that will be useful, and Gemma won’t remember any of it BUT will use the MCP tool you’re using for long-term memory to store that data, which will ultimately land in a vector database like Qdrant. Then when you ask “do you remember what’s my name” Gemma pulls it from your MCP server and answers correctly. It feels as if the model remembers but it actually does not, it just has external memory.

So the point is, a modest model plus retrieval and tools often beats a massive frozen generalist for fresh, checkable answers. Same for code when the harness grounds work in repo and docs.

So how does this affect OpenAI and Anthropic

If their core sell is omniscience baked into the weights, but users including younger generations are tired of very wrong and verbose answers, and small local models with MCPs and RAG can answer faster and more accurately for real work, then having the biggest model isn’t what locks people in anymore. What’s left is convenience, habit, distribution.

But now for that convenience you pay ever increasing token costs. Dario Amodei is telling you to use multiple agents in parallel to get a better answer (sure, burn more tokens, make him richer, what would he say, use Claude less?). Software engineers are getting fed up with how expensive every hallucination is and how verbose and inaccurate generated code is getting.

Meanwhile early adopters running local LLMs like me have reached a point where downloadable LLMs plus custom MCPs work better for me than commercial cloud ones, and they don’t suck my personal data since it runs on our PCs. We’re past the peak where you needed two H100s to run a decent model. I have my tailor-made local PRIVATE stuff on my puny 5060 Ti with 16GB VRAM. I belong to two of their target demographics, software engineer AND early adopter, and I don’t need them. Imagine once the rest realises the same.

Enterprise reality check: cloud APIs only matter when the organisation refuses to self-host, full stop. Because, no matter how good their sales pitch is, a lot of companies simply can’t ship their code, their customer data, their internals through someone else’s API and sleep at night. Contracts, GDPR, NDAs, basic sense of risk, there are many reasons not to. Privacy isn’t a nice-to-have for most workplaces, it’s a hard constraint. So I’m saying value moves to harnesses and specialisation and to setups that stay on your own metal when the cloud is legally off limits.

The trend is clear. OpenAI and Anthropic aren’t just competing against each other but against how people actually want to use these systems. Their advantage was never really parameter count, only the perception that bigger meant better. That perception is fading among engineers and hobbyists, and regular people are tired of AI shoved into every surface. So the focus has shifted to maintaining the illusion through PR and hype.

Look at Mythos on the Linux kernel for how that plays out. You get the news cycle and pieces like https://www.darkreading.com/vulnerabilities-threats/ai-assisted-software-scan-linux-bug, big scary AI found bugs in the kernel energy, then you dig into what actually matters for real threat models and half the punchline is local access, physical access, you already have to be at the machine in ways that make the headline feel ridiculous for anyone trying to prioritise actual risk. If I can touch the box I can do worse than whatever CVE paragraph fourteen buried.

The Reddit thread https://www.reddit.com/r/linux/comments/1sk9hcd/how_linux_plan_to_patch_the_exploits_discovered/ is worth reading for tone. People aren’t stupid. There’s a comment that says the quiet part out loud, this smells like an advertising campaign, scare users then sell the same brand as the thing that finds and patches the holes, subscribe now.

Basically you don’t need them. Those misnamed systems aren’t AI in the sci-fi sense, they’re bloated natural language processors (NLP), and none of them will ever be close to artificial general intelligence.

What is AI actually good for as a coder

Boilerplate code

You want to write in TDD style some new feature, you need fixtures, sandboxes, test doubles and mockups. THE BORING stuff. That’s where it shines and you still need to check those fixtures match reality, let alone the latest features of the language for testing.

Aided summarisation and aided article

If you write a very long post AI could summarise it for you but it’ll take all the personality out of it and sound bland and boring, hence why I wrote AIDED summarisation and not summarisation, aided article writing and not article writing. It’s good to give them your article and tell it to suggest a better structure of the headers after you’ve written it. The LLM will figure normally what is it that you’re trying to convey and guide you a better order of headers so you keep your voice, your tone, your typing, your million of typos (cough cough) BUT it is a lot easier to read now for others since now with the improved order, it is harder to lose track. This is specially useful for neurodivergent people (hi, that’s me and a huge percentage of coders) since we usually don’t think linearly.

Translation

Obvious one. Easiest one for them to accomplish. Do we need 500B parametres models for this? Nope.

Shaping ideas or feasibility, brainstorming

I wrote another post about using AI to check the feasibility of an idea. It’ll definitely write awful code but you often just want to brainstorm how possible it is to develop something and what problems you might face. The creativity is all yours and you compose prompt by prompt something you’ll never push to production, resembling your idea enough for you to figure the problems you’ll find in the way and the extras you’ll need to design. Let alone it allows you to reach full completion of your idea before actually starting to work on it, no SCRUM needed, no Agile, your focus is to write a full requirements document before you write your first line of code.

I strongly suggest using a different language than your target one if you’re serious about the idea, on one side that avoids licensing issues and on the other side that forces you to write the code yourself on your target language.

What I think everybody should do

1. Stop supporting the worst business model

Let the Scam Allmens of Sillicon Valley fall on the weight of their own predictions. When you use cloud-based commercial LLMs you’re paying to train the next model on how much they can model your soul from your prompts, supporting infrastructure that’s destroying the planet, and giving data that can target you for ads or worse. People willingly write mental health stuff into chats, and even chat about their life-threatening alleries like they’re handing over a playbook on how to destroy them.

Switch instead to local models. Both Ollama and LMStudio use Llama.cpp behind the scenes, you can even use it directly and it is supposedly faster. I prefer LMStudio because I like the interface more and token generation per second is high enough (anything from 20 or more is good enough) that faster wouldn’t make a difference for me reading or reviewing. I tend to use Qwen 2.5 coder 14B, Mistral Devstral, Qwen3.6 9B, and Gemma. For conversation with internet the 9B models are good enough. For coding it’s got to be a “coder” version of Qwen or Devstral.

I have an Nvidia 5060 with just 16GB VRAM and so far that’s enough. I’ve tried larger models on ThunderCompute, Runpod and others and sure the code seemed better and tokens per second were higher, but they just seemed, on a closer look I couldn’t keep up with it. So there’s no point in a model typing faster if every time you review the code there’s too much of it. Again my right> -arm tattoo is right:

LESS IS MORE

When I stopped chasing bigger models on rented cloud PCs with H100 GPUs, I focused on long-term memory with ingestion of self-updating data and moved into RAGs, vector DBs, and Oban to self-update. I had the pleasure of being at ElixirConfEU and unknown to me had the creator of hex.pm, hexdocs and Ecto by my side, I went in without googling anyone on purpose so I get to know people before titles. I learnt that unlike everything in codeberg.org, everything in hexdocs can be scraped as needed, and all docs of deps sit in deps/ too, so you avoid scraping unless you want your RAG to check for a new stable version that doesn’t match what’s on your elixir project’s folder.

Local LLMs vs cloud commercial APIs

Same story as above, different stack. Quick contrast before we go deeper on harnesses.

Both OpenAI and Anthropic share the same pitch: rent the flagship and hope the weights know your repo, and the table above shows where the value actually is (memory, tools, retrieval, who owns your prompts). The product was never only the weights. Once that lands, section 2 below is the practical half. Anthropic goes even further and is trying to convince you the solution is to use multiple agents burning tokens in parallel to balance each other. That’s efficiency at making them richer, not you getting solutions today.

2. Develop your own harness

I first noticed the RAG thing thanks to RooCode, indexing into local Qdrant with a local embedder and your whole repo locally, so you can ask “where’s the function that creates a new nix environment on my Fish shell folder” instead of “where’s create_nix” and it answers. So I thought:

…wait, my puny local PC is able to answer questions about the whole of the codebase by meaning?

Then I thought what if my entire Obsidian Vault, what if the latest Kotlin Multiplatform docs, what if I inject Rust docs in LMStudio to finally have me explain in a way that it sticks how the borrow checker works.

I coded a preprocessor on LMStudio but preprocessors only work on LMStudio (meaning their UI), so I converted it into an MCP in Elixir called remember_ex and kept fiddling with it. I can inject ePub docs and PDFs into Qdrant now. Chunking is still the hard part.

Eventually at ElixirConfEU George Guimaraes was presenting Arcana, I haven’t tried it yet but I will. Surprisingly we were doing very similar things and reaching similar conclusions, like using another LLM to chunk the texts better, Oban in the background so retrieval isn’t blocked by pending chunking. I still need to check heavy jobs don’t block LMStudio and supposedly when I run a model I have 4 threads but I’m not entirely sure that’s true or that my GPU can actually handle 4 at the same time. So we’ll see. That’s my path, let’s focus now on yours.

What should you try? Start small.

• Try RooCode or Cline or ZooCode (RooCode’s new team) in VSCode with your own local model, embedder and Qdrant. See what models work best for your language and style.
• Move onto Zed Editor. It’s an IDE centered on removing bloat and being fast, written in Rust with their own UI framework. Fewer problems than RooCode for me most of the time. remember_ex works with it.
• Cursor IDE. I don’t trust their privacy. It’s VSCode with some extensions plus magic URL docs fetch when you thought you were fully using your local model, semantic search without ever asking you to configure an index or vector DB like RooCode does, something smells fishy, I feel they’re in the business of gathering repos. Your threat model may differ. I simply don’t trust them. I like their UI though, the way they structure their settings feels better thought that RooCode. They just hide too much stuff for me to trust them.
• Experiment with MCPs. I fork stuff at https://lmstudio.ai/maikelthedev and https://lmstudio.ai/tupik/top has the most incredibly useful README since lmstudio extensions have no directory for reasons that make no sense to me. The MCP standard is on https://github.com/modelcontextprotocol and you can get from there code that already works to tweak and make your own thing. My MCP started from their JS example “memory”, I rewrote it in Elixir. Preprocessor means LMStudio runs it before your prompt, hidden. MCP means the model decides to call it, visible. I wanted remember_ex in LMStudio and Zed so I gave up preprocessing perks for compatibility and ended up in that repo.
• Learn Qdrant. Simple, built for this. I haven’t tried every vector DB, they bore me. I just needed to understand enough to optimise the chunking. Qdrant does not get in my way.
• Do learn about Pi.dev since it is THE tool that lets you build your own harness easily and quickly.

3. Learn new programming languages

LLMs with internet and your own RAG for long-term memory and docs injection are ideal for learning new languages if you can ingest up-to-date docs. For Elixir the easiest path for me was ePub docs from projects, decompress, process, done. Efficient chunking is still the issue. Not a problem now but I keep thinking long term with massive libraries on Qdrant. Efficient chunking is about providing the LLM with JUST enough context to answer the question, that’s the key of the efficiency, the least information provided possible, the least context window you use. As context window grow the model becomes slow and hallucinates more, once you reach the limit you start afresh. Normally your harness compresses the context into a markdown file with just the important stuff and creates a new sesssion where it injects again. But there’s information loss during the compression so the longer you can remain before reaching the limit the better.

If the model remembers your style via long-term memory MCP or skills.md it can explain new programming languages in the exact way that you know worked for you before to learn the fastest. And we devs love flattening learning curves.

Specialisation over generic omniscience

The next phase won’t be packing more trivia into one tensor. It’ll be integration. LSP (Language Server Protocol) level stuff already exists for deprecations, many LSPs already do boilerplate warnings, so it’s composition from multiple well-known packages added on top to create more complex boiler plate and reduce the boring and repetitive stuff. Company wikis plus small local models can help employees find information faster about processes, rules and how to do their job. Personal harnesses like pi.dev that feel like what Neovim is for people who compose their editor, are tools that simplify creating your own harness tailored to you.

The tools to build this (RAG, MCP, Qdrant) are open-source, documented, affordable. The barrier is time and awareness, not permission from Scam Allmen. If you can write a Dockerfile you can deploy a local model. Guess what we’re good at, learning quickly, we have half the job done already.

The illusion of the threat to job security

Answering my questions at the top, will LLMs affect our job security. I don’t think so. The threat is idiots who employ you might think AI will replace you and cut costs. It is not a surprise, all LLMs talk like overcaffeinated CEOs. We’re the users, they are the buyers. The buyer doesn’t need to understand the product, they see a vision to sell shareholders and believe it since it is talking in his same grandiose unbelievable to everyone else (but shareholders) tone.

You don’t need to be mindful of the LLM, you have to be mindful of how stupid your boss might be.

The future will be companies using LLMs as another frontend to data. LLMs will handle repetitive (boilerplate) parts of your job but everything that needs expertise (things that can go wrong), judgement (which stack, which CI, which OS, which database), creativity (front-end design is ridiculously basic and generic with LLMs), debugging, knowing package details, privacy, keeps being you.

The real change comes from engineers building custom tools. While those waiting for OpenAI or Anthropic to package the same solutions get left behind. And it won’t be because their LLM is smarter, it’ll be because the harnesses they build fit their work as a glove same as your own Neovim config makes you objectively faster.

Another funny ironic thing is how the more companies try to replace us, the more they will need us to fix all the fuck ups of unmanaged code written by the idiots who thought LLMs were reliable enough to be trusted.

I do think demand for prompt engineers is going away on its own, that stuff was always shallow next to real expertise on your programming language and frameworks. What it turns into is a smaller, more realistically sized niche of engineers who know how to design systems that work with natural language, from helpdesk chats that do not make customers hate your company to apps that answer from the company wiki when someone asks in plain language. For devs it’ll be just an improved boilerplate generator.

Direct answers to the three questions

1. What can it do today? Fluent-ish text, images and audio and video, boilerplate, translation, brainstorming, and convincingly wrong answers unless you ground it with tools and sources.

2. How can it help or hurt my job? Helps on repetition, hurts when trust exceeds capability or when management believes the keynote.

3. Could it disrupt the economy or cost jobs? Money and attention will move. Mass unemployment of competent engineers isn’t what I’m seeing. The bubble that’s bursting is the idea that bigger closed models were the whole future. More like small models, clear tools, systems you own.

And again, none of this is A.G.I.

Have a good day!

For any questions find me in Mastodon as @maikel@vmst.io or in Twitter if you don’t mind waiting a hell of a lot longer since I’m a fediverse-first kind of person.

Living With Hidradenitis Suppurativa

I have hidradenitis suppurativa, stage 2. Living with it means constantly thinking about things most people never have to worry about: what I eat, how much I sleep, what clothes I wear, how stressed I am, and whether any of those things might trigger a flare.

The disease itself isn’t just painful — it’s disruptive. When cysts appear in the armpits, sleeping becomes difficult. When they appear in the groin or buttocks, even sitting can become painful. After decades of dealing with this and going through several surgeries, avoiding those situations has become something close to an obsession.

Over time one factor has stood out more clearly than anything else: body fat percentage. The lower my body fat is, the less often I get flares.

One explanation involves TNF-α, an inflammatory protein strongly associated with hidradenitis. Fat tissue is one of the places where TNF-α activity tends to be higher. Since people with HS already have elevated inflammatory signalling, carrying more body fat seems to make flare-ups easier to trigger.

Because I’m stage 2, keeping inflammation under control matters a lot. Surgery is something I really want to avoid repeating.

Why Fat Loss Matters So Much

For years the only reliable way I’ve found to manage this is by maintaining a relatively low body-fat percentage. The approach that works best for me is strength training. Building muscle makes it much harder for the body to accumulate fat, so keeping muscle mass high has always been part of the strategy.

I’ve been going to the gym consistently both before and after my last surgery. The goal wasn’t to become particularly big or strong — it was simply to keep fat levels low enough to reduce the chances of another flare.

But lately the strategy has started to run into a problem.

When Dieting Stops Working

I started doing cycles of bulking muscle and cutting fat more than six years ago. Back then, losing weight was relatively straightforward. I could drop around 20 kg in about three months without much trouble.

Hunger was never the limiting factor. My usual method was simple: I would start a cut with a 24-hour dry fast, which effectively reset my appetite and made the rest of the diet easy to maintain.

At 40, that approach doesn’t work anymore.

Part of the problem is medication. One of the drugs I take every day needs to be taken with roughly 400 calories of food, and it has to be taken at about the same time each day. That alone breaks the fasting routine that used to work so well.

Another complication comes from ADHD medication. I alternate between Elvanse and Medikinet, and both of them interact poorly with many of the supplements I used to rely on during cutting phases. Stimulants like caffeine or synephrine interfere with them, while other supplements such as forskolin or L-carnitine tend to create unpleasant side effects or blunt their effect.

Because of that, aggressive dieting isn’t really an option anymore. The only realistic strategy left is a slow caloric deficit.

Unfortunately that creates another issue.

The Inflammation Problem

The longer I stay in a dieting phase, the more likely it becomes that inflammation ramps up and cysts start appearing again.

I’ve experimented with a lot of different approaches: alternating weeks of dieting and normal eating, slower cuts, different calorie cycles. None of them solved the problem consistently. Eventually a cyst would appear and I’d have to abandon the cut entirely and go back to maintenance or bulking.

Over time the result of this cycle has been predictable.

I now weigh 97 kg, and while a lot of that is muscle, it’s also more mass than I ever intended to carry. Being heavier is starting to affect my back, and if I don’t interrupt this cycle it will only get worse.

Why I Decided to Try Wegovy

For a long time I’ve been following the research around semaglutide and other GLP-1 medications. Wegovy is essentially the weight-loss version of semaglutide — the same active ingredient used in Ozempic, but dosed specifically for obesity treatment.

Most people think of these drugs purely as appetite suppressants, but they actually do several things at once. They reduce appetite, slow stomach emptying, regulate blood sugar, and may also have anti-inflammatory effects.

That last point is what caught my attention.

If semaglutide really does reduce inflammatory signalling, it might help keep TNF-α activity lower while I’m dieting. In theory that could allow me to stay in a caloric deficit long enough to lose fat without triggering another hidradenitis flare.

Starting Dose

Last night I took 0.25 mg, which is the lowest available dose. This is the standard introductory dose used to let the body adjust before increasing it.

For now I’m deliberately staying low. I’m not actually looking for extreme appetite suppression. Hunger was never my biggest obstacle. What I’m really interested in is whether the medication can make dieting less inflammatory.

If the lowest dose already helps, I might never need to increase it.

Day One: What It Felt Like

The Morning

The first thing I noticed when I woke up was that I felt less hungry than usual. That’s one of the most commonly reported effects of GLP-1 drugs, so it wasn’t surprising.

My energy at the gym, however, was strange.

I had no problem getting up, preparing for the gym, and starting my workout. But halfway through my deadlift session I suddenly felt completely drained. My routine always begins with the two most important exercises in case I have to cut the session short, and that’s exactly what happened.

It was back day, and I managed to complete six total sets across two exercises. After that I was done.

I sat on a recumbent bike at the lowest resistance for about twenty minutes while my partner finished training. Even walking to the showers felt unusually heavy.

Another odd detail was body temperature. I had to wear my thick winter jacket on the way to the gym even though I’m usually someone who runs hot. My hands felt freezing the entire time.

That said, I’m not sure I can blame semaglutide for that. Something similar has happened before when Elvanse peaks during heavy workouts, especially on deadlift or leg days. Today I took it earlier than usual because GLP-1 drugs slow digestion, and the timing might simply have been off.

So that part remains a question mark. 2

Midday

After leaving the gym and have some sugary drink to counteract the low-blood sugar effect, I felt fine again and I remembered I had a lunch meeting with my former boss on the other side of the city. Getting there required walking uphill at a pretty fast pace, which surprisingly felt completely fine.

The interesting part happened when I sat down to eat.

Normally after a workout I’m ravenous. Instead I ordered two chicken fillets and a Mediterranean salad, and that was more than enough. The feeling was very similar to what happens after my usual 24-hour fasting reset, except this time I hadn’t fasted.

Something else felt different too.

People often describe GLP-1 medications as eliminating “food noise”. In my case it feels more like all mental noise is reduced. My brain simply feels calmer and more controlled.

Some people with ADHD report something similar on these drugs, and that description matches what I’m experiencing surprisingly well.

Digestion

So far there have been no digestive issues. If anything, my stomach actually feels better than usual. By this time of day I’m normally a bit bloated, but today that hasn’t happened.

What I Actually Ate Today

Despite going to the gym, my total intake so far has been fairly small. I’ve had a protein shake with creatine, two chicken fillets, a Mediterranean salad with olive oil and vinegar, and a few drinks throughout the day: an orange Fanta, a sugar-free Aquarius, a glass of Albariño wine, and a small espresso.

The espresso was necessary — my digestion is already slow even without semaglutide, and I suspected those chicken fillets might otherwise stay in my stomach until next year.

Interestingly, the salad tasted fantastic, while the heavier dishes on the menu looked strangely unappealing. That’s very unusual for me after training. Normally after deadlifting 80 kg for three sets of ten repetitions, I feel like I could eat an entire cow, farmer included.

Mood and Energy

Mood-wise I feel calm and focused, without any irritability.

Energy levels are harder to judge because the early gym crash complicates things. But after drinking the Fanta I recovered quickly, and walking uphill across the city didn’t feel difficult at all. Now, late in the afternoon, I also haven’t experienced the usual crash that tends to happen after lunch.

Interaction With ADHD Medication

Today wasn’t the ideal test because Elvanse peaked earlier than expected.

Normally I alternate between Elvanse (50 mg) and Medikinet (60 mg). For reasons I still don’t fully understand, both medications seem to work better for me when they’re alternated instead of taken continuously. It is as if I develop tolerance if I continue with the same but not when I alternate.

Tomorrow I’ll repeat the experiment with Medikinet and see whether the experience feels different. Back on Elvanse the day after I will take it later.

Realistically it will probably take several days before I can separate normal fluctuations from actual effects of the medication.

Early Thoughts

It’s obviously far too early to draw strong conclusions, but the first day with Wegovy has been interesting.

The most noticeable differences so far are the near absence of cravings, a much smaller appetite after training, and a general sense of mental quietness that I didn’t expect and are making me considering even trialing a few days ADHD meds free.

If those effects remain consistent over time, semaglutide might finally make it possible to lose fat without triggering hidradenitis flare-ups. And if that turns out to be true, it could change the way I manage this disease entirely. Reducing the time left to achieve 11% body fat and forget about it for good to merely months.

I recently survived showing someone sparkr_private, a repo containing a prototype version of Sparkr I built in React Native within a week. The goal wasn’t to build production code. It was to rapidly test feasibility of ideas, disposing of concepts quickly just to see what could actually be possible based on ideas in my head.

The result? Shameful code. Heavily written with the help of LLMs (specifically Cursor), it’s 100% slop built on top of slop, designed to answer one question after another:

1. Is this possible? Yes.
2. Ok, is this possible? Yes, ok, next.
3. Is this possible? Yes, ok, next.
4. Is this possible? No? Ohhh, what if I do it this way? Yes, ok next.

Rinse and repeat until I had all my questions answered.

The code individually worked, but integrated would probably make any mobile phone explode. There were no test suites, just monkey trialing after each idea. No integration tests. Once a feature was proved feasible I run the app on my phone, tested it manually, then I read the code to understand how, then I moved onto checking how the next one could be done. I guarantee you most new ideas broke the previous ones. I’m still debating with myself whether to make that code public.

But here’s the thing: it worked for its purpose. I learned that NIP-17 e2ee direct chat was possible (even if implemented in extremely wasteful and verbose ways) to add to a chatting app easily. I proved uploading facepics using free-to-use Blossom relays could work. I validated a grid directory system based on relays passed via app signature, posted in public relays.

From there onwards, I had all I needed to know it was feasible.

The Only Valid Use Case

After this experiment, I’ve found the only valid use case for LLMs in software development: testing feasibility of random ideas on disposable code to motivate yourself enough to code them yourself.

Once you’ve seen it, you want to make it real. You’re no longer working with an idea in your head. You answered each and every question you could have about it, to completion, and saw its full potential. It’s a bit like experiencing the joy of seeing your own children grow up and get married, knowing you made it happen, you raised a good kid, before actually deciding to have children. There’s no what if, there’s only a clear path. There’s no scrum or agile ever changing requirements, you’ve gone from specification to final broken thing that kind of works. There’s no ifs, there’s no uncertainty. You’ve seen it, had it in your hands, made of your ideas. Ignore the code, you just wanted to know if it could exist. You know now it can exist. It is a certainty.

Or, put another way: helping you gather answers to all the burning questions you might have on a software project before you write the first line of actual decent code.

This is genuinely useful. When you’re exploring a new domain, trying to understand if something is technically possible, or rapidly prototyping to validate concepts, discard what you figure doesn’t work and move onto quicker into alternative options.

But that’s where it ends.

Where LLMs Fail Catastrophically

If you’re thinking about using LLMs for actual software development, here’s where they IMHO fall apart:

1. Elegance

LLMs don’t understand elegance. They don’t grasp clean architecture, beautiful abstractions, or thoughtful design patterns. They’ll give you code that works, but it’s the software equivalent of a functional but ugly building. It stands, but you wouldn’t want to live in it. Stupid ridiculous thing never had to pass an exam on algorithms, data structure or Big O notation, you did.

They’ll write stuff like this 👇

function doStuff(a, b, c) {
  if (a != null) {
    if (a !== undefined) {
      if (a !== "") {
        if (b == true) {
          if (c > 0) {
            console.log("doing stuff");
            for (var i = 0; i < c; i++) {
              setTimeout(function () {
                console.log(a);
              }, 1000);
            }
          }
        }
      }
    }
  }
}

There are some basic principles of software development that they simply ignore:

• KISS, they write incredibly long lines of code with no specialisation or compartimentalisation in smaller functions, it’s untestable due to how long and how many variables it depends on .
• DRY, they write the same lines across entire codebases again and again.
• ….you can find the whole damn list here in Wikipedia. No one who’s studied software engineering would be unaware of the existence of those and many other rules.

Anyone who’s coded for a couple of years can easily identify code written by a LLM compared to code written by a human.

2. Refactoring and Global View

Ask an LLM to refactor code, and you’ll get a mess. They don’t understand the subtle relationships between components, the reasons behind certain design decisions, or how to improve code while maintaining its integrity. They’ll change things that shouldn’t be changed and leave problems that should be fixed.

They’re terrible at handling project specific requirements, domain knowledge, or nuanced business logic. They’ll give you generic solutions that don’t quite fit your actual needs. The devil is in the details, and LLMs are detail blind because they can’t see things globally. Why? Context. Remember, they aren’t human.

I’ll talk more about this context thing later, but this is what makes them behave like elderly people with 👇 and the main reason I’ll never fear them.

3. Testing

Tests written by LLMs are awful. They test the wrong things, is not that they miss edge cases, but that they implementation details rather than behavior. Good testing requires understanding the system, its requirements, and potential failure modes, all things LLMs struggle with because of a lack of a global view. Context, my friend, that’s why you’ll always have a job.

4. Anything Involving Refinement

LLMs are one-shot generators. They don’t iterate well. They don’t learn from feedback in a meaningful way. Real software development is iterative refinement, taking something that works and making it better, cleaner, more maintainable. LLMs can’t do this. You can tell them to rewrite the same function ten times and I gurantee you by the fourth time you’ll get again the first version. Again, why? Repeat after me: context.

5. Language Support Beyond Python and JavaScript

LLMs fail catastrophically at any language that’s not Python or JavaScript. In Elixir, for example, they even make up non-existent functions of core modules. They’ll confidently suggest core-language functions that don’t exist, use incorrect syntax, and provide solutions that simply won’t compile or run. Let alone they are dated by design. Why do you think their best language for any of them to prototype with is JavaScript?

The “Junior Dev” Fallacy

People who defend LLMs as if they were the 2nd cumming (typo intended) of Jesuschrist often say:

It’s like sitting with a junior developer.

A junior developer thinks. They ask questions. They learn. They make mistakes and understand why they made them. They grow their knowledge, they refine, they get better. They bring human judgment, creativity, and reasoning to the table.

An LLM vomits. It generates text based on patterns it’s seen, without understanding, without reasoning, without the ability to truly learn from context in the way a human does.

But here’s the critical difference that makes human coders irreplaceable: context.

What do you even mean with “context” Maikel?

A human developer can maintain a massively humongous context. They can hold in their head the entire architecture of a system, understand how components interact, remember why certain decisions were made months if not years ago, see the big picture and the small details simultaneously. They can trace through code mentally, understand the flow of data, see relationships that aren’t explicitly documented, and make connections across the entire codebase. They have a global vision.

I have ADHD yet unlike most, when I’m unmedicated, my working memory is so large I can hold in my head the entire architecture of an idea for weeks if not months. I can think through complex systems, see how everything connects, and maintain that mental model continuously while I try pseudocode in my head.An LLM can’t do more than a few prompts without forgetting the entire subject. Even the most advanced models with massive context windows can’t maintain that kind of persistent, deep understanding. They reset. They forget. They can’t hold onto the architecture the way a human mind can.

That’s what context means for an LLM. he bigger the context size, the slower they get and they all have this limitation. They’ll never get global-type of understanding to any codebase unless it is so tiny it fits entirely in their context, together with the much larger amount of reasoning of what it does, why it does it, etc.

Any LLM, even with the largest context windows available, fails precisely where humans excel. Context windows are limited. They can’t truly “remember” beyond what’s in the current conversation. They can’t maintain the kind of deep, interconnected understanding that a human developer builds over time working with a codebase. They process text, not meaning. They see tokens, not systems.

This is where human coders will always prevail. Real software development isn’t about writing isolated functions. It’s about understanding complex systems, maintaining mental models of how everything fits together, and making decisions that consider the entire context of the project, its history, its future, and its constraints. LLMs can’t do this. They can only work with what’s explicitly in their context window, and even then, they don’t truly understand it.

The Professional’s Approach that IMHO should be the gold-standard on LLM usage

So how do you use LLMs without destroying your career or your codebase?

First, assume their knowledge is based on inaccuracies. Don’t ask them if something is feasible. Direct them to code your idea, so you can see with your own eyes if it is and fix what it gets wrong.Never use LLMs as juries of what is possible. Never take their opinion. They aren’t people, they are all snake oil salesmen. Their job is to sound knowledgeable, not to produce actual knowledge. Do you think the guy at MediaMarkt has any clue of the actual power of an i7-13123 vs an AMD Ryzen 7 Gen 8 v2.5 (I just made up tha last part)? His job is neither to draw sillicon logic in ever shrinking transistor size, with an ever increasing set of instructions to process things ever quicker, using ever more complicated manufacturing processses. Nope, that’s not his job, his job is to sell.

So instead focus on making them do quickly the prototypes of ideas you had in your head. Think of it as a feedback loop overcharged of the ideas that you will ask yourself over a number of weeks, in just days or 24 hours. But ultimately the machine would answer them a lot quicker, just a lot less accurately and more constrained. The prototype you end up with is just one of hundreds of millions of possibilities. The box cannot think outside the box. YOU CAN.

1. Use a Different Language for Prototyping one you don’t care much about

Never use an LLM for the final programming language you’re going to use. Only use it for with shite error-ignoring-prone languages that you don’t get paid professionally to use anymore, like JavaScript (if that’s not your main language).

Why? This ensures your knowledge of your food-on-the-table language remains intact due to constant use unaided. It also avoids future licensing issues. Most importantly, it makes copy and paste between prototype and final product impossible.

So prototype ideas on a shite language, write them yourself on the proper one.

2. Never Use It With Your Professional Language or the one you feel passionate about

If JavaScript is your professional language, use Python for prototyping. The separation is crucial.

Here’s my personal approach: JavaScript was my professional language for quite a while. I can still read it and code in React, Angular, React Native, or NativeScript when designing quick prototypes for Android, Angular was paying the bills. But I haven’t used it professionally in a very long time, nor do I think I will. My main decent languages that I get paid sustenance money for are Elixir, which I deeply love, and hopefully soon Kotlin, which finally covers the problems of Java’s obsessive OOP, and finally able to do what React Native had for me: multiplatform, thanks to Kotlin Multiplatform.

I need to know what I’m doing with these languages, so no LLMs with them. Even better if you can use pseudocode for prototyping. Pseudocode lets you think through the logic and architecture without committing to any specific language, and then you can implement it properly in your professional language yourself. This maintains your skills while still allowing you to rapidly prototype ideas.

We need to compartmentalize: code we write from code LLMs produce. The best way is to use it to understand a concept, read through it, close the fucking tool, and force yourself to write from scratch the code yourself in that different language. As I said before: test the feasibility of ideas, never their actual implementation.

The main reason is the one I mentioned earlier, licensing issues. Imagine you work on a project, you worked aided by some LLM and then months down the line you discover your code comes (inevitably) from copyrighted code with an incompatible viral license to what you’ve “written” for someone else. I’m not talking about some for loop, I’m talking about those naive fake-fluencers trying to sell you books, seminars, and other bullshit, about completely code-free coding using agentic-mode only. There’s no way they aren’t ending up with large sections of “their” code being copyright-breaking material with lawyers in-waiting. This is going to probably end up being so big, these kinds of ads will have to be created with different banner “has your code being used in a large codebase elsewhere, no win, no fee”.

3. Use Local Models When Possible

Swap for local models with tools like Ollama as soon as you can. But be VERY aware: they are a black box. Every line of code out of an LLM is code stolen from somewhere and that somewhere clearly has a license just as much as anything sucked by a commercial-provider. NEVER copy and paste.

Even with local models, you’re dealing with code that was trained on, always assume, copyrighted material. The licensing implications are enough to remember you cannot and should not use their code.

The local models have a big advantage: nothing leaves your PC. The code you write, using a commercial LLM, always end up on someone else’s server. Cursor has a setting to keep thinks locally, I assume that setting is misleading.Never put the code you write for one of your clients on LLMs but specially online ones. Assume the company behind it is harvesting your prompts for further refinement of the model, and that everything you enter on it, will be used by someone else later. You might be digging your grave.

4. Never Invest in This Tech

Don’t buy GPUs to use them locally, don’t get the greatest 64 GB Apple Sillicon laptop to try different models locally, unless you have the spare funds. Assume it’ll vanish into thin air. Don’t put your value on requiring them. Never develop dependency on them.

Nothing depreciates faster than software, and this is clearly an unsustainable bubble on snakeoil sales-speech software.

You’ve lived through Uber, Airbnb, and other venture capitalistic cunts. You know what OpenAI and others will do. This shit is cheap now, it’ll cost 10 times more in the near future. They are burning through VC cash to get you hooked into it. Same as Uber did while destroying their local taxi competitors, and now they are pricier than local taxis. Same as Starbucks does opening multiple stores to asphyxiate the competitors. It’s all the same strategy: cheap now, gets you hooked, become a commodity, then raise the prices.

Don’t build your career or your projects on something that will become unaffordable once they’ve eliminated the competition and you’re locked in.

The LocalLLM market is entirely different, and for certain do investigate on it for fun as much as you’d like as I think this sub-are of LLMs is what will eventually rise victorious.

5. Maintain Self-Control

All of this requires self control. How much of an adult are you? How much do you value your employability?

The temptation to use LLMs for “real” work is strong. Short term might feel like you can do one week’s worth of work in an couple of hours. But in the long term, it erodes your skills, creates technical debt, produces code that’s harder to maintain, and makes you dependent on a service that will become eventually either unaffordable to you or unusable due to licensing issues.

Think about this: if running a local LLM that produces anything near the quality of Cursor’s default model costs you a humongous debt in computer components, what incentive do the already existing commercial ones have to NOT eventually raise what they charge for it. They aren’t NGOs, they are all for-profit companies.

It’s a fad, it’ll go and evolve into mini-local LLM models.

Conclussion, why the rubbish image and why our Future is Safe

I don’t think professional software development is going anywhere in favour of machines doing it.

The people who will ignore this advice? Clearly those who don’t work professionally as coders. Professional developers understand that code isn’t just about making something work, it’s about making something work well, maintainably, and elegantly. It’s like raising a kid.

But I don’t think we’re through the worse yet. I think first, will come the commodifying of LLMs, getting as many people hooked as possible, second the hiking of the prices, third, the selling of the convenience of commercial ones compared to local LLMs, then legislation will FINALLY catch up (if ever) and burst the bubble of the commercial ones (that’s where the injury-lawyer industry re-focus will happen into some major copyright battles), then some local LLMs will become easier to understand and run, then there’ll be probably more openness (enforced by the law, probably the EU first) about the source of LLMs “knowledge” and finally purpose-built per coding-language and ecosystem language models. Tiny thematicals LLMs capable of requiring less power since they are focused on a single thematic task (like, future Jetpack Compose UI generators).

I’m expecting the bubbele to burst spectacularly and in a similar way the housing crash did since we’re humans, which means, our context window is neither infinite and love repeating our own mistakes. Every bank surely has directly or indirectly invested in this crap, and the moment OpenAI crash we’ll have another Lehman Brothers moment

OpenAI is the new Lehman Brothers

Now, why that image? Because when I think of Sillicon Valley and Big Tech™️, that’s what comes to my mind: rubbish and people going through it, trying to find value. Yet instead of looking in the recyclable bin, where by definition it is easier to find something that worked in the past and refine it, they look into the non-recyclable one, the one filled with dog poo and cat litter, and try to sell it to us as The Cum of Christ, Microsoft is particularly guilty of this, no matter how many times people shout at them “I don’t want to eat a used diaper” they persistently repeat “now with Premium Poo”👇

LLMs are a tool. Like any tool, they’re useful for specific tasks and terrible for others. Use them for what they’re good at: rapid feasibility testing on disposable code. Don’t use them for what they’re bad at: actual software development.

Our future is safe because professional software development requires skills that LLMs simply won’t ever have due to their main limitation: context.

The developers who will thrive are the ones who understand this distinction and maintain their skills accordingly. The ones that will have to re-skill themselves into some other industry are those who fell for the vibe-coding fad.

Thanks for coming to my house, tip your waitress. Byyeeeee!

Quick mandatory reminder 👇

Some issues I’ve encountered from trying to operate in a way I am not used to

I think the main issue we’ve got to discuss globally is the fact I’ve functioned 39 years more or less succesffully without any medication. That means I have 39 years of workarounds and systems put in place, and behaviours to control what I thought was generic distractability and procrastination. For the most part, my ADHD only bothers me half the day when I’m not medicated, when these ways have exhausted my brain as even as hardcoded as they are, they are still forcing a machine to work in ways it shouldn’t be doing.

The main good thing: On meds I start lots of things that I normally don’t even have the drive to start, and I would do them to completion, but in the path to that; the main bad thing: everything else gets accumulated.

1. Priorities are hard to measure with extra dopamine

Without any extra dopamine all tasks feel as if they have the same weight so when you try to trust your guts and do what “feels right” you’re indeed doing what reason tells you it is right.

With dopamine in abundance, that doesn’t work, what feel rights is actually a scale of different things, the ones you do enjoy have a much bigger weight and the ones that were reasonably important become somehow less so. It’s ridiculously easy to lose track on something you were even slightly passionate about and realise when it is too late in the day.

Deciding on priorities is a lot harder off the meds. I cannot stop a task until I finish it with meds, the problem is that task might not be the most important one for that day.

2. The Sargent™️ is missing and LIFO does not work.

Unmedicated I normally have this inner voice I call “The Sargent” that reminds me what’s the main task I’m doing every few minutes and what other things I have to do, so I don’t lose track of what I’m doing with some distraction. That voice is gone now. So what keeps me on track is now passion, which is easy to let myself get carried away with.

So my days require a lot more planning because whatever I’m doing I’m going to lose track of any other thing I had to do that day unless I keep checking.

Normally, unmedicated LIFO (last-in, first-out) works, I can be doing a main task and distractions come in that are necessary to remove to carry on with main task. This stack scheduling does not work at all medicated. The stack just keeps getting bigger because I keep forgetting the main task and getting carried away. So the only thing that works for me is to outsource The Sargent.

I have a humongous Fish shell script that prints a banner with the main task, duration, when I stated and whenever I get distracted, I run another command from that script file to record the distraction. The whole system is markdown based and kept in my obsidian vault, except the Fish shell file. So today for that we get this, so far: Without this artificial version of The Sargent, I wouldn’t get anything done at all. So I’m introducing automation left and right to avoid making decisions the whole day and wasting hours on analysis paralysis.

I’m also going to rewrite this tool to remind me every 5 minutes of the task I’m doing instead, I just need to figure how to disable all other desktop notifications in the process.

4. Tyrosine matters

This is plain simple, less than 1 gram of tyrosine supplementation per day and the effects of Elvanse (Medikinet too) were jerky or erratic. Get the gram of tyrosine (at least first thing together with the Elvanse) and the effect just maintains the whole day.

So now I’m force to supplement myself with tyrosine. At least is cheap.

5. Sleeping is better but more rigid in some ways and flexible in others

I’m slowly realising I can sleep anytime, at any moment when I want to do so, but under some rules. Being able to put the mind in blank is the main rule, which I can do under the effect of the meds. Once the effect starts to fade it becomes increasingly harder.

It doesn’t matter much when I wake up, what I’m realising matters the most is that I stay consistent in the time I take the pill. I can take it at 7am every day and still go back to sleep. If I don’t, and I take it whenever I wake up and that time is noon, I’m going to struggle to go to sleep early that day, and then we enter a vicious circle of taking the pill each day later and going to sleep later. So taking the medication at the exact same time every day is crucial, more so than waking up every day at the same hour.

So now I have the pill prepared with a lot of water by the bed with the tyrosine.

6. Discovering I’m a workaholic and how this is negative

I’ve got lots of drive but in too many directions which generates procrastination by analysis paralysis. I want to:

• go to the gym
• lose fat (not weight)
• have a sleep schedule
• work
• study something new
• learn Kotlin
• code Sparkr

Each one of those have sub-tasks, and trying to do them without a system to set priorities nor The Sargent™️ is close to impossible. I end up picking up one and sticking to it most of the day completely forgetting of the existence of the other ones.

7. The rulebook changes in winter with less sun

A seasonal-affective disorder (SAD) light is not optional. It’s mandatory if I want to work the whole day with the big PC. I might feel i have enough energy but nope, if I don’t keep it on most of the day (it’s a small one) then I’m going to feel tired at lot earlier. At least during winter or while living in a dark place, which I am, at the moment.

8. Task lock awareness or excessive drive actually has a name

This is connected with number 1 and number 3 and it’s part of the default-mode network. That’s an area of the brain ADHDers have overdeveloped, and is in charge among many other things of the voice (or voices) we hear on our minds while we think.

That voice is my scheduler, with it going quiet or having zero independence, I lose the ability to realise I’ve been hours on the same task. It’s also the reason I can’t stand methylphenidate since it makes that voice completely silent while lisdexamphetamine give me more flexibility with it. At the same time, I feel like I’m so used to having “The Sargent” that internally I keep fighting the effects of the pill and if it weren’t for the total emotional regulation I would rather never take these meds.

9. The role of the time the pill is taken and how your reward system is different

Going to the gym is a nightmare on Elvanse because it makes me sweat thrice as much and be a lot thirstier. Unfortunately taking it after the gym is impossible, because without it, I simply never leave the bed. Elvanse sets a new baseline for what “minimum energy levels” is required to jumpstart your day. This is why I rather take it and go back to bed, than wait until I’m fully awake and then take it.

While unmedicated, I just wake up and go to the gym. Every task feels the same ( = nothing) until I am actually finishing the task and THEN I get my dopamine reward. I get the motivation to go to the gym from chasing that high, the one I get when I hit the shower and I know I completed my workout, not from working out itself.

With Elvanse, this reward system is heavily modified. When I’m there I’m only there, I forget to even play music on my headphones. When I lift, I compete strongly with what I normally can lift, a lot more than usual. But on Elvanse working out is no longer something I do chasing the joy of having done it, but something that I do chasing the knowledge that I’m killing records. Which means a lot more ego-lifting than usual and I have to re-calibrate constantly to remember I’m on Elvanse and my perception of max weight is not what it’s healthy.

10. Bullet time is gone

Remember that bullet time thing you got at the beginning on Elvanse, that’s long gone. Not because suddenly time has slowed down, but because you are so long with it that you stop perceiving the difference. The days I do not take the meds, time feels nearly the same too, you do notice it flies quicker but still doesn’t feel as before the meds.

11. Still got ADHD issues just different ones

• Procrastination is gone, I can do whatever I want at all times, in exchange I have a harder time to figure what I want.
• I’m getting messier, without a voice in my head reminding me stuff I keep forgetting keys, buying groceries, cleaning the house. This is a common ADHD issue but I don’t have it off meds because I weaponized that internal distracting voice into what I call The Sargent.
• Setting priorities is very hard.
• My time perception is awful now.
• I have working memory issues always on meds, I can’t hold unrelated data in my mind.

12. What happens on rest days and why I can’t be more than 2 days without meds.

The positives:

• I can hold humongous amount of unrelated data
• The Sargent is back, I don’t need TO-DO lists anymore.
• Global views on source code are easier to maintain.
• I can code in my head.
• I’m a lot more aware of my body and sensations.
• Going to the gym and enjoying it is a lot easier because I’m used to delayed rewards.

The negatives:

• They all happen in the afternoon
• I’m exhausted, mentally exhausted.
• I’m incredibly hungry, and overeat.
• Noise is a nightmare, especially when there’s too much and is unpredictable. Is like being in twitchy, jumpy mode.
• I can’t sleep, I have no control of my default-mode network. I can only sleep by physical exhaustion.
• I’m very irritable with everyone around me and spending humongous amounts of mental energy trying to not get irritated for things that I know shouldn’t bother me that much.
• I can’t stop yawning.
• Out-of-nowhere anxiety starts crippling in, a baseline anxiety that I had my entire life off-meds and I don’t have in the slightest on meds. Financial worries are the biggest ones crippling in. While on meds, I can focus on finding solutions instead of constantly enumerating the problems in my head.

The negatives don’t happen the first day off meds, they start to happen toward the ending of the 2nd day meds free, and they always come with an immediate and huge craving for caffeine.

13. I tried splitting my dosages and it only gives me anxiety

I have all the crazy chemistry doctor material to split my Elvanse dosages in whatever amounts of mutiple of 10 miligrams. Nothing works. It’s got to be 50mg, any less than 50mg and all I have is anxiety. Only 50 reaches the threshold to build up the necessary dopamine to have more positives than negatives. Thirty only works when I’ve woken up really late and take it in the afternoon.

This has made me consider the option of changing into 30mgs and spending half day off meds, the other half with meds so I get to enjoy my favourite “me” format. But it’s jerky. 30mg works when it’s the pills, when it’s the split dosage, it can keep me awake at night. I’m not going to spend 83€ on 30mg pills.

14. Bad trips

Not all days are perfect, some days I have really really bad effect and the memory issues are even worse. Then the inability to stretch my attention span enough to remember what I’m doing starts to make me feel anxious. The worst day this happened, it literally feels like having early-onset Alzheimer. It took me 3 hours to remember the main task I was doing was moving the shoes from mine and Remi’s bedroom into the entrance shoes cabinet. Can you imagine the desparation of seeing the time fly while you spend it trying to remember what were you doing? You don’t have even short-term memory enough to be able to reach a notepad or Obsidian to write it.

It fucks my short-term memory more than my working one. But, as I said, that’s on the odd bad trip day which usually happen before I decide to take a couple of days off the meds. Those days are usually the reason I’d rather stop the meds altogether or even try the 30mg option. But right now what I’m studying the most is the modifying power of naps since that will dictate in the near future my dosage or even choice of med.

15. Why I find cycling meds on and meds off is so necessary?

Memory. Each state of mind (med/unmed) changes the way my memory works and what I have more easily accessible. I tend to forget the cons of being unmedicated after long time medicated, and the same happens the other way. Both are bad. None are optimal. The solution is definitely going to be self-directed cognitive-behavioral therapy (CBT) which I’m already doing every time I write this posts.

The key to figure out my strength, weakness and behavioral patterns I need to change is to figure which ones worked and which ones didn’t. I only get that perspective swapping from one to the other. Everything I learn while medicated is stuff I apply later unmedicated with the hope of eventually stopping meds altogether.

What I’ve learnt so far that will eventually help me take no meds.

1. What I thought were distractions were actually necessary aids to keep focus

I do watch a shitload of TV and can’t do anything without music in the background. The gym is the moment of the day where I go through my “discovery weekly” playlist and classify what I like from what I don’t. I’m normally following the rhythm of the music when I do so. I don’t think about it, I just do. It’s the background task that keeps me focused. The passive thing you do without paying much attention to it, that somehow keeps the most distracting inner dialogue from focusing on…distracting me.

On medication watching TV bores me, but because it normally does and I can do it without paying much attention to it. Medicated it becomes the main task and is simply not enough interesting.

2. The Sargent™️ has a cost

Maintaining the voice that every couple of minutes reminds me of what I have to do, to take the keys when going out, that the house is filthy, that I need to shower, that the fridge is empty…is the main reason my brain gets exhausted. I cannot turn it off unmedicated, too many years of practice.

But I can refrain from feeding it by writing down what I’ve got to do. This sounds easier than it is, because that voice is capable of sorting out priorities and take quick decisions on the fly, while writing down implies doing all that in advance and learning which tasks shouldn’t need remembering.

3. The humongous working memory or internal blackboard also has a cost

I can code in my head, I can explore solutions without typing a single line. Together with the sargent this has another humongous costs and is probably the reason I get mentally exhausted by the afternoon. While I’m fine I don’t even feel any effort in doing this I just keep getting progressively tired until at some point of the day, its gets a life of its own and feels like being enclosed in the Architect room of The Matrix with all the screens as the same volume claiming for your attention.

Again, the solution is of course to use it less, but how do you do that when it feels effortless to use. It’s easy in the case of the sargent, but maintaining humongous abstractions gives you a lot of speed. Is like running a full OS from RAM instead of hard drive.

This is the main thing I need to fix to be pill free. And so far all I’ve got is that I don’t have access to either while medicated. e.g: the abstractions on meds can be just as large but they are thinner, more specific, less global. Without meds I don’t need to re-read this entire article to avoid repeating myself, I would know what I wrote, while medicated I do because each paragraph is a different issue.

And none of that is giving me yet a clue on how to avoid using the full available bandwidth unmedicated. So far all I got is that I can reset it by having a nap.

4. Napping is the key to everything

When I was a kid, something that I can only remember on meds because it expands the access and reach of my long-term memory, is that every afternoon I could spend ~4 hours sitting on sofa with nothing but myself, I wasn’t bored, nor I had my eyes closed, even though I surely would have loved to do so and fall sleep and indeed sometimes I did, I was just letting go.

When I reached exhaustion and was overwhelmed by my own brain I just relaxed by becoming an spectator. There was nothing to fear, I’ve always known in the afternoon that I would feel exhausted until I got my second wind. What I didn’t know until the diagnose is that it was untreated ADHD the reason.

So I would just sit comfortably in the nicest sofa around in my home and daydream until I eventually had a short nap or the exhaustion vanished.

The thing is on meds, I can just fall anytime. I’m definitely planning to do so after finishing this awful thing that is already consuming 6 hours of my time. But without meds I cannot. So I need to figure how to transfer that skill from medicated to unmedicated. Because if I can have a nap then I can be unmedicated and in the right side of my ADHD symptoms the whole day.

5. Memory might not be erratic just different

Remember what I’ve just written, on medication I can remember things from the very-long-ago past better while my short-term and working memory are normally limited, while other days the short-term is kind of frustratingly non-existent.

But what if that’s what’s normal.

I have the theory that I’ve somehow specialised my brain in recycling the space for long-term memory in exchange for a bigger daily working memory. I notice same I can remember with 10x more detail what happened around the city where I live, street names, where to find stuff, etc from the most immediate past, I erase the stuff I don’t care about from the far past very quickly while everybody around me can remember stuff from their childhood that I do not and for them is not normal I cannot, while for me, it is. e.g.: each generation has a cartoon they were addicted to, mine was Dragon Ball. I can’t barely remember anything about it, not even names, while Adrian that is my same generation can tell me entire plotlines. And I do know I was addicted to those cartoons but I know it is information I did not care at all about storing.

I’m yet to meet someone else that can semi-consciously decide what information to delete.

6. Emotional disregulation is 100% tied to mental exhaustion

Once I cannot control my inner monologue, I can’t do anything at will other than rest. So my body becomes this 1-goal zombie that only wants one thing: to rest. And anyone standing in the way between me and rest they’re going to get run over and there’s nothing I can do about it other than subtract myself from their presence as I’m a ticking bomb with no control over what they say to be left alone and sleep.

7. Decision fatigue is a big issue

The Sargent does spend a humongous amount of energy moving priorities. In this sense there’s a feedback loop between it and the abuse of the bandwidth of my working memory. You can take better decisions when you have as many possibilities displayed in your mind’s eye as possible.

The solution is to delegate. To who? To me in the past. Decide ahead of the future, in small chunks. Avoid my daily routine to have menial decisions. Decisions are decisions big or small, the less you take, the less decision fatigue. If I can get rid off the smaller ones, then I’m further from suffering it.

Also, just doing what’s right instead of what’s optimal helps. What’s optimal never gets an immediate answer, what’s right always does.

8. Measure times

I’m making tasks that take really little time a lot longer by overthinking them, I should be measuring how long do they take me and challenge that timing.

9. Small increments

Only small changes stick but they have to be so simple and dumbed down that they are effortless. Like, instead of focusing on trying to wake up to go to the gym, focus on not taking the pill at 7am independently of leaving the bed or carrying on sleeping.

Conclusion

In a nutshell meds-free life is going to be:

• Learning to not abuse and instead protect my bandwidth, by using it as little as possible, and changing ways I do stuff to save it for when I actually need it. e.g.: actually writing to-do lists.
• avoid analysis paralysis and decision fatigue as anything involving this, will undoubtedly make me think globally.
• Use meds as a tool to build new systems, then lean on external scaffolding. Don’t rely on internal memory or the “Sargent” voice.
• Cycle between medicated and unmedicated states to test what works and learn from each mode.

Manage mental energy smarter: naps, pacing, and avoiding afternoon crashes that make meds be necessary.

A partir de ahora, inquilinos y propietarios deberán adaptarse a un nuevo marco legal que incluye un índice de precios de referencia, límites para grandes tenedores y beneficios fiscales para los pequeños arrendadores que ajusten las rentas.

📊 El nuevo Sistema Estatal de Referencia de Precios de Alquiler

Una de las principales herramientas de esta regulación es el Sistema Estatal de Referencia de Precios de Alquiler de Vivienda, creado por el Ministerio de Vivienda. Esta aplicación oficial permite conocer el precio de referencia de una vivienda a partir de datos tributarios sobre arrendamientos habituales, considerando superficie, ubicación, antigüedad, estado o eficiencia energética. 💡 Ejemplo: para un piso de 90 m² en A Coruña, el precio de referencia puede variar desde 377 € en Agra do Orzán hasta 825 € en la plaza de Lugo.

📍 Cuadro de precios orientativos por zonas (vivienda tipo de 90 m²)

📈 El precio medio actual del mercado en A Coruña ronda los 730 €/mes, según el Instituto Galego de Vivenda e Solo (IGVS).

En portales como Idealista, dos tercios de los pisos en oferta superan los 900 €, lo que confirma la brecha entre la realidad del mercado y el índice estatal.

⚖️ Quién debe aplicar el índice de referencia

Según la Ley de Vivienda, el índice no afecta a todos los propietarios por igual:

• Grandes tenedores (dueños de más de 10 viviendas) deben ajustarse obligatoriamente al índice al firmar un nuevo contrato en una zona tensionada.
• Pequeños propietarios solo deben hacerlo si:
  • Firman un nuevo contrato en una zona tensionada, y
  • El piso no ha estado alquilado en los últimos 5 años.

El Ministerio no fija un precio único, sino una horquilla mínima y máxima, que permite flexibilidad según las características del inmueble (planta, antigüedad, certificación energética, etc.).

🏠 Reglas clave de los contratos en zonas tensionadas

1. Limitación de rentas

• Si el piso ya estaba alquilado en los últimos 5 años, el nuevo contrato no puede superar la renta anterior actualizada con el índice permitido.
• Si nunca se alquiló o lleva más de 5 años vacío, el precio máximo será el del índice estatal correspondiente.

2. Actualización anual

• En 2025, la subida máxima será del 3 %.
• A partir de 2026, se aplicará un nuevo índice (aún pendiente de definir).

3. Duración y prórrogas

• Contratos de 5 años (propietarios particulares) o 7 años (personas jurídicas).
• En zonas tensionadas, el inquilino puede pedir una prórroga adicional de hasta 3 años, salvo causa justificada de necesidad del propietario.

4. Registro autonómico

• Todos los contratos deben inscribirse en el registro de arrendamientos de Galicia.
• La Xunta podrá inspeccionar y sancionar incumplimientos del límite de precios.

💰 Beneficios fiscales e infracciones

Incentivos

Los propietarios que ajusten el precio a los límites y ofrezcan estabilidad pueden obtener bonificaciones de hasta el 90 % en el IRPF por los ingresos del alquiler, siempre que cumplan con los requisitos de duración y referencia del índice.

Sanciones

El incumplimiento de la normativa puede acarrear consecuencias graves:

• Multas de hasta 60.000 € por infracciones muy graves.
• Nulidad de las cláusulas abusivas.
• Pérdida de beneficios fiscales aplicados indebidamente.
• Inspección y sanción administrativa si se detectan rentas fuera del índice.

🔍 Impacto en el mercado de A Coruña

Efectos esperados:

• Mayor transparencia en los precios.
• Incentivo para rehabilitar viviendas vacías.
• Estabilidad para inquilinos y previsibilidad para propietarios.

Riesgos a vigilar:

• Reducción temporal de la oferta.
• Aumento del alquiler turístico o de habitaciones.
• Desplazamiento de la demanda a municipios cercanos (Oleiros, Culleredo, Arteixo).

🧭 Conclusión

Con la declaración de A Coruña como zona tensionada, la ciudad entra en una nueva etapa del mercado del alquiler.

La regulación busca equilibrio entre protección al inquilino y sostenibilidad para los propietarios, pero el éxito dependerá de su aplicación práctica y del control efectivo por parte de las administraciones.

En definitiva: la vivienda en A Coruña no solo se regulará por la oferta y la demanda, sino también por un marco normativo que fija límites, incentiva la rehabilitación y penaliza los abusos.

Un cambio estructural que marcará los próximos años del mercado inmobiliario gallego.

Mas información

• Página de la cual copie el contenido porque yo lo valgo y porque nada toca mas los huevos que una página creyendo que puede decidir que yo no pueda copiar y pegar.
• Precios cogidos de este artículo de La Opinión de Coruña
• Tambien de esta otra

If you use Bitwarden you might have tried using Bitwarden CLI which is a nightmare of a tool clearly not fit for purpose.

The main problem with it is that it takes between 1 to 5 seconds for every value you retrieve. The secondary problem is that unlike any other official Bitwarden implementation it is impossible to remain logged in without writing your own scripts to store BW_SESSION (logging with api credentials), pass it between shell sessions or make it universal and still make it so that it tests it works and relogs again if the session token has expired. Considering this again costs between 1 to 5 seconds it is too much time to waste whenever you open a new terminal.

I use Fish shell, it’s been my favourite shell for more than ten years, it does stuff that all other shells should be doing now without plugins required. In Fish shell when you make a universal environment variable with set -U VARIABLE, it doesn’t magically get into the ether or stored in memory, it gets writen on the filesystem on $HOME/.config/fish/fish_variables and I definitely don’t want that there.

So we have two problems, on one side the official bitwarden cli takes ages with any command, and on the other side I don’t want to keep the session alive by writing the token to a file anywhere on my system.

RBW entered the room

The program rbw is a command-line tool that does the same job as Bitwarden-CLI albeit very **very **differently. To begin with the commands are not the same, and the way you search for stuff is not the same either. But the most important value of rbw is that it maintains the connection logged unlike the official CLI tool.

It has a small issue, which is that it doesn’t accept Webauth/FIDO2 as 2FA right now but you can bypass this issue enabling any of the other accepted 2FA ways. In fact I enabled TOTP and it worked beautifully, I was asked for the temporal number combo only once the first time. You can use bitwarden itself as TOTP generator for this since you already have other login mechanisms for it.

That done, one problem was solved, login with rbw is very easy after installing it, if you use Bitwarden’s official vault, same as I do, do not forget the register command as explained in the rbw repo also if you use Nixos add pinsentry-tty to your packages, not pinsentry not any GUI version, you want the one for the terminal . Then do:

# To configure it
rbw config set email your@ema.il
# Lock timeout in seconds, I prefer 16 hours, covers the time I'm awake
rbw config set lock_timeout $(math "60*60*16")
# To log in
rbw login

And that’s it. You don’t need to do anything else. Any changes in config will ask you to login again the next time you try to get anything out of Bitwarden. With this we’ve solved the second problem, keeping environment variables anywhere on our system to stay connected.

Next issue: RBW speed has limits

So imagine I want to set up a function called load_bitwarden_vars that I call at the very end of config.fish so something like this

function load_bitwarden_vars
  set -gx GITHUB_CLIENT_ID $(rbw get github -f client_id)
  set -gx GITHUB_CLIENT_SECRET $(rbw get github -f client_secret)
  set -gx ZT_TOKEN $(rbw get zerotier -f token)
  set -gx ZT_NWID $(rbw get zerotier -f network_id)
end

The rbw tool has the advantage over bw that it is a lot faster retrieving data, milliseconds, not seconds. But the more calls you do to it during start up of fish shell the slower it gets for you to see the shell prompt whenever you open a window. This is unwieldly. I don’t have 4 vars, I have plenty more of them. After filling up my load_bitwarden_vars.fish file containing the function this took a very **unacceptable **long time.

I came up with the idea of putting each var directly as an alias or abbreviation of the tool it uses them. So, e.g: vault became either

# option 1
abb --add vault "TOKEN=$(rbw get...) vault"
# option 2
alias vault "TOKEN=$(rbw get...) /run/current-system/sw/bin/vault"

Yet alias has the issue of needing the whole vault path (Nixos) otherwise it becomes an infinite loop and Fish doesn’t allow it. And both have the major issue of computing the values when Fish launches so very slow.

The solution

One call, just one. It doesn’t matter how big is the item, with just one call it still takes less than a second. So I created an item called tokens in Bitwarden, I made it as a note, but it really doesn’t matter if you store it as a login, identity or anything else because rbw doesn’t care of what it is when it retrieves it with rbw get tokens all that matters is the custom fields I created.

For each one of the variables I want to retrieve I created a hidden text field, with the exact name of the variable. For conveniency I used Bitwarden-desktop for this but you could easily use the CLI tool or rbw itself to do so. I just had to do too much copy and paste from different places so prefered the visual GUI. The elegance of this approach is that I get to name all vars directly on Bitwarden as custom-fields, no sign of them in my fish config files.

So now to get Fish to load them type funced load_bitwarden_vars and add this to it

function load_bitwarden_vars
  set TOKENS $(rbw get tokens --raw)
  for pair in (printf "%s" "$TOKENS" | jq -r '.fields[] | "\(.name)=\(.value)"')
    set -l parts (string split -m1 = $pair)
    set -gx $parts[1] $parts[2]
  end
end

Then funcsave load_bitwarden_vars to store it in $HOME/.config/fish/functions/load_bitwarden_vars.fish and then add at the end of $HOME/.config/fish/config.fish the function name load_bitwarden_vars to run it after everything else of your config has loaded. In my case being at the end was quite important as I have modifiers for PATH in this file.

Now to test it fully lock your vault with rbw lock and close your terminal window. Open a newone and you should see 👇 Once you log in, close the shell and open it again. This time it doesn’t ask for anything, you’ll notice a very small lag but one you can comfortably live with. In fact try to open multiple terminal windows.

You’ve tested both cases, being logged and locked. As you see it works.

**Problem solved! **🥳

How it works

It’s pretty simple actually, it uses the speed of rbw for any given item, combined with JQ to set the variables without making them universal so they don’t get written to disk.

1. We take the whole output as json of the item tokens from Bitwarden and assign it to the local variable TOKENS
2. With JQ we extract from the fields array on TOKENS each one of the pairs of name and value custom fields we created. Format them as lines name=value
3. With a for loop we iterate over each one of those lines and assign them to pair
4. The inner content of the loop asigns each part of part to the corresponding local variables name and value.
5. The final line inside the loop assigns the globally exported variable. So that shell window and any subshells get the values.

I’m sure it can be improved and if you come up with ideas feel free to provide me some feedback. I’m not entirely sure of the difference between the types of variables. I mean universal, local and function environment variables are pretty self-explanatory but exported and global are not that clear. The manual says exported makes them available to child processes, but how’s that different from global? Feel free to share some light to me about this in Mastodon.

Useful links

• Fish shell scope in the Fish manual, very important to understand how set -U works.
• RBW repo page in Github.

• Desde los años 80, A Coruña presenta una división socioespacial marcada:
  • Centro histórico y Ensanche → clases medias-altas y procesos de rehabilitación.
  • Barrios periféricos o satélites (Novo Mesoiro, Matogrande, Someso, Los Rosales, Ventorrillo, Adormideras) → creados en los 90-2000 bajo el mandato de Francisco Vázquez, con carencias de servicios, movilidad y cohesión urbana.
• La expansión periférica se hizo a costa de abandonar el centro, lo que facilitó más tarde la gentrificación y el encarecimiento de la vivienda rehabilitada.

2.Estructura y dinámica del mercado

• Oferta muy reducida de alquiler y exceso de vivienda vacía o en mal estado.
• Se mantiene una preferencia cultural por la propiedad, pero la compra se volvió inalcanzable para gran parte de la población desde los 2000.
• Los precios del alquiler subieron de manera constante entre 2014 y 2022, llegando a ser de los más altos de Galicia, especialmente en barrios céntricos como Papagayo o Monte Alto.

3.Gentrificación urbana y comercial

• A Coruña ha vivido varias fases de gentrificación:
  • Fase 1 (2000–2008): rehabilitación en Ciudad Vieja y Paseo del Parrote; transformación del mercado de la Plaza de Lugo con la entrada de marcas de lujo e Inditex; encarecimiento del centro.
  • Fase 2 (2008–2015): crisis del ladrillo → precarización, pero también consolidación de la “ciudad creativa”, con llegada de población joven con mayor renta.
  • Fase 3 (2015–actualidad): expansión de la gentrificación hacia Monte Alto, San Agustín y Curros Enríquez, ligada a rehabilitación y turismo urbano.

4.El “efecto Inditex”

• Inditex no domina toda la economía urbana, pero tiene efectos indirectos claros:
  • Simbolismo y atracción de talento: la empresa genera una imagen de prosperidad que influye en la percepción de la ciudad.
  • Cambio en la demanda residencial: los trabajadores de Inditex son considerados inquilinos “ideales”, percibidos como solventes y estables, lo que margina al precariado local.
  • Contribución indirecta a la gentrificación: zonas céntricas se adaptan al estilo de vida de esa “clase creativa” y a la economía del consumo cultural y turístico.
• La autora y los expertos advierten que A Coruña depende en exceso del “monocultivo Inditex” (hasta un 45% de la productividad local), lo que supone un riesgo futuro.

5.Problemas estructurales

• Escasez de vivienda pública y políticas de alquiler social.
• Desigualdad territorial: distritos como Monte Alto y Torre concentran precios más altos; Los Mallos o Agra del Orzán muestran menor renta y envejecimiento poblacional.
• Dependencia del sector inmobiliario y de la plusvalía del suelo en los presupuestos municipales.
• Presión del turismo y auge de pisos turísticos, que agravan la exclusión residencial.

🧭 Conclusión general

El mercado inmobiliario coruñés combina tres tensiones:

1. Desequilibrio centro-periferia → abandono del centro seguido de gentrificación.
2. Influencia de Inditex → simbólica y material, reconfigura quién puede vivir y consumir en el centro.
3. Débil intervención pública → políticas de vivienda insuficientes para frenar exclusión o especulación.

En palabras de la tesis, A Coruña es hoy una “ciudad creativa gentrificada”, donde el acceso a la vivienda depende tanto de los ingresos como del tipo de empleo y de la identidad social del inquilino.

Bibliografía

• Maravillosa tesis doctoral de 400 y pico páginas de Julia Nogueira Dominguez https://ruc.udc.es/entities/publication/8a8f26be-5d80-483e-8241-50f59c7aa920

Configuration.nix

# Assuming configuration.nix
{
  # Rest of your file
  imports = [
    # Rest of your imports
    ./haproxy-acme.nix
  ]
}

Server: haproxy-acme.nix

Change serverNames for whatever list of servers you want to add, don’t forget to manually edit the services.haproxy.config configuration too for your added servernames without SSL, in my case is my zerotier one, accessible on my zerotier network.

The acme_emailvariable should point to your var.

{ config, pkgs, ... }:
let
  acme_email = "acme@maikel.dev";
  # Map domains to their backend host:port
  serverBackends = {
    "something_one.maikeladas.es" = "127.0.0.1:4000"; # Phoenix dev server.
    "something_else.maikeladas.es" = "thinkpad.zerotier:8080"; #Zerotier URL
  };
  serverNames = builtins.attrNames serverBackends;
  # ACLs
  aclLines = builtins.concatStringsSep "\n" (map (d:
    let aclName = "host_${builtins.replaceStrings [ "." ] [ "_" ] d}";
    in "  acl ${aclName} hdr(host) -i ${d}"
  ) serverNames);
  redirectLines = builtins.concatStringsSep "\n" (map (d:
    "  http-request redirect scheme https code 301 if host_${builtins.replaceStrings [ "." ] [ "_" ] d}"
  ) serverNames);
  # use_backend lines
  backendLines = builtins.concatStringsSep "\n" (map (d:
    let
      aclName = "host_${builtins.replaceStrings [ "." ] [ "_" ] d}";
      backendName = builtins.replaceStrings [ "." ] [ "_" ] d;
    in "  use_backend ${backendName}_app if ${aclName}"
  ) serverNames);
  # crt files
  crtFiles = builtins.concatStringsSep " " (map (d:
    "crt /var/lib/haproxy/certs/${d}.pem"
  ) serverNames);
  # backend definitions
  backendDefs = builtins.concatStringsSep "\n" (map (d:
    let
      backendName = builtins.replaceStrings [ "." ] [ "_" ] d;
      backendAddr = serverBackends.${d};
      indent = "    "; # 1 tab = 4 spaces
    in ''
      backend ${backendName}_app
        mode http
        server ${backendName}_1 ${backendAddr} check inter 2s fall 3 rise 2
        errorfiles customerrors
    ''
  ) serverNames);
in {
  # SSL certificates for HAProxy
  security.acme = {
    acceptTerms = true;
    defaults.email = acme_email;
    certs = builtins.listToAttrs (map (domain: {
      name = domain;
      value = {
        webroot = "/var/lib/acme/acme-challenge";
        group = "haproxy";
        postRun = ''
          mkdir -p /var/lib/haproxy/certs
          cat /var/lib/acme/${domain}/fullchain.pem \
            /var/lib/acme/${domain}/key.pem \
            > /var/lib/haproxy/certs/${domain}.pem
          chown root:haproxy /var/lib/haproxy/certs/${domain}.pem
          chmod 0640 /var/lib/haproxy/certs/${domain}.pem
        '';
      };
    }) serverNames);
  };

  # HAProxy service
  services.haproxy = {
    enable = true;
    config = ''
      global
        log stdout format raw local0
        maxconn 2000

      defaults
        log global
        mode http
        option httplog
        option dontlognull
        option forwardfor except 127.0.0.1
        timeout connect 5s
        timeout client 30s
        timeout server 30s
        retries 3

      frontend http_in
        bind *:80
        acl acme_challenge path_beg /.well-known/acme-challenge/
        use_backend acme_backend if acme_challenge
        acl host_zt hdr(host) -i stephen.zerotier
        ${aclLines}
        use_backend something_one_maikeladas_es_app if host_zt
        ${redirectLines}
        default_backend not_found

      frontend https_in
        bind *:443 ssl ${crtFiles}
        mode http
        acl acme_challenge path_beg /.well-known/acme-challenge/
        ${aclLines}
        use_backend acme_backend if acme_challenge
        ${backendLines}
        default_backend not_found

      backend acme_backend
        mode http
        server local_acme 127.0.0.1:8081

      ${backendDefs}

      http-errors customerrors
        errorfile 503 /etc/haproxy/errorfiles/503.http

      backend not_found
        mode http
        errorfiles customerrors
    '';
    user = "haproxy";
    group = "haproxy";
  };

  environment.etc."haproxy/errorfiles/503.http".text = ''
    HTTP/1.1 503 Service Unavailable
    Cache-Control: no-cache
    Connection: close
    Content-Type: text/html
    ${builtins.readFile ./haproxy-error-503.html}
  '';

  # Local HTTP server to serve ACME challenges
  systemd.services.acme-challenge-server = {
    description = "Serve Let's Encrypt challenges for HAProxy";
    wantedBy = [ "multi-user.target" ];
    serviceConfig = {
      ExecStart = "${pkgs.python3}/bin/python3 -m http.server 8081 --directory /var/lib/acme/acme-challenge";
      Restart = "always";
    };
  };
}

Your laptop or other PC configuration to be accessible

Assuming you use Zerotier (is free) and have it in the same network as the server (I do) and you know the IP or domain name if you have it in /etc/hosts (I do but I prefer to use IPs). Notice how I’ve limited the listening interfaces to that one of Zerotier only.

Of course import this file in your configuration for that machine. I call it haproxy-redirect.nix to make it clear what the nix contains.

{ config, pkgs, ... }:
{
  # HAProxy service
  services.haproxy = {
    enable = true;
    config = ''
      global
        log stdout format raw local0
        maxconn 2000

      defaults
        log global
        mode http
        option httplog
        option dontlognull
        option forwardfor except 127.0.0.1
        timeout connect 5s
        timeout client 30s
        timeout server 30s
        retries 3

      frontend local_http
        bind thinkpad.zerotier:8080
        default_backend phoenix_app

      backend phoenix_app
        server phoenix_1 127.0.0.1:4000 check inter 2s fall 3 rise 2
        errorfile 503 /etc/haproxy/errorfiles/503.http
    '';
    user = "haproxy";
    group = "haproxy";
  };

  environment.etc."haproxy/errorfiles/503.http".text = ''
    HTTP/1.1 503 Service Unavailable
    Cache-Control: no-cache
    Connection: close
    Content-Type: text/html
    ${builtins.readFile ./haproxy-error-503.html}
  '';
}

The default 503 error file

All errors I got when I turned off any of them servers were of type 503 so that’s the error I customised. The files is haproxy-error-503.html and should be in the same folder as the nix configuration. The content is this

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>Service Unavailable</title>
    <style>
      body {
        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
        background: #fafafa;
        color: #333;
        margin: 0;
        display: flex;
        align-items: center;
        justify-content: center;
        height: 100vh;
      }
      main {
        text-align: center;
        padding: 2rem;
        background: white;
        border-radius: 1rem;
        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
      }
      h1 {
        font-size: 2rem;
        margin-bottom: 0.5rem;
        color: #c0392b;
      }
      p {
        font-size: 1rem;
        color: #666;
      }
    </style>
  </head>
  <body>
    <main>
      <h1>503 – Service Unavailable</h1>
      <p>Our server is taking a quick break. Please try again in a moment.</p>
    </main>
  </body>
</html>

Advantages over the Pagekite way

1. HAProxy is a lot more robust.
2. Since you’re using already a machine as server and Zerotier for LAN-like communication, this harness precisely all that to make the config a lot simpler.
3. SSL renewal bult-in.
4. You can just stop the services whenever, the 503 custom-error page will be shown. No need to remember to “sysctl stop whatever”
5. Custom error page.

I just want to be able to use my own domains, that’s all. I don’t need any of the other fancy stuff so even though Pagekite is a lot cheaper than all of them 3, to use custom domains **with **SSL is not so much. So I decided to self-host the frontend. Btw, whoever decided to call the server “frontend” and the client “backend” deserves to be hanged upside down in a bucket filled with piranhas.

Getting SSL

Think that here DOMAIN is going to be the parent domain. I could make it be directly maikeladas.es but I have other stuff there and using a wildcard would force me to get rid of subdomains so I rather use a subdomain for specific temporary stuff, in this case dev.maikeladas.es. I could have used maikel.devbut the restrictions of dev domains that you cannot use port 80. They force you to use 443 and SSL. I want flexibility.

mkdir $HOME/certs
set DOMAIN dev.maikeladas.es
nix-shell -p certbot
certbot certonly --manual \
  --work-dir=$HOME/certs --logs-dir=/tmp/ --config-dir=$HOME/certs \
  --preferred-challenges=dns \
  --email avalid@email.whatever \
  --server https://acme-v02.api.letsencrypt.org/directory \
  --agree-tos \
  -d "*.$DOMAIN"
exit
sudo cat \
  $HOME/certs/live/$DOMAIN/fullchain.pem \
  $HOME/certs/live/$DOMAIN/privkey.pem \
  | sudo tee $HOME/certs/keycert.pem > /dev/null

Now you have the keycert.pem file that Pagekite requires to provide domains over HTTPS. The certificate will require renewal every 6 months. It can be automated but that’s for another day.

Do your DNS changes

Go to your DNS provider. For the domain create a *.dev.YOURDOMAIN.COM record of A type pointing to the IP and one of the parent subdomain pointing to the same IP. So also dev.YOURDOMAIN.COM again of A type.

NixOS Changes to get Pagekite

Assuming you use configuration.nix or somefile.nix that is not a flake.

{ config, lib, pkgs, ... }:
let
  kitesecret = "YOUR_KITE_PASS";
  pagekite = import ./pagekite-package.nix { inherit pkgs; };
in {
  # The rest of your config
  # To install the derivation while keeping it around to pass it
  environment.systemPackages = lib.mkAfter [ pagekite ];
  imports = [
    # ...your other imports
    # Import as functions, passing pagekite and kitesecret explicitly
    # If this machine is the client
    (import ./pagekite-client.nix {
      inherit config pkgs lib pagekite kitesecret;
      frontendHost = "dev.maikeladas.es";
      frontendPort = 80;
      backendHost = "stephen.dev.maikeladas.es";
      backendLocalPort = 4000;
    })
    # If this machine is the server
    (import ./pagekite-server.nix {
      inherit config pkgs lib pagekite kitesecret;
      kitename = "*.dev.maikeladas.es";
      ports = "80,443";
      protos = "http,https";
      domainHttp = "*.dev.maikeladas.es";
      domainHttps = "*.dev.maikeladas.es";
      tlsEndpoint = "*.dev.maikeladas.es:/home/maikel/certs/keycert.pem";
    })
  ];
  # The rest of your /etc/nixos/configuration.nix file
}

Then the pagekite-package.nix

This is all you need to intsall pagekite.py

{ pkgs }:
pkgs.stdenv.mkDerivation rec {
  pname = "pagekite";
  version = "1.0";
  src = pkgs.fetchurl {
    url = "https://pagekite.net/pk/pagekite.py";
    sha256 = "1nqa4nkhjq2shc7zpxn22pxfqpsl6xf06mfxlwa72c5p72zf7x94";
  };
  nativeBuildInputs = [ pkgs.makeWrapper ];
  unpackPhase = ":";
  installPhase = ''
    mkdir -p $out/bin
    sed "1 s|^.*$|#!${pkgs.python3}/bin/python3|" $src > $out/bin/pagekite
    chmod +x $out/bin/pagekite
  '';
}

Then the pagekite-client.nix

This is the one to use a client.

{ config, pkgs, lib, kitesecret, pagekite, frontendHost, frontendPort, backendHost, backendLocalPort, ... }:
let
  # Construct addresses
  frontend = "${frontendHost}:${toString frontendPort}";
  backend = "http:${backendHost}:localhost:${toString backendLocalPort}";
in {
  # PageKite client configuration file
  environment.etc."pagekite.d/${backendHost}.conf".text = ''
    frontend = ${frontend}
    service_on = ${backend}:${kitesecret}
  '';

  # Systemd service
  systemd.services."pagekite-client-${backendHost}" = {
    description = "PageKite Client Tunnel Service for ${backendHost}";
    after = [ "network.target" ];
    wantedBy = [ "multi-user.target" ];
    serviceConfig = {
      Type = "simple";
      ExecStart = "${pagekite}/bin/pagekite --optfile /etc/pagekite.d/${backendHost}.conf";
      Restart = "always";
      RestartSec = 10;
      User = "root";
    };
  };
}

Then the pagekite-server.nix

This is the one to run a server. This machine needs to be one that responds when you ping dev.YOURDOMAIN.COM and *.dev.YOURDOMAIN.COM so you must have your DNS configured correctly.

{ config, pkgs, lib, kitesecret, pagekite, kitename, ports, protos, domainHttp, domainHttps, tlsEndpoint, ... }:
{
  # PageKite server configuration file
  environment.etc."pagekite.d/pk-server.conf".text = ''
    kitename = ${kitename}
    kitesecret = ${kitesecret}
    isfrontend
    ports = ${ports}
    protos = ${protos}
    domain = http:${domainHttp}:${kitesecret}
    domain = https:${domainHttps}:${kitesecret}
    tls_endpoint = ${tlsEndpoint}
  '';

  # Systemd service
  systemd.services.pagekite = {
    description = "PageKite Reverse Tunnel Service";
    after = [ "network.target" ];
    wantedBy = [ "multi-user.target" ];
    serviceConfig = {
      Type = "simple";
      ExecStart = "${pagekite}/bin/pagekite --optfile /etc/pagekite.d/pk-server.conf";
      Restart = "always";
      RestartSec = 10;
      User = "root";
    };
  };
}

How to use it

On whatever machine plays as server add the necessary files to run the server, and on the client for the client. Both cases need pagekite-package.nix though. Then just nixos-rebuild switch or whatever NixOS method you use to update your config.

I normally do a sudo systemctl stop pagekite-client-DOMAIN after running any client the first time so it’s only available when I need it.

Caveats

1. I haven’t automated SSL renewal, it can be done, but I need to have a life. I might not be using this in six months.
2. If you stop whatever is you’re serving or the server, the client hangs and does not auto-reconnect. So get ready to restart the client.
3. You won’t have to pay ever again Zrok, Ngrok or Tailscale for using a custom domain. Oh, the suffering!

If you liked this article consider tipping me on Ko-Fi 👇

My first choice would normally be VirtualBox, but on NixOS it’s a pain: every system upgrade forces VirtualBox to be recompiled. Since I upgrade often, that became unmanageable.

People in the fediverse suggested libvirtd, so I gave it a try. It’s trickier at first, but once you learn a few commands it’s not bad at all—and in fact, it allows for a lot of automation.

Installing Libvirtd

In configuration.nix you need to make the following changes.

# Add the user to these groups
users.users.maikel = {
  extraGroups = [ "libvirtd", "libvirt", "qemu-libvirtd" ];
};

# Enable libvirtd
virtualisation = {
  libvirtd = {
    enable = true;
    qemu.vhostUserPackages = with pkgs; [ virtiofsd ];
    # Enable NSS plugin for resolving VM hostnames
    nss = {
      enable = true;        # classic libvirt NSS
      enableGuest = true;    # resolves domain names of guests
    };
  };
};

# Add Virt-Manager makes simpler to explore actual configs
programs.virt-manager.enable = true;

environment = {
  systemPackages = with pkgs; [
    virt-viewer
    cloud-utils
    cloud-init
  ];
};

Running commands when using Libvirtd as a system’s service

Despite all the changes there, I still need to prepend all virsh and virt-viewer commands with -c qemu:///system. One way to avoid having to do this is to set the environment variable.

For Fish shell:

# Run this from anywhere, it automatically stores it in ~/.config/fish/fish_variables
set -Ux LIBVIRT_DEFAULT_URI qemu:///system

For Bash:

# Append to ~/.bashrc or ~/.profile, whichever is the last to load on your system
export LIBVIRT_DEFAULT_URI="qemu:///system"

Alternatively, you can use Fish abbreviations (which I prefer because they show you the full command):

# Add to ~/.config/fish/conf.d/abbreviations.fish
abbr --add virt-viewer "virt-viewer -c qemu:///system"
abbr --add virsh "virsh -c qemu:///system"

I like abbr instead of alias because with abbr I don’t actually forget the full command ever. It’s shown to me every time.

Configuring the Network

By default there’s nothing running network wise. So you need to start the default network with:

# Starts it if you can't see any new networks in ifconfig
virsh net-start default

# So it autostarts
virsh net-autostart default

That will run the virtual network every time the PC reboots.

Modifying the default network to your desired IP range

virsh net-dumpxml default > mynetwork.xml

We get this from it on the file mynetwork.xml:

<network>
  <name>default</name>
  <uuid>07c8b831-3fa7-4bb1-ae07-fad64b672a67</uuid>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr0' stp='on' delay='0'/>
  <mac address='52:54:00:9f:f9:f6'/>
  <ip address='192.168.122.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.122.2' end='192.168.122.254'/>
    </dhcp>
  </ip>
</network>

I’m going to change the range to 192.168.100.0/24 and the network name to maikenet since I like it more and tells me on the name what it is. You can remove UUID.

<network>
  <name>maikenet</name>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr0' stp='on' delay='0'/>
  <mac address='52:54:00:9f:f9:f6'/>
  <ip address='192.168.100.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.100.2' end='192.168.100.254'/>
    </dhcp>
  </ip>
</network>

Now let’s destroy the network interface and create a new one. Beware if you’re doing these commands while your machines are running and attached to any network you’re destroying, they might need a reboot to recover their IPs once that network is back up.

# To destroy it
virsh net-destroy default

# We need to undefine it in case something is assigned to it already but also because we're not using it anymore
virsh net-undefine default

# To recreate it from file
virsh net-define mynetwork.xml

# Now start it and autostart to ensure it starts with NixOS
virsh net-start maikenet
virsh net-autostart maikenet

# Check with an ifconfig
ifconfig
# You should see an adapter virbr0 with the right IP

Creating a cloud-init enabled image

For a ZFS VM image

This will create a template on your PC to run cloud-init from the ZFS VM image that uses ZFS filesystem, the most common case.

# Make a folder for your vms
mkdir $HOME/vms
cd $HOME/vms

# Download standard VM image and unzip it
wget https://download.freebsd.org/releases/VM-IMAGES/14.3-RELEASE/amd64/Latest/FreeBSD-14.3-RELEASE-amd64-zfs.qcow2.xz

# Decompress but keeps the original
xz -dk FreeBSD-14.3-RELEASE-amd64-zfs.qcow2.xz

# Make the disk slightly bigger
mv FreeBSD-14.3-RELEASE-amd64-zfs.qcow2 freebsd14-cloud-init-zfs.qcow2
qemu-img resize freebsd14-cloud-init-zfs.qcow2 10G

# Run it with the network to install CloudInit
virt-install \
  --name freebsd-zfs \
  --memory 2048 \
  --vcpus 2 \
  --disk path=freebsd14-cloud-init-zfs.qcow2,format=qcow2,bus=virtio \
  --os-variant freebsd14.0 \
  --import \
  --network network=maikenet,model=virtio \
  --graphics spice

Now inside the machine

The default root user is passwordless so if you use root it won’t ask for any password, just log you in.

# OPTIONAL: Keyboard to Spanish, symbols are in different places
kbdcontrol -l es

# Now inside the machine prepare it for cloud-init (as root, no pass)
pkg update
pkg search cloud-init
pkg install -y WHATEVER_VERSION_YOU_GOT_FROM_SEARCH

# Now enable it
sysrc cloudinit_enable="YES"
poweroff

# On your host system: Back it up
xz -k freebsd14-cloud-init-zfs.qcow2

Using your own templates to launch custom-made VMs easily

Create a cloud-init config

The SSH key I have there is the default one I have in SSH part of my home-manager config.

1. Create this file as user-data.yaml on the $HOME/vms folder as the basic template for all other machines:

#cloud-config
hostname: freebsd1
users:
  - name: maikel
    shell: /usr/local/bin/fish
    sudo: ALL=(ALL) NOPASSWD:ALL
    lock_passwd: false
    # Use mkpasswd -m sha-512 to get this
    passwd: "$6$L80IKTwDwcfp......josH0"
    ssh_authorized_keys:
      - ssh-ed25519 AAAA......ikel.dev
ssh_pwauth: True
keyboard:
  layout: es
packages:
  - fish
  - sudo
  - mkpasswd
  - neovim
  - ncdu
  - git
runcmd:
  # Enable SSH
  - sysrc sshd_enable=YES
  - service sshd start
  # OPTIONAL: Set Spanish keyboard permanently
  - sysrc keymap="es.kbd"
  - service syscons restart
  # OPTIONAL: set root and maikel shells to fish explicitly
  - pw usermod root -s /usr/local/bin/fish
  - pw usermod maikel -s /usr/local/bin/fish
  # OPTIONAL: Auto resize main partition
  - gpart recover vtbd0
  - gpart resize -i 4 vtbd0
  - zpool online -e zroot /dev/vtbd0p4

1. Use this command to create a CD-ROM ISO to launch it from. Assuming you’re in $HOME/vms:

cloud-localds seed.iso user-data.yaml

Creating the final machine using the ZFS image

# Access the folder of your vms
cd $HOME/vms

# Decompress the fresh cloud-init-enabled version we created before
xz -dk freebsd14-cloud-init-zfs.qcow2.xz

# Rename it to something more useful to distinguish it from the template
cp freebsd14-cloud-init-zfs.qcow2 freebsd1.qcow2

# Create the seed ISO from user-data.yaml in case you've made any changes
cloud-localds freebsd1.iso user-data.yaml

# Make the disk bigger here it is set to 20G but you can do whatever size you like
qemu-img resize freebsd1.qcow2 50G

virt-install \
  --name freebsd1 \
  --memory 4096 \
  --vcpus 4 \
  --disk path=freebsd1.qcow2,format=qcow2,bus=virtio \
  --disk path=freebsd1.iso,device=cdrom \
  --os-variant freebsd14.0 \
  --import \
  --network network=maikenet,model=virtio \
  --graphics spice \
  --noautoconsole

And that’s it, your system should be up and running ready to be used. Because you enabled NSS and added your default SSH key (default in .ssh/config), you can just log into it with a simple:

ssh maikel@freebsd1

…once the machine finishes running all of its cloud-init script.

Extra steps for your own sanity

Resizing the partition to use all available space (ZFS)

If you want your system to use all the available space in your qcow2 file after resizing it you’ll need some extra steps. This can all be added on the user-data template though which I did so you don’t need to.

# Ensure vtbd0 is the name of it
gpart show

# Resize partition
gpart recover vtbd0

# Get the slice or number of partition, in my case is 4
gpart show

# This is assuming the slice is 4
gpart resize -i 4 vtbd0

# Again the end "p4" depends on the slice number
zpool online -e zroot /dev/vtbd0p4

# Check with
zpool list

That’s all your machine is ready to use. If you ever need to change the size of the qcow2 file repeat those steps.

Autostart this machine with NixOS

Run on the host machine:

virsh autostart freebsd1

Otherwise to start manually:

virsh start freebsd1

Detach cloud-init disk just in case

Normally cloud-init runs only once, but just to be sure on the host machine:

# To find the name of the ISO device, in my case "hda"
virsh domblklist freebsd1

# To both remove it and ensure it never comes back after reboot
virsh change-media freebsd1 hda --eject --config --live

Cloning user data

I create this mostly because I was considering the Zerotier one that is far below and realised I can kill two birds with one shot.

function clone_user_data
  if test (count $argv) -ne 1
    echo "Usage: clone_user_data <vmname>"
    return 1
  end

  set NEWVM $argv[1]
  set BASE "$HOME/vms/user-data.yaml"
  set vm_dir $HOME/vms/in_use/$vm
  mkdir -p $vm_dir
  set OUT "$vm_dir/$NEWVM-user-data.yaml"

  if not test -f $BASE
    echo "Error: base file $BASE does not exist"
    return 1
  end

  # Replace hostname line
  sed "s/^hostname:.*/hostname: $NEWVM/" $BASE > $OUT
  echo "Created config: $OUT"
end

Creating machines quickly with Fish function

At the moment I separate creating the user-data file for that machine from creating it because precisely we might want to change what is installed on the machine. So this is how I normally do it now:

# Assuming decompressed ready cloud image on ~/vms
# Create a user-data file for that machine
clone_user_data freebsd4

# Edit it
vi $HOME/vms/in_use/freebsd4/freebsd4-user-data.yaml

# Create the machine
create_vm freebsd4

Then create the machine:

function create_vm
  if test (count $argv) -lt 1
    echo "Usage: createvm <vm-name>"
    return 1
  end

  set vm $argv[1]
  set vm_dir $HOME/vms/in_use/$vm
  cd $vm_dir

  echo "Copying template to VM disk..."
  cp $HOME/vms/freebsd14-cloud-init-zfs.qcow2 $vm.qcow2

  echo "Creating seed ISO..."
  cloud-localds $vm.iso $vm-user-data.yaml

  echo "Resizing disk..."
  qemu-img resize $vm.qcow2 20G

  echo "Launching VM..."
  virt-install \
    --connect qemu:///system \
    --name $vm \
    --memory 4096 \
    --vcpus 4 \
    --disk path=$vm.qcow2,format=qcow2,bus=virtio \
    --disk path=$vm.iso,device=cdrom \
    --os-variant freebsd14.0 \
    --import \
    --network network=maikenet,model=virtio \
    --graphics spice \
    --noautoconsole

  echo "VM $vm launched."
end

Destroying machines quickly with Fish shell

function destroy_vm
  if test (count $argv) -lt 1
    echo "Usage: destroyvm <vm-name>"
    return 1
  end

  set vm $argv[1]
  echo "Destroying VM $vm..."
  virsh destroy $vm

  echo "Undefining VM $vm..."
  virsh undefine $vm

  set disk ~/vms/in_use/$vm/$vm.qcow2
  set seed ~/vms/in_use/$vm/$vm.iso
  set userdata ~/vms/in_use/$vm/$vm-user-data.yaml

  if test -f $disk
    echo "Deleting disk $disk..."
    rm -f $disk
  else
    echo "Disk $disk not found, skipping."
  end

  if test -f $seed
    echo "Deleting seed $seed..."
    rm -f $seed
  else
    echo "Disk $seed not found, skipping."
  end

  if test -f $userdata
    echo "Deleting user-data $userdata..."
    rm -f $userdata
  else
    echo "Disk $userdata not found, skipping."
  end

  rm -rf $HOME/vms/in_use/$vm
end

Zerotier on creation with self-authorisation

This is something I’m experimenting with, installing Zerotier and joining a network are easy steps but I want it to self-authorise too. It does works as it currently is but I want the variables to be fed into the cloud config somehow instead of hard-coding the variables.

Then once the machine is up and running you can just and simply run /root/join-network.sh as root.

I set a few variables to simplify this all, for example I want the fish functions to be in the vm folder as they are all related to this.

# This loads functions from the path in the vms add to config.fish
set -g fish_function_path $fish_function_path ~/vms/fish_functions

# This sets the default password I want to use for my machines which is later hashed by mkpasswd, can be set from the shell
set -Ua DEFAULT_VM_PASSWORD whatever_passw_you_want

I also did a few more changes here and in the cloning function since now this is my standard user-data.yaml template:

#cloud-config
hostname: 
users:
  - name: maikel
    shell: /usr/local/bin/fish
    sudo: ALL=(ALL) NOPASSWD:ALL
    lock_passwd: false
    passwd: ""
    ssh_authorized_keys:
      - 
ssh_pwauth: True
keyboard:
  layout: es
packages:
  - fish
  - sudo
  - mkpasswd
  - neovim
  - ncdu
  - zerotier
  - curl
  - jq
write_files:
  - path: /root/join-network.sh
    permissions: '0755'
    content: |
      #!/bin/sh
      zerotier-cli join "" && \
      MEMBER_ID=$(zerotier-cli info | awk '{print $3}') && \
      curl -H "Authorization: token " -X POST \
      "https://api.zerotier.com/api/v1/network//member/$MEMBER_ID" \
      --data '{"config": {"authorized": true}}'
runcmd:
  # Enable SSH
  - sysrc sshd_enable=YES
  - service sshd start
  # Set Spanish keyboard permanently
  - sysrc keymap="es.kbd"
  - service syscons restart
  # Optional: set root and maikel shells to fish explicitly
  - pw usermod root -s /usr/local/bin/fish
  - pw usermod maikel -s /usr/local/bin/fish
  # Auto resize main partition
  - gpart recover vtbd0
  - gpart resize -i 4 vtbd0
  - zpool online -e zroot /dev/vtbd0p4
  # Zerotier joy
  - sysrc zerotier_enable="YES"
  - service zerotier start

Applying the ZT_TOKEN and ZT_NW with a Fish-shell function clone_user_data VM_NAME:

function clone_user_data
  if test (count $argv) -ne 1
    echo "Usage: clone_user_data <vmname>"
    return 1
  end

  set NEWVM $argv[1]
  set BASE "$HOME/vms/user-data.yaml"
  set VM_DIR "$HOME/vms/in_use/$NEWVM"
  mkdir -p "$VM_DIR"
  echo "Created directory $VM_DIR"

  set OUT "$VM_DIR/$NEWVM-user-data.yaml"

  if not test -f $BASE
    echo "Error: base file $BASE does not exist"
    return 1
  end

  if test -z "$ZT_TOKEN"
    echo "Error: ZT_TOKEN environment variable not set"
    return 1
  end

  if test -z "$ZT_NWID"
    echo "Error: ZT_NWID environment variable not set"
    return 1
  end

  if test -z "$DEFAULT_VM_PASSWORD"
    echo "Error: DEFAULT_VM_PASSWORD environment variable not set"
    return 1
  end

  # Generate hashed password
  set PASSWD (mkpasswd -m sha-512 $DEFAULT_VM_PASSWORD)

  # Extract default identity file from ssh config (already a .pub in your setup)
  set PUBKEYFILE (grep -m1 -i 'IdentityFile' ~/.ssh/config | awk '{print $2}' | sed "s|~|$HOME|")

  if test -z "$PUBKEYFILE"
    echo "Error: could not find IdentityFile in ~/.ssh/config"
    return 1
  end

  if not test -f $PUBKEYFILE
    echo "Error: public key $PUBKEYFILE not found"
    return 1
  end

  set PUBKEY (cat $PUBKEYFILE)

  sed \
    -e "s||$NEWVM|g" \
    -e "s||$ZT_NWID|g" \
    -e "s||$ZT_TOKEN|g" \
    -e "s||$PASSWD|g" \
    -e "s||$PUBKEY|" \
    $BASE >$OUT

  if test $status -ne 0
    echo "Error: failed to generate $OUT"
    return 1
  end

  echo "Created config: $OUT"
end

Installing a desktop environment

I use KDE, it really just needs to read the handbook and follow it step by step. I even created its own desktop-user-data.yaml file for this one in case I ever need the desktop.

The yaml file for cloudinit:

#cloud-config
hostname: desktop
users:
  - name: maikel
    shell: /usr/local/bin/fish
    sudo: ALL=(ALL) NOPASSWD:ALL
    lock_passwd: false
    passwd: "$6$L80IKTw............osH0"
    ssh_authorized_keys:
      - ssh-ed25519 ....... maikel.dev
ssh_pwauth: True
keyboard:
  layout: es
packages:
  - fish
  - sudo
  - mkpasswd
  - neovim
  - ncdu
  - xorg
  - kde
  - sddm
runcmd:
  # Enable SSH
  - sysrc sshd_enable=YES
  - service sshd start
  # Set Spanish keyboard permanently
  - sysrc keymap="es.kbd"
  - service syscons restart
  # Optional: set root and maikel shells to fish explicitly
  - pw usermod root -s /usr/local/bin/fish
  - pw usermod maikel -s /usr/local/bin/fish
  # Auto resize main partition
  - gpart recover vtbd0
  - gpart resize -i 4 vtbd0
  - zpool online -e zroot /dev/vtbd0p4
  # Add KDE
  - pw groupmod video -m maikel
  - sysrc dbus_enable="YES"
  - service dbus start
  - sysctl net.local.stream.recvspace=65536
  - sysctl net.local.stream.sendspace=65536
  - sysctl -f /etc/sysctl.conf
  - sysrc sddm_enable="YES"
  - sysrc sddm_lang="es_ES"
  - setxkbmap -layout es
  - service ssdm start

The machine has a few differences, I assigned more total system memory (8GB) and hiked the RAM assigned to the video card too. My mouse is a USB one so only works with that line in input. If yours isn’t USB delete that line.

virt-install \
  --connect qemu:///system \
  --name desktop \
  --memory 8192 \
  --vcpus 4 \
  --disk path=desktop.qcow2,format=qcow2,bus=virtio \
  --disk path=desktop.iso,device=cdrom \
  --os-variant freebsd14.0 \
  --import \
  --video qxl,ram=524288,vram=262144,vgamem=262144 \
  --network network=maikenet,model=virtio,mac=52:54:00:6f:3c:58 \
  --input type=mouse,bus=usb \
  --graphics spice \
  --noautoconsole

Cleaning up

# See the machines
sudo virsh list --all

# The first stops immediately the machine
sudo virsh destroy freebsd14

# This second removes it from the pool of VMs of libvirtd
sudo virsh undefine freebsd14

# Delete any pre-made seed just in case
rm -rf seed.iso

Extra: Repo with all this

I made a repo with all these commands including a pre-made ZFS-ready FreeBSD 14.3 image.

The URL is https://github.com/maikelthedev/libvirtd_automation

Some oddities

These are some painful parts from the process.

The command virt-install and “~”

I don’t know why the path can’t interpret “~” hence why I did it all from the $HOME/vms folder. In this version I changed “~” to $HOME in all scripts for consistency.

Run without virt-viewer

Sometimes you want to install and see nothing, in those case use:

--graphics spice \
--noautoconsole

At the end of the virt-install command, this runs the system with graphics enable but doesn’t attach any viewer to it.