DEV Community: Khadim Hussain

AI Bubble Burst in China: What It Means for 2027

Khadim Hussain — Sun, 01 Nov 2026 09:01:35 +0000

Originally published on khadim.tech.

In short: China's AI stock bubble burst in 2026: the STAR50 index fell 40% in under four months, erasing about $480 billion, while Chinese AI firms were rationing compute and raising prices. In the US, Microsoft, Alphabet, Amazon and Meta spent $201.9 billion on property and equipment in the third quarter of 2026, $26.4 billion more than their combined operating cash flow. A few forecasters put a US market fall in 2027 or 2028, while the other strategists Bloomberg tracks see about 14% upside on average. For a company using AI, the main risk in a correction is a vendor failing, so keep a second provider, an open-weight model you can run yourself, and a measured return for each use case.

The AI bubble burst in China in 2026, on the stock market. China's STAR50 technology index fell 40% in under four months, at a time when Chinese AI companies were short of computing power and raising their prices. Valuations collapsed, and demand for AI did not.

In the US the argument is about money. Microsoft, Alphabet, Amazon and Meta now spend more on data centres and equipment than their businesses generate in cash, and they are borrowing and selling shares to cover the gap. A minority of forecasters name 2027 or 2028 for a correction, and the strategists Bloomberg tracks still see US stocks rising on average.

For a company that uses AI, the useful question is what a fall would do to the models and vendors it depends on. The market predictions below are the forecasters' own, and none of this is investment advice.

Did the AI bubble burst in China?

China's AI stock bubble did. On October 27, 2026, Reuters reported that the STAR50, the main index of Shanghai's technology board, had fallen 40% in less than four months, wiping out about $480 billion of market value. At its peak it traded at nearly 250 times the previous 12 months' earnings, and after the fall it was still around 100 times, against 30 times for the Nasdaq 100.

By Goldman Sachs' count, AI stocks are 42% of China's market value and 57% of its trading turnover. The broader CSI 300 was about 20% below its June peak, while the Nasdaq was about 6% below its record.

Beijing helped let the air out. Regulators cracked down on leveraged and high-frequency trading, state-backed investors sold into rallies, and October guidelines from the Communist Party and the State Council set out to "curb investment bubbles" while keeping the "AI Plus" push to use AI in traditional industries.

When MiniMax listed in Hong Kong in January, its retail tranche was oversubscribed 1,848 times, and by late February it and Zhipu, which listed a day earlier, were worth $63 billion together, with enterprise values of more than 100 times the revenue analysts forecast for the next 12 months. A Reuters Breakingviews column compared them with the electric-car maker Nio, whose shares rose tenfold and then fell more than 90%.

What happened to China's AI startups before the crash?

In 2024 more than 144 companies registered large language models with the Cyberspace Administration of China. By the end of that year only about 10% were still investing in large-scale training, according to the Economic Observer, as cited by MIT Technology Review. A price war in May 2024 squeezed them further: ByteDance priced its Doubao Pro model at what it said was 99% below the industry average, and Alibaba cut some Qwen prices by up to 97% (Fortune).

Why did China's AI data centres sit idle?

More than 500 data-centre projects were announced in 2023 and 2024. The Chinese outlets Jiazi Guangnian and 36Kr reported that up to 80% of the newly built computing capacity was unused, and the monthly rent for a server with eight Nvidia H100 GPUs fell to 75,000 yuan from highs of around 180,000 (MIT Technology Review, March 2025). Many were remote sites built for training, and they lost their appeal when demand moved to serving reasoning models close to users. In May 2026 the Australian Strategic Policy Institute still reported utilisation as low as 20% to 30% at some western data centres, against a goal of more than 60%.

Why did AI demand in China keep growing?

By early 2026 the shortage ran the other way. In January Bloomberg reported that Zhipu was limiting access to its coding agent, cutting the daily quota of new coding-plan sales to 20% of its previous level. In April, Caixin reported that a shortage of computing power was forcing Chinese AI firms to "throttle services, ration access and hike prices". Alibaba Cloud raised AI compute prices by 5% to 34% and Baidu by about 5% to 30%, both from April 18 (TrendForce).

The large platforms kept building: Alibaba, Tencent and Baidu spent about 131.8 billion yuan on capital projects in the second quarter of 2026, about 2.1 times as much as a year earlier (36Kr).

China is an imperfect template for the US: the Chinese state actively cooled the market, and the AI crash came on top of a wider fall in Chinese shares.

Is AI a bubble in the US?

In the US, the question is whether spending has outrun cash. Microsoft, Alphabet, Amazon and Meta spent $201.9 billion on property and equipment in the July-to-September quarter of 2026, against $175.5 billion of operating cash flow. A year earlier they spent $97.3 billion against $159.0 billion. Their spending roughly doubled while their cash from operations rose about 10%.

Chart: Q3 2026 capital spending vs operating cash flow for Microsoft, Alphabet, Amazon and Meta, from each company's results.

The figures are reported purchases of property and equipment and net cash from operations for the quarter ended September 30, 2026 (Microsoft's fiscal first quarter of 2027). None of the four reports an AI-only figure, and Oracle is left out because its quarter ends in August.

The case for a bubble

Three of the four are spending more cash than they make. Alphabet's free cash flow was -$9.1 billion in the quarter, and Meta's was -$2.1 billion, against +$10.6 billion a year earlier. Amazon's was -$42.4 billion over the 12 months to September, against +$14.8 billion a year before. Microsoft had about $18.6 billion of operating cash left after its capital spending.

Outside money is filling the gap. Meta announced a $95 billion share offering, its first new stock since 2013 (Semafor). A Bank of Korea report found that Alphabet, Microsoft, Amazon, Meta and Oracle issued $230 billion of bonds in the first nine months of 2026, more than double their total for 2025 (Herald Business).

The IMF warned in October 2026 that "faltering AI investment and profitability could challenge optimistic expectations and trigger a correction in asset prices." It reviewed 14 circular financing deals since 2023, in which AI companies' investors are also their suppliers or customers: about $300 billion of equity and $650 billion of debt, tied to $1.4 trillion of future revenue commitments. Trouble at one recipient could spread along that chain, though the IMF presents this as a vulnerability, not a forecast.

Bain estimated in September 2025 that AI needs $2 trillion of annual revenue by 2030 to pay for the computing it expects to use, and that the world is still $800 billion short after counting AI-driven savings. Citadel's Ken Griffin said on October 20, 2026 that investors are "almost certainly" in an AI bubble, and compared GPUs to airline seats: once supply exceeds demand, prices can collapse.

The case against a bubble

The demand shows up in revenue. In the same quarter Azure revenue grew 48%, Google Cloud grew 103% to $30.7 billion with $11.1 billion of operating income, and AWS grew 39% to $46.0 billion. Microsoft's commercial remaining performance obligation, the revenue under contract that it has not yet recognised, rose 73% to $677 billion. Nvidia's data-centre revenue was $89.0 billion in the quarter to July 26, 2026, up 117% (Nvidia).

Compute is still scarce. AWS raised prices for EC2 Capacity Blocks for ML, its reserved GPU capacity, by about 15% in early January 2026, saying the change "reflects the supply/demand patterns we expect this quarter" (The Register). Jeff Bezos, who called AI "a kind of industrial bubble" in October 2025, said such bubbles are "not nearly as bad" as financial ones (Fortune).

Will the AI bubble burst in 2027?

A handful of forecasters name 2027, and they predict different things:

Who	What they predict	By when
Capital Economics (James Reilly)	A "late-stage bubble": the S&P 500 ends 2026 at 8,250, then falls 21% to 6,500	End of 2027
Joachim Klement, Panmure Liberum	The AI bubble "will either burst in 2027 or in 2028"; the S&P 500 at 5,000, about 36% below its October 2026 level	End of 2027
Ohsung Kwon, Wells Fargo	Markets start treating 2027 as a potential peak year for AI capital spending, which will "likely slow meaningfully in 2028"	2027 to 2028
Pantheon Macroeconomics	Hyperscaler capital spending growth "looks set to moderate"	2027
Michael Burry	Reportedly bought put options, which pay off if a share falls, on Micron and Nebius	Expiring June 2027
Gartner	More than 40% of agentic AI projects cancelled	End of 2027

Only the first two forecast a market fall in 2027, and Burry's positions bet the same way; the other calls are about slower spending or cancelled projects.

Most strategists disagree: the seven others Bloomberg tracks alongside Klement see 14% upside for US stocks on average. Ruchir Sharma of Rockefeller International names a trigger rather than a date: in a Financial Times column he wrote that the bubble could pop if the 10-year US Treasury yield "decisively breaches" 5%. In mid-September it reached 4.97%.

What happens to companies using AI when the AI bubble bursts?

A correction is a fall in share prices and spending plans. Trained models and finished data centres keep running. What changes for a company using AI is the price of compute, which vendors survive, and how budgets are judged.

On price, the evidence points both ways. Griffin's airline-seat comparison implies that a glut of GPUs would push compute prices down, and the price of a fixed level of LLM capability has fallen between 9 and 900 times a year depending on the task, according to Epoch AI. But shortages pushed prices up in 2026 in both the US and China, so an AI budget should allow for movement in either direction.

The bigger exposure is vendors. Builder.ai, once valued at over $1 billion, backed by Microsoft and funded with more than $450 million, entered insolvency proceedings in May 2025. Gartner estimates that only about 130 of the thousands of companies selling "agentic AI" are real, and calls the relabelling of chatbots and automation tools "agent washing".

Gartner's cancellation forecast names rising costs, unclear business value and weak risk controls as the causes. MIT's Project NANDA, based on 52 interviews and 153 survey responses, found that just 5% of integrated generative AI pilots were extracting millions in value, while the large majority had no measurable effect on profit and loss (Virtualization Review).

How do you protect an AI project from a bubble burst?

I recommend these engineering hedges whatever the market does, because providers change prices, models and terms in good years too.

Keep the model behind one interface

Call the model through one thin layer in your own code, keep prompts and evaluation sets in your repository, and run the same evaluation against a second provider on a schedule. Switching then takes a configuration change and a test run. For agents, tools built as MCP servers can be called by any compatible model client, so the model can change without rebuilding them. That is one reason MCP servers are part of my AI agent consulting work.

Keep an open-weight model you can run yourself

An open-weight model you host stays available if its maker fails or changes its terms. DeepSeek V4, released in April 2026 under the MIT licence, can be served by any provider or on your own hardware, and its Flash version costs $0.14 per million input tokens through DeepSeek's API (Simon Willison). Few companies have this fallback ready: Menlo Ventures found open-source models handled 13% of enterprise AI workloads in mid-2025, down from 19% six months earlier, partly because they trail the best closed models by nine to 12 months. For one narrow task, test whether a smaller open model fine-tuned on your own examples meets your accuracy bar, which is the first step in LLM fine-tuning and consulting.

Running a model yourself means owning the runtime as well. When Ollama 0.34.1 dropped support for LoRA adapters in September 2026, fine-tunes served that way needed a new route, and I tested the two that work in Ollama no longer supports LoRA adapters. Pin the versions you depend on and test upgrades before they reach production.

Measure the return of each use case

Give every AI use case a baseline and a number, such as minutes per task, error rate or cost per thousand requests, and measure before and after. Unclear business value is one of the causes Gartner gives for its cancellation forecast, and a measured result answers it.

Write the exit into the contract

Avoid long prepaid commitments to loss-making start-ups, or keep them small enough to write off. In any AI contract, ask for:

export of your data, prompts, logs and any fine-tuned weights in a standard format, at any time;
notice before price changes (AWS raised its reserved GPU prices by about 15% on a Saturday in January 2026);
a termination right and the return of your data if the vendor becomes insolvent or is acquired;
clear ownership of anything trained on your data.

FAQ

Did the AI bubble burst in China?

China's AI stock bubble did. The STAR50 index fell 40% in under four months to late October 2026, wiping out about $480 billion, according to Reuters. Demand for AI computing held up: earlier in 2026, Chinese cloud providers raised AI compute prices by 5% to 34% and some AI firms rationed access.

Is AI a bubble?

Forecasters disagree. On the spending side, Microsoft, Alphabet, Amazon and Meta put $26.4 billion more into property and equipment than they generated in operating cash in the third quarter of 2026, and the IMF warns that faltering AI investment could trigger a correction in asset prices. On the revenue side, Google Cloud grew 103% in the same quarter and Microsoft reported $677 billion of contracted commercial revenue not yet recognised.

Will the AI bubble burst in 2027?

A few forecasters say so. Capital Economics expects the S&P 500 to fall 21% to 6,500 by the end of 2027, and Panmure Liberum's Joachim Klement says the AI bubble will burst in 2027 or 2028. They are in the minority: the seven other strategists Bloomberg tracks see about 14% upside for US stocks on average.

What happens when the AI bubble bursts?

Share prices and spending plans fall, but models already trained keep running. For a company using AI, the larger exposure is its vendors: Microsoft-backed Builder.ai, once valued at over $1 billion, entered insolvency proceedings in May 2025. Projects with a measured return are the easiest to defend when budgets tighten.

Are big tech companies spending more than they earn on AI?

In cash terms, three of them were in the third quarter of 2026. Alphabet, Amazon and Meta each spent more on property and equipment than their operating cash flow, while Microsoft spent $39.4 billion against $58.0 billion. The filings report total capital spending, with no AI-only figure.

How can a company protect its AI projects if the bubble bursts?

Call models through one interface so you can switch providers, and keep a tested open-weight model you can run yourself. Measure each use case against a baseline, and avoid long prepaid commitments to loss-making start-ups. Contracts should cover data export, notice of price changes and what happens if the vendor becomes insolvent.

Disclosure: written with AI assistance, from my own research and notes. Not investment advice.

Claude Code on Windows: Install and Setup for Beginners

Khadim Hussain — Tue, 27 Oct 2026 09:17:25 +0000

Originally published on khadim.tech.

In short: To install Claude Code on Windows, open PowerShell (no admin rights needed), run irm https://claude.ai/install.ps1 | iex, then open a new terminal and type claude --version. You need Windows 10 version 1809 or later, 4 GB of RAM and a paid Claude plan: the free plan doesn't include Claude Code, and Pro costs $20 a month, or $17 a month billed yearly. If Windows says claude is not recognized, add %USERPROFILE%.local\bin to your user PATH and open a new terminal.

Claude Code on Windows takes one command to install, and you don't need to know how to code to use it. I filmed the whole setup on a fresh Windows 11 install for my YouTube channel, Khadim Labs: the install, the PATH warning the installer gave me, the sign-in, and two real jobs done in plain English. This page has every command from the video, plus the fixes Anthropic's documentation lists for the errors beginners run into. Steps and prices are as of 27 October 2026.

Video: Claude Code on Windows: Full Beginner Setup (No Coding Needed)

What is Claude Code?

Claude Code is Anthropic's AI assistant that works on the files on your computer. The official overview calls it "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools."

A chatbot like ChatGPT answers in a browser tab. Claude Code runs in the terminal, the window where you type commands, inside a folder you choose, where it can read, create and change files and run commands. You describe the result, it works out the steps, and you check what it did. Developers use it to write software, but the two jobs in my video were a messy folder and a bakery website. It also runs in the Claude desktop app, in VS Code and on the web.

Is Claude Code free? What does it cost?

No. Claude Code needs a paid plan, and the free Claude plan doesn't include it. These are the individual plans on claude.com/pricing as of 27 October 2026, in US dollars and before tax:

Plan	Price	Claude Code	Usage per 5-hour session
Free	$0	No	Everyday questions
Pro	$20/month, or $17/month billed yearly ($200 up front)	Yes	At least 5x Free
Max 5x	$100/month	Yes	5x Pro
Max 20x	$200/month	Yes	20x Pro

Limits reset on a rolling five-hour window, paid plans add weekly limits on top, and the Claude app and Claude Code share one pool. There's no fixed message count: usage depends on how long and complex the work is and which model you pick. At a limit you can wait, upgrade, or turn on usage credits billed at API rates. Type /usage in Claude Code to see where you stand.

Start with Pro. Anthropic's help article for Pro and Max suggests Max 5x if you "consistently hit limits." To pay per use instead, a Claude Console account with prepaid API credits works too. One trap: if an ANTHROPIC_API_KEY environment variable is set on your PC and you approve it when Claude Code asks, it bills that API account instead of your plan.

What do you need to run Claude Code on Windows?

From Anthropic's system requirements:

Windows 10 version 1809 or later, or Windows Server 2019 or later, 64-bit
4 GB of RAM or more, with an x64 or ARM64 processor
An internet connection, in a supported country
A Pro, Max, Team, Enterprise or Console account

You don't need admin rights, Node.js or WSL. Git for Windows is optional: it adds Git Bash, which Claude Code uses for its Bash tool, and without it Claude Code runs commands through PowerShell. Choose WSL 2 only if you want Linux tools or Claude Code's sandbox, which native Windows doesn't support.

How do I install Claude Code on Windows?

Right-click the Start button (or press Win + X) and choose Terminal or Windows PowerShell. Check that the prompt starts with PS. Without PS you're in Command Prompt, which needs a different command (below).
Paste this line and press Enter:

   irm https://claude.ai/install.ps1 | iex

irm downloads the installer and iex runs it. It shows no progress while it downloads, and it took a few minutes for me. Anthropic's terminal guide says it ends with "Claude Code successfully installed!" Read the last lines anyway: mine also said the install folder wasn't on my PATH, which the next section fixes.

Close the terminal, open a new one, and check the install:

   claude --version

A working install prints a version number followed by (Claude Code). For a fuller check, claude doctor prints read-only diagnostics without starting a session.

The installer puts claude.exe in %USERPROFILE%\.local\bin and keeps it updated in the background. If you're in Command Prompt instead of PowerShell, use the CMD installer:

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

WinGet works too (winget install Anthropic.ClaudeCode), but it doesn't update itself, so run winget upgrade Anthropic.ClaudeCode now and then. To skip the terminal entirely, the Claude desktop app for Windows (x64 and ARM64) has a Code tab that runs Claude Code in a normal window.

Why does Windows say 'claude' is not recognized?

PowerShell shows claude : The term 'claude' is not recognized as the name of a cmdlet, and Command Prompt shows 'claude' is not recognized as an internal or external command. Both mean claude.exe is installed but its folder isn't on your PATH, the list of folders Windows searches for programs. The installer prints this under Setup notes: as Native installation exists but C:\Users\you\.local\bin is not in your PATH. and leaves PATH alone.

This is the fix I used in the video. It takes about 30 seconds, once:

Open Start and search for "environment variables for your account". Open it.
Under the user variables, select Path and click Edit.
Click New and type %USERPROFILE%\.local\bin.
Click OK, then OK again.
Close the terminal, open a new one, and run claude --version.

Or paste these two lines into PowerShell, from Anthropic's PATH troubleshooting, then open a new terminal:

$currentPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
[Environment]::SetEnvironmentVariable('PATH', "$currentPath;$env:USERPROFILE\.local\bin", 'User')

Still not recognized in a new window? A terminal inside an editor such as VS Code takes its PATH from the editor, so quit and reopen the editor. If the error started right after an update, the docs explain how to restore claude.exe from its backup.

Other Claude Code install errors on Windows, and their fixes

These are the Windows errors in Anthropic's installation troubleshooting page.

What you see	What it means	Fix
`'irm' is not recognized`	You're in Command Prompt	Open PowerShell, or use the CMD installer above
`The token '&&' is not a valid statement separator`	You ran the CMD command in PowerShell	Use the `irm` command
`A parameter cannot be found that matches parameter name 'fsSL'` or `'bash' is not recognized`	You ran the macOS/Linux command	Use the `irm` command
The script's text prints and nothing installs	You ran `irm` without `\	iex`
`Claude Code does not support 32-bit Windows`	You opened Windows PowerShell (x86)	Open the Start entry without "(x86)"
`The process cannot access the file ... because it is being used by another process`	An earlier install is still running, or antivirus is scanning the download	Close other installer windows, delete `%USERPROFILE%\.claude\downloads`, run the installer again
`Could not create SSL/TLS secure channel`	Usually an older Windows 10	Run the TLS line below, then the installer
Typing `claude` opens the desktop app	An older Claude Desktop registered its own `Claude.exe`	Update Claude Desktop
`App unavailable in region`	Claude Code isn't offered in your country	No workaround

The TLS fix for older Windows 10:

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
irm https://claude.ai/install.ps1 | iex

How do I start Claude Code for the first time?

Claude Code works inside a folder, so make one for your first project, move into it, and start Claude Code:

mkdir Documents\my-first-project
cd Documents\my-first-project
claude

The first time, it asks you to pick a text style, then how to sign in: pick your Claude subscription. Your browser opens, you sign in with the account that has your plan and approve, and the terminal shows "Login successful" and asks you to press Enter. If the browser doesn't open, press c to copy the login link. If it shows a code instead of sending you back, paste it at "Paste code here if prompted."

Next it asks whether you trust this folder. The highlighted answer was "No, exit", so I pressed the down arrow, then Enter. Say yes only for folders you made. Avoid starting it in your user folder itself: the security docs say trust given there isn't saved, so the question comes back every launch.

Then you're in. You type in the box at the bottom, and the welcome screen shows the version, the model and your folder. The line under the box says auto mode is on, the starting mode for terminal sessions since Claude Code 2.1.283. In auto mode, reads and file edits inside your folder just happen. Everything else goes to a second AI model, the classifier, which blocks risky actions such as downloading and running code or permanently destroying files that existed before the session. After 3 blocks in a row, or 20 in a session, it pauses and Claude Code asks you instead.

How to use Claude Code with no coding: two tasks I ran

I recorded on Claude Code 2.1.310. For the first task I put 16 files in the project folder, photos, PDFs, spreadsheets and a voice memo all mixed together, and typed:

Sort these files into folders by type, and don't delete anything.

It looked at the files, made the folders and moved each file. About two minutes later it was done: six folders, with all 16 files still there. It also offered to put the screenshots in a folder of their own.

For the second task I asked for a website:

Make a simple one-page website for a bakery called Sunrise Bakery, with a menu, prices, opening hours and a contact section. Open it in my browser when it's done.

It took a couple of minutes to write the page, then opened it in Edge: a menu with prices, the opening hours and a contact section. The address and phone number were placeholders, so you'd swap in real ones. Changes are one more sentence:

Make the colors warmer and add a photo gallery.

About two minutes later it opened the new version, in oranges and creams, with a gallery that has empty spaces ready for your own photos. Sorting the files and building the site raised no permission prompts in auto mode.

How to get better results from Claude Code

Describe the result you want, not the steps, and add your rules, like "don't delete anything." Both tasks above were one sentence of this kind.
Use plan mode for bigger jobs. Shift+Tab cycles the modes, from auto to manual, accept edits, then plan, so press it three times until the line under the box says plan mode, or type /plan before one request. Claude then reads and proposes but doesn't edit. When I asked it to "Add an online order form to the website," it asked clarifying questions with suggested answers first, then showed the plan and waited for my okay. The docs list the choices as "Yes, and use auto mode", "Yes, manually approve edits" and "No, keep planning."
Give it a memory. /init writes a CLAUDE.md file with notes about your project, which Claude reads at the start of every session. Add your own rules there, and keep it under 200 lines, as the memory docs advise.
Rewind when it goes wrong. Press Esc twice with an empty input box, or type /rewind, to restore your files, the conversation, or both to an earlier point. Rewind only tracks changes made with Claude's own file-editing tool, so files moved or deleted by commands may not come back. Keep backups.
Type /clear when you switch tasks. It starts a fresh conversation, and the cost docs note that stale context "wastes tokens on every subsequent message."

Also useful: Esc once stops Claude mid-task, Shift+Enter adds a new line in Windows Terminal, Alt+V pastes an image, and @ picks a file by name. A procedure you repeat can become a Claude Code skill.

Is Claude Code safe to use on Windows?

It's safe enough to learn on if you start it in a folder you made and read what it does. Auto mode approves file edits in your folder without asking, and Anthropic's own warning is that it "reduces permission prompts but does not guarantee safety." To approve every step yourself, press Shift+Tab once from auto to reach manual mode: Claude Code then asks before it edits files or runs commands, apart from read-only ones such as ls and git status. The security docs put it plainly: "You're responsible for reviewing proposed code and commands for safety before approval."

Native Windows also lacks Claude Code's sandbox, which only WSL 2 supports, so never start it in your whole user folder, and never paste passwords or API keys into it.

If you want Claude Code set up for your team's real work, that's part of my AI agent consulting.

FAQ

Is Claude Code free?

No. The free Claude plan doesn't include Claude Code. The cheapest plan that does is Pro, at $20 a month or $17 a month billed yearly, and its usage limits are shared with the Claude app on web, desktop and mobile.

Do I need to know how to code to use Claude Code?

No. You type what you want in plain English. In my beginner video it sorted a folder of 16 files and built a one-page bakery website, and I didn't write any code. You still need to read what it does and check the result.

Do I need admin rights to install Claude Code on Windows?

No. Anthropic's setup guide says you don't need to run the installer as Administrator. It puts claude.exe in %USERPROFILE%.local\bin, inside your own user folder.

Do I need WSL or Git to use Claude Code on Windows?

Neither. Claude Code runs natively on Windows 10 version 1809 or later. Git for Windows is optional: it adds Git Bash, and without it Claude Code runs commands through PowerShell. WSL 2 matters only if you want Claude Code's sandbox, which native Windows doesn't support.

Can I use Claude Code without the terminal?

Yes. The Claude desktop app for Windows has a Code tab that runs Claude Code with a graphical interface, and it needs the same paid plan. Anthropic's help center now lists it as the recommended way for Pro and Max subscribers to open Claude Code.

How do I update or uninstall Claude Code on Windows?

The PowerShell install updates itself in the background, and claude update applies an update right away. A WinGet install doesn't update itself, so run winget upgrade Anthropic.ClaudeCode. To remove the PowerShell install, delete %USERPROFILE%.local\bin\claude.exe and the %USERPROFILE%.local\share\claude folder.

Why is Claude Code using API credits instead of my Pro plan?

An ANTHROPIC_API_KEY environment variable is set on your PC and you approved it when Claude Code asked. Claude Code then bills that key's API account instead of your subscription. Turn the key off with the Use custom API key toggle in /config, or remove the variable, and check /status to see which login is active.

Disclosure: written with AI assistance, from my own recording and notes.

Claude Code Skills: How They Work and When They Trigger

Khadim Hussain — Sun, 25 Oct 2026 20:51:46 +0000

Originally published on khadim.tech.

In short: A Claude Code skill is a folder with a SKILL.md file: a short YAML header whose name and description tell Claude when to use it, then instructions that load only when the skill runs. Claude picks a skill up by itself when your request matches, or you run it as /skill-name. In my 108-run test on Claude Code 2.1.310, a skill loaded on 15 of 15 matching requests when either its name or its description said what it does, on 5 of 15 when neither did, and never with disable-model-invocation: true, in which case Claude did the job without the skill's rules.

I run Claude Code with 71 skills in my own agent repo, and I make short Claude Code tutorials on my YouTube channel, Khadim Labs. For the skills episode I had Claude Code write a skill from one sentence, and it made a decision I hadn't asked for. Then I measured when Claude actually loads a skill by itself, because every guide says "write a good description" and none of them shows what that changes.

What is a Claude Code skill?

A skill is a folder with a SKILL.md file that teaches Claude Code a procedure. The file has two parts: YAML frontmatter between --- lines, then Markdown instructions. Anthropic's skills documentation puts the frontmatter rule plainly: "All fields are optional. Only description is recommended so Claude knows when to use the skill." The name defaults to the folder's name.

---
name: tidy-folder
description: Sort the loose files in the current folder into subfolders by type. Use when the user asks to tidy, clean up, organize or sort a folder.
---

# tidy-folder

Only move files. Never delete or overwrite anything. Finish with a table of what moved.

Skills are cheap because of when they load. Claude Code keeps only the names and descriptions in context, and the "full skill content only loads when invoked." A 400-line procedure costs almost nothing until a request needs it, while CLAUDE.md loads in full every session. Skills follow the Agent Skills open standard, and Claude Code adds its own fields on top, such as invocation control and running a skill in a subagent.

Where do Claude Code skills go?

Scope	Path	Who gets it
Personal	`~/.claude/skills/<name>/SKILL.md`	You, in every project on this machine
Project	`.claude/skills/<name>/SKILL.md`	Everyone who clones the repo, once you commit it
Plugin	`<plugin>/skills/<name>/SKILL.md`	Wherever the plugin is enabled, as `/plugin-name:skill-name`
Enterprise	the managed settings directory	Every machine your organisation deploys it to

When two skills share a name, enterprise beats personal and personal beats project. Old .claude/commands/deploy.md files keep working, since "custom commands have been merged into skills", and a skill wins over a command file with the same name. /skills lists what Claude Code found. It also watches these folders, so a new or edited SKILL.md is live in the running session without a restart.

How to create a skill: I asked Claude Code to write one

You can write SKILL.md by hand, but the fastest way is to describe what you want. In a clean Windows VM running Claude Code 2.1.310, I typed:

Create a personal skill called tidy-folder. It sorts the files in the current folder into subfolders by type, puts screenshots in their own Screenshots folder, never deletes anything, and ends with a short table of what moved.

Fifty seconds later it had written ~/.claude/skills/tidy-folder/SKILL.md, 2,936 characters long. This is its frontmatter, unedited:

---
name: tidy-folder
description: Sort the loose files in the current folder into subfolders by type (Images, Documents, Spreadsheets, Audio, Video, Archives, Code, Other), put screenshots in a Screenshots folder, never delete anything, and finish with a table of what moved. Use when the user asks to tidy, clean up, organize or sort a folder.
disable-model-invocation: true
---

The body added rules I hadn't spelled out. It works only on files directly in the folder and skips hidden and system files. On a name clash it keeps both files by adding (1), (2) and so on, and it moves files with PowerShell's Move-Item without -Force. If the folder looks like a project (a .git folder, a solution file), it stops and asks first, because moving files could break it.

I never asked for the last line of the frontmatter. disable-model-invocation: true makes a skill manual-only: Claude won't load it by itself, and it runs only when you type /tidy-folder. Claude set it because the skill moves files. The docs describe the field the same way, for "workflows you want to trigger manually", and their own example is a skill that makes git commits.

Run by hand on a folder of 16 messy files, it reported "16 moved, 0 skipped, 0 deleted". Then I asked: "Change my tidy-folder skill so you can use it on your own whenever I ask you to tidy a folder." It deleted that one line. In a fresh folder of 16 files, a plain "Tidy up this folder." loaded the skill without any slash command, followed the same rules, and again moved 16, skipped 0 and deleted 0.

When does Claude use a skill by itself? I measured it

I gave Claude Code the same skill body under six frontmatters. Two things varied: whether the name says what the skill does (tidy-folder or helper), and whether the description does (the long one Claude wrote above, Folder utility. or General helper.). The sixth version is the specific one with disable-model-invocation: true added.

Each version got six requests: five that want the folder tidied, in different words, and one that only asks what's in it. I ran the set three times, 108 runs in all, on 26 October 2026. Every run started in a fresh folder with six dummy files and the skill in .claude/skills/, headless with claude -p on Claude Code 2.1.310 and Opus 5.5 (claude-opus-5-5). The skill listing also held the nine skills synced to my claude.ai account (PDF, Word, Excel and others), none of them about folders. A run counts as a trigger when Claude called its Skill tool. File commands were blocked, so nothing actually moved.

Name	Description	Tidy requests that loaded the skill	"What files are in this folder?"
`tidy-folder`	the specific one Claude wrote	15 of 15	0 of 3
`tidy-folder`	`Folder utility.`	15 of 15	0 of 3
`helper`	the specific one Claude wrote	15 of 15	0 of 3
`helper`	`Folder utility.`	13 of 15	0 of 3
`helper`	`General helper.`	5 of 15	0 of 3
`tidy-folder`	specific, plus `disable-model-invocation: true`	0 of 15	0 of 3

Claude reads the name as well as the description, and one clear signal was enough. A two-word description under a telling name triggered every time, and so did a meaningless name with a telling description. With neither, it fell to 5 of 15. The five tidy wordings made no real difference, and the request that only asked what was in the folder never loaded the skill, in any version.

The manual-only row needs a second look. Claude never loaded that skill, but it didn't refuse the job either: in all 15 runs it went straight to PowerShell or Bash to sort the files itself, without the skill's rules. If those rules matter (mine say never delete anything), type /tidy-folder, or let Claude load the skill on its own.

This test pits one skill against about a dozen others on one model. With many more skills, Claude Code starts dropping descriptions from the listing while keeping every name (next section), which is one more reason to name a skill after what it does.

Why isn't my Claude Code skill triggering?

Check these in order. I've hit the first two myself.

Neither the name nor the description says what the skill does. Use the words a person would type ("tidy, clean up, organize or sort a folder"), and put that use case first, because each description is cut at 1,536 characters in the listing.
disable-model-invocation: true is set. It can be there without you writing it, as my tidy-folder skill shows, so read the frontmatter before rewriting the description.
The frontmatter didn't parse. Claude Code reads frontmatter only when the opening --- is the file's first line. If the YAML between the markers is malformed, the skill loads with no fields, so /skill-name still works but Claude has no description to match. Field names must match exactly, hyphens included, and Claude Code ignores an unknown field without an error. claude --debug shows the parse error.
You have too many skills. The listing of names and descriptions gets about 1% of the model's context window, and when it overflows, Claude Code drops the descriptions of the skills you use least. /doctor estimates the listing's cost, and the skillListingBudgetFraction setting raises the budget.
The skill sets paths. It then activates only for matching files inside the current working directory.

The quickest check is to ask Claude "What skills are available?" If the skill isn't in the answer, Claude can't choose it.

Claude Code skills vs CLAUDE.md, slash commands, subagents and hooks

	When it loads	Use it for
`CLAUDE.md`	In full, every session	Facts and rules that always apply
Skill	Name and description always, body only when used	Procedures, checklists, reference material
Slash command (`.claude/commands/`)	Same as a skill; the two were merged	Existing commands; prefer a skill for new work
Subagent	In its own context window	Work that shouldn't fill your conversation; a skill with `context: fork` hands its instructions to one
Hook	Runs on every matching event	Rules that must hold every time, with no judgement involved

The docs give a simple test for moving something out of CLAUDE.md: "Create a skill when you keep pasting the same instructions, checklist, or multi-step procedure into chat, or when a section of CLAUDE.md has grown into a procedure rather than a fact." When Claude skips a rule that must hold every time, they recommend moving that rule into a hook.

What 71 skills in one repo taught me

My own agent repo holds 71 skills, covering how I review merge requests, publish this site and run the YouTube channel, among other jobs. Two lessons cost me real time.

Don't name a skill after a built-in command. I had a CV skill called resume, and Claude Code's built-in /resume, which reopens an earlier session, stopped working. That's documented behaviour: "In a local terminal session, your skill replaces the built-in command, but not its aliases." I renamed mine resume-cv, and the script that indexes my skills now refuses built-in names.

Keep one copy of each skill and point to it. My skills live in a plain skills/ folder that Claude Code doesn't scan. A script writes a one-line pointer for each into .claude/commands/<name>.md ("read skills/<name>/SKILL.md and follow it"), so /<name> works while the instructions stay in one place, and the same script fails the build when a pointer is missing or stale. When I first generated them, all 55 pointers worked in the already-running session, with no restart.

The skills episode, with the tidy-folder runs, is on my YouTube channel.

FAQ

Does a vague description stop Claude from using a skill?

Not if the name is clear. In my test a skill called tidy-folder with the description "Folder utility." loaded on 15 of 15 tidy requests. A skill called helper with "General helper." loaded on only 5 of 15, so give Claude at least one clear signal, and preferably both.

Do Claude Code skills use up context?

A little. Claude Code keeps every skill's name and description in context and loads the full SKILL.md only when the skill runs. Each description is cut at 1,536 characters, and the whole listing gets about 1% of the model's context window; past that, the least-used skills lose their descriptions but keep their names.

Do I need to restart Claude Code after adding a skill?

No. Claude Code watches the skill folders and picks up a new or edited SKILL.md in the running session. The exception is a top-level skills folder that didn't exist when the session started: run /reload-skills for that one.

What is the difference between a skill and a slash command?

Very little now. Custom commands were merged into skills, so .claude/commands/deploy.md and .claude/skills/deploy/SKILL.md both create /deploy. A skill adds a folder for supporting files and frontmatter that controls who can invoke it, and it wins if both exist with the same name.

How do I stop Claude from using a skill on its own?

Add disable-model-invocation: true to the frontmatter, and Claude Code runs the skill only when you type /skill-name. Claude still does the task if you ask for it in plain words: in my test it never loaded such a skill and sorted the files itself every time, without the skill's rules.

Can a skill run a script?

Yes. Put the script in the skill's folder and tell Claude in SKILL.md to run it, with ${CLAUDE_SKILL_DIR} in the path so it resolves wherever the skill is installed. Claude Code runs the script rather than loading its code into the conversation.

Do Claude Code skills work in other AI tools?

The format is the Agent Skills open standard, so the folder works in other tools that support it. Outside Claude Code only the standard's fields count: name, description, license, compatibility, metadata and allowed-tools. Claude Code's extras, such as disable-model-invocation, don't carry over.

Disclosure: written with AI assistance, from my own measurements and notes.

TensorRT INT8 vs FP16 on RF-DETR, Measured on an RTX 5090

Khadim Hussain — Fri, 23 Oct 2026 21:01:04 +0000

Originally published on khadim.tech.

In short: On an RTX 5090 with TensorRT 10.12, a calibrated INT8 build of RF-DETR put zero layers in INT8. TensorRT's own timing chose FP16 for every layer, so the INT8 engine was the FP16 engine: about 5x faster than the PyTorch FP32 forward, with no extra gain. Forcing INT8 through Q/DQ nodes made it 17% slower and wrecked accuracy. On a CPU without VNNI, only PyTorch dynamic INT8 sped the forward up (1.3-2x), and it changed some detection decisions. Distilling RF-DETR Medium into Nano with pseudo-labels lowered accuracy on every seed. For RF-DETR on an RTX 5090, TensorRT FP16 was the answer, and NVIDIA's own release notes point the same way for DETR models.

I maintain a training and serving engine for RF-DETR defect-detection models. When a model has to meet a cycle time on a given device, the first question is whether it can run faster, so I added a job that builds every faster variant of a trained model (TensorRT FP16 and INT8, CPU INT8 in two runtimes, and a distilled smaller student) and measures each one against the original on the same hardware and the same test images.

Most of the variants that are supposed to be faster were not. These are the measurements, the reasons, and what I recommend instead. The models and their training data stay private; the setup, the method and the ratios below carry over to any RF-DETR model.

How the INT8, FP16 and distillation variants were measured

Measured on 12 October 2026:


GPU	NVIDIA RTX 5090
CPU	12-vCPU QEMU virtual CPU, AVX2 only (no VNNI, AVX-512 or AMX)
Software	rfdetr 1.11.2, PyTorch 2.9.0 with CUDA 12.8, TensorRT 10.12, ONNX Runtime 1.23
Models	RF-DETR Nano detect at 384 px, RF-DETR Seg Nano at 312 px, RF-DETR Medium detect at 576 px, each fine-tuned on an industrial defect-detection set
Timing	median of 100 timed calls after 10 warm-up calls, at batch 1 and batch 4
Accuracy	mAP50:95 change against the FP32 original on a 10-image test set, plus decisions at a 0.5 threshold that changed

Each variant replaces only the network forward. rfdetr calls model.model.inference_model when a model is marked as optimized, so preprocessing, the decoder and the postprocessing are the same code for every variant, and any difference comes from the forward alone. The Nano measurements were repeated three times: forward medians stayed within about 6% on the GPU and 10% on the CPU, and accuracy was identical every time.

The test set is small, so read the accuracy changes as a direction, not a precise figure. The speed numbers are solid.

Why is TensorRT INT8 not faster than FP16 for RF-DETR?

Because TensorRT didn't use INT8. I built the INT8 engine the standard way: INT8 flag, an entropy calibrator over 64 training images, FP16 allowed as the fallback. Then I counted the precision of every layer in the finished engine:

Model	Layers in INT8	TensorRT FP16 vs PyTorch FP32 (batch 1)	TensorRT INT8 vs PyTorch FP32 (batch 1)
Nano detect @384	0 of 193	5.3x faster	5.3x faster
Seg Nano @312	0 of 259	5.7x faster	5.7x faster
Medium detect @576	0 of 225	4.8x faster	4.8x faster

With INT8 allowed, TensorRT times the candidate kernels for each layer and keeps the fastest. It kept FP16 every time, so the "INT8" engine was the FP16 engine with a different name. FP16 cost almost nothing in accuracy: mAP50:95 moved by 0.002 or less, and one decision changed on the segmentation model.

This is a known pattern for DETR models, not an RF-DETR quirk. NVIDIA's TensorRT 10.2 release notes list it as a known issue: "For some Transformer models, including ViT, Swin-Transformer, and DETR, there is a performance drop in INT8 precision (including both explicit and implicit quantization) compared to FP16 precision."

Forcing the issue didn't help. With explicit Q/DQ nodes in the ONNX graph, TensorRT put 166 layers in INT8. That engine was 17% slower than FP16, and mAP50:95 dropped by more than three quarters. I left it out of the job.

The calibrator route is going away

The same release notes deprecate implicit INT8 quantization and the calibrator APIs, IInt8EntropyCalibrator2 included, and NVIDIA's 10.x-to-11.x migration guide says implicit quantization is not supported in TensorRT 11. On TensorRT 11, INT8 means explicit quantization with Q/DQ nodes, the route that was slower here.

Check the precision TensorRT actually chose

An engine that builds with the INT8 flag is not proof that anything runs in INT8. Build with detailed profiling verbosity, then ask the engine inspector:

import json
import tensorrt as trt

# at build time: config.profiling_verbosity = trt.ProfilingVerbosity.DETAILED
inspector = engine.create_engine_inspector()
info = json.loads(inspector.get_engine_information(trt.LayerInformationFormat.JSON))
for layer in info["Layers"]:
    print(layer["Name"], layer["Outputs"][0]["Format/Datatype"])

Without detailed verbosity the inspector returns layer names only, which looks like an empty result rather than an error.

Does the network forward even matter on the GPU?

Barely, in this pipeline. The test frames are 16 megapixels, and preprocessing them for the model took most of each request: the TensorRT forward was between 1% and 5% of a request's time on the GPU host, decoding not even counted. Shrinking the network further would change nothing a user of the line notices. Profile the whole request before optimizing the model.

Does INT8 speed up RF-DETR on a CPU?

One method did, with a cost. I tried two:

Model	PyTorch dynamic INT8 vs FP32 forward	ONNX Runtime static INT8 vs PyTorch FP32 forward
Nano detect @384	1.3x faster (1.5x at batch 4), 1 decision changed	19% slower, 2 decisions changed
Seg Nano @312	1.6x faster (2.0x at batch 4), 4 decisions changed	9% slower, mAP50:95 −0.131, 32 decisions changed
Medium detect @576	1.4x faster (1.5x at batch 4), 3 decisions changed	36% slower, 3 decisions changed

PyTorch dynamic INT8 (torch.ao.quantization.quantize_dynamic on every nn.Linear) is a load-time transform with nothing extra to ship. It sped up the network forward by 1.3 to 2.0 times and the whole request by 1.2 to 1.3 times. Accuracy moved only slightly, between −0.014 and +0.009 mAP50:95, but 1 to 4 detections per model crossed the 0.5 threshold one way or the other on 10 images. In inspection, a changed decision is a missed defect or a false reject, so that matters more than the mAP change.

ONNX Runtime static INT8 (per-channel weights, MinMax calibration) was slower than plain PyTorch on this CPU, and its FP32 path was no faster than PyTorch either. It broke the segmentation model whatever the calibration. Percentile calibration helped the detection model (−0.011 instead of −0.026 mAP50:95 on the same images) but needed 30 GB of memory for the Medium model, because ONNX Runtime's histogram calibrators keep every activation of every calibration image in memory.

This CPU has no VNNI, AVX-512 or AMX. INT8 kernels depend on those instructions, so a server CPU that has them could give a different answer; I haven't measured one.

Does distilling RF-DETR Medium into Nano help?

Not with clean labels. The distillation was the simple, hard-label kind. The Medium model predicted on the training images. Every detection at 0.5 confidence or higher that no existing label of the same class already covered (IoU 0.5 or more) became an extra training box. Then two Nano students trained with the same configuration and the same three seeds: one on the labels alone, one on the labels plus the teacher's boxes. Each ran 20 epochs, with no early stopping and no augmentation, and both were scored on the untouched test set.

The student trained with pseudo-labels scored lower on every seed, by 0.025 mAP50:95 on average, and varied more between seeds (standard deviation 0.022 against 0.010). The reason is in what the teacher added. On a fully labelled training set it mostly re-found the existing labels, and it added two boxes across the whole set, both false positives on its weakest class. This kind of distillation can only add value through objects the annotators missed. It is worth trying on incompletely labelled data, and it has nothing to offer on clean labels.

The student was faster: 2.5 times on the CPU and 1.3 times on the GPU. But the Nano and Medium variants have 29.5M and 32.7M parameters, so the speed came from the input resolution (384 px against 576 px), not from a smaller network. If speed is what you need, retrain at a lower resolution and measure that first.

Feature- and logit-based distillation, which train the student on the teacher's internal outputs, weren't part of this test.

How to compare model compression methods fairly

Most of what I learned is about measuring, and it applies to any detector:

Swap only the forward. Run the same preprocessing, decoder and postprocessing for every variant, or you measure your pipeline changes rather than the compression.
Report medians. On a shared or virtual host, one stalled call in a hundred can triple a mean.
Record the host load. One run next to a training job measured a CPU forward more than 50 times slower than its real speed.
Calibrate on training images, never on the test set. Calibrating on the images you score flatters INT8.
Count changed decisions at your operating threshold. A small mAP change can hide detections that flip between found and missed.
Repeat anything that involves training, with three or more paired seeds, before reading a difference.
Check which precision actually ran, with the inspector above.

What should you use for RF-DETR?

Hardware	Use	Why
NVIDIA GPU (measured on an RTX 5090)	TensorRT FP16	About 5x the PyTorch FP32 forward, accuracy unchanged; INT8 gave no further gain
CPU without VNNI, AVX-512 or AMX	PyTorch FP32, or dynamic INT8 if your decisions survive it	1.3-2x faster forward, but check the flips at your threshold
Any, and still too slow	A lower input resolution, retrained	Where the distilled student's speed actually came from
Incomplete labels	Pseudo-label distillation, measured with seeds	The only case where the teacher adds real information

This covers one GPU, one CPU class and three RF-DETR variants. Jetson devices, CPUs with VNNI or AMX, and quantization-aware training for TensorRT 11's explicit INT8 are open questions here. They are the next things I would measure for a customer who needs one of them.

FAQ

Why is TensorRT INT8 not faster than FP16?

With a calibrator and the INT8 flag, TensorRT times INT8 and FP16 kernels per layer and keeps the faster one. For RF-DETR on an RTX 5090 it chose FP16 for every layer, so the INT8 engine was the FP16 engine. NVIDIA's TensorRT 10.2 release notes list INT8 as slower than FP16 for some Transformer models, DETR among them.

Can RF-DETR run in INT8 with TensorRT?

You can force it with Q/DQ nodes in the ONNX graph. In my test that put 166 layers in INT8, ran 17% slower than FP16 and cut mAP50:95 by more than three quarters. A calibrated build with FP16 allowed put no layer in INT8 at all.

Is the TensorRT INT8 calibrator deprecated?

Yes. TensorRT 10.2 deprecated implicit INT8 quantization and the calibrator APIs, IInt8EntropyCalibrator2 included, and NVIDIA's 10.x-to-11.x migration guide says implicit quantization is not supported in TensorRT 11. INT8 there means explicit quantization with Q/DQ nodes.

Does PyTorch dynamic quantization speed up object detection on CPU?

For RF-DETR on an AVX2-only CPU it made the network forward 1.3 to 2.0 times faster and the whole request 1.2 to 1.3 times faster. It also flipped 1 to 4 detection decisions at a 0.5 threshold on a 10-image test set, so check decisions, not only mAP, before shipping it.

Does knowledge distillation make RF-DETR faster?

The distilled Nano student was 2.5 times faster than the Medium teacher on CPU and 1.3 times on GPU, but nearly all of that came from its lower input resolution: the two models have 29.5M and 32.7M parameters. Training it on the teacher's pseudo-labels lowered accuracy on every seed compared with labels alone.

How do I see which layers TensorRT ran in INT8?

Build the engine with detailed profiling verbosity, then read its engine inspector as JSON and look at each layer's output data type. Without detailed verbosity the inspector lists only layer names.

Disclosure: written with AI assistance, from my own measurements and notes.

Ollama LoRA Adapters No Longer Supported: What to Do

Khadim Hussain — Wed, 21 Oct 2026 14:19:22 +0000

Originally published on khadim.tech.

In short: Since version 0.34.1 (September 2026), Ollama rejects every Modelfile with an ADAPTER line: "Error: LoRA adapters are no longer supported". The same release stopped converting safetensors to GGUF and stopped quantizing GGUF files. You have two ways to run a LoRA fine-tune now. One is to merge the adapter into the model and import a single GGUF into Ollama. The other is to keep the adapter separate and serve it with llama.cpp's llama-server --lora. I tested both with my Qwen3-14B adapter, on Ollama 0.40.7 and llama.cpp; on CPU the merged file generated about 13% faster.

I publish my Qwen3-14B STEM fine-tune three ways: as a LoRA adapter, as a merged model and as GGUF files. For a long time, the adapter route in Ollama was two lines in a Modelfile, a FROM for the base model and an ADAPTER for the fine-tune. On a current Ollama, that second line makes ollama create fail before it touches the model files. I tested what still works with the same adapter, end to end.

What changed in Ollama 0.34.1?

Ollama removed LoRA adapter support in PR #14969, merged on 15 September 2026 and shipped in v0.34.1. The PR limits ollama create to "wrapping existing GGUF inputs into Ollama manifests" and removes the built-in safetensors-to-GGUF converter and the server-side quantizer, "so GGUF conversion and quantization stay in llama.cpp tooling". Adapters went with the converter: the CLI and the server both reject a Modelfile that contains ADAPTER.

The release notes give this one line: "GGUF model creation now requires using llama.cpp tooling for safetensor conversion and quantization." The word adapter isn't in them. The ADAPTER section and the "Importing a fine tuned adapter" section have since been removed from the Modelfile and import docs, so the old instructions now live on mostly in blog posts and tutorials. Nothing has changed since: v0.40.7, released 18 October 2026, rejects adapters the same way.

What you do	Ollama 0.34.0 and earlier	Ollama 0.34.1 and later
`ADAPTER` line in a Modelfile (GGUF or safetensors adapter)	Applied on top of the `FROM` model	Rejected before anything is uploaded
`FROM` a GGUF file	Imported	Imported (unchanged)
`ollama create --quantize q4_K_M` on an F16 or F32 GGUF	Quantized by Ollama	Rejected; quantize with llama.cpp first
`FROM` a safetensors model directory	Converted to GGUF	Imported only through the MLX engine, which needs the MLX runtime
Models created with an adapter before the change	Ran with the adapter	The adapter layer is kept, with a deprecation warning in the server log

The last row comes from Ollama's own source: when it loads an older model that has an adapter layer, it logs "LoRA adapters are deprecated; the adapter layer is carried over but new adapters cannot be created" (server/model.go). I didn't have such a model to test.

What does "LoRA adapters are no longer supported" mean?

It means the Modelfile has an ADAPTER line, and Ollama 0.34.1 or later refuses to build any model that has one. I ran the variants against Ollama 0.40.7 on Windows. With ADAPTER pointing at the GGUF LoRA, or at the PEFT folder with adapter_model.safetensors, ollama create stops before it reads either file:

$ ollama create stem-qa -f Modelfile
Error: LoRA adapters are no longer supported

Pointing FROM at the GGUF LoRA itself gets one step further. Ollama copies the file, reads its header and refuses it there:

Error: LoRA adapters are no longer supported: qwen3-14b-stem-qa-lora-f16.gguf is a LoRA adapter

Asking Ollama to quantize a GGUF fails too, because quantization moved to llama.cpp as well:

$ ollama create stem-qa --quantize q4_K_M -f Modelfile
Error: create-time quantization is only supported for safetensors imports; quantize GGUF models before importing

Getting the error for a vision projector?

Some Modelfiles for vision models put the multimodal projector, the mmproj GGUF, on the ADAPTER line. Ollama rejects those now too, with the same message, even though a projector isn't a LoRA. The projector goes on a second FROM line:

FROM ./SmolVLM-256M-Instruct-Q8_0.gguf
FROM ./mmproj-SmolVLM-256M-Instruct-Q8_0.gguf

I tested this with SmolVLM-256M because it is small: with ADAPTER the create failed, and with two FROM lines it succeeded and ollama show listed the projector and the vision capability.

How do I use a LoRA fine-tune in Ollama now?

Merge the adapter into the base model, convert the result to GGUF, quantize it with llama.cpp, and point FROM at that file. Ollama still imports any GGUF; it just won't build one for you anymore.

Merge the adapter, then convert and quantize

If you trained with Unsloth, the model object does the merge and the GGUF export itself. These are the calls from my gpt-oss fine-tuning walkthrough, with this model's names:

# merged 16-bit model, for Transformers or vLLM, and the input for a GGUF
model.save_pretrained_merged("qwen3-14b-stem-qa-merged", tokenizer, save_method="merged_16bit")

# or merge, convert and quantize in one call
model.save_pretrained_gguf("qwen3-14b-stem-qa-gguf", tokenizer, quantization_method="q4_k_m")

With plain PEFT, load the base model in 16-bit, not 4-bit, so the merged weights aren't rounded to the 4-bit grid:

import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-14B", torch_dtype=torch.bfloat16)
model = PeftModel.from_pretrained(base, "khadim-hussain/qwen3-14b-stem-qa").merge_and_unload()
model.save_pretrained("qwen3-14b-stem-qa-merged")
AutoTokenizer.from_pretrained("Qwen/Qwen3-14B").save_pretrained("qwen3-14b-stem-qa-merged")

Then convert and quantize with llama.cpp, the two steps Ollama dropped:

python convert_hf_to_gguf.py qwen3-14b-stem-qa-merged --outtype f16 --outfile qwen3-14b-stem-qa-f16.gguf
llama-quantize qwen3-14b-stem-qa-f16.gguf qwen3-14b-stem-qa-q4_k_m.gguf Q4_K_M

My published Qwen3-14B GGUF came out of this path. Its metadata calls the model "Qwen3 14b Finetuned Merged", the name llama.cpp's converter takes from the merged model's folder, and the Q4_K_M file is 9.0 GB. Merging needs the whole 16-bit model in memory, and my F16 GGUF of it is 29.5 GB, so it is a step for the training machine rather than a laptop.

llama.cpp also has a merge tool that works on GGUF files directly, llama-export-lora, which applies a GGUF LoRA to a GGUF base and writes a merged file. Don't look for it in the release download: the Windows CPU zip I used (build b11793) loads its CPU backends dynamically, and llama.cpp's build file skips export-lora in that configuration (tools/CMakeLists.txt). You would have to build it from source with GGML_BACKEND_DL off. I didn't, because the merged GGUF from training already existed.

Import the merged GGUF into Ollama

The Modelfile loses its ADAPTER line, and FROM points at the merged file:

FROM ./qwen3-14b-stem-qa-q4_k_m.gguf

TEMPLATE """{{- if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}
{{- range .Messages }}
{{- if or (eq .Role "user") (eq .Role "assistant") }}<|im_start|>{{ .Role }}
{{ .Content }}<|im_end|>
{{ end }}
{{- end }}<|im_start|>assistant
"""

PARAMETER stop "<|im_end|>"
PARAMETER num_ctx 4096

ollama create qwen3-14b-stem -f Modelfile
ollama run qwen3-14b-stem "What is DNA?"

On Ollama 0.40.7 the create took 20 seconds, most of it spent copying the 9.0 GB file into Ollama's model store, and the first request loaded the model in 9.6 seconds. It answered the DNA question directly, in 49 tokens and without a <think> block, which is how the adapter behaves in llama.cpp below. The wording wasn't identical ("two long chains of nucleotides" where the adapter run says "two polynucleotide chains"). That is expected: this file was merged first and quantized afterwards, while llama.cpp adds the 16-bit adapter on top of an already quantized base, so the two setups don't compute exactly the same numbers.

The template loops over .Messages so that earlier turns of a chat keep their <|im_end|> and a SYSTEM line is used. I first published it with {{ .Prompt }} alone, which renders one question byte for byte the same (the runs above used it) but drops <|im_end|> after every earlier answer once a chat has history, and ignores SYSTEM. The gpt-oss post shows the rendered difference.

How do I run a LoRA adapter without Ollama?

llama.cpp still loads LoRA adapters, and it can apply one on top of a quantized base at run time. It needs the adapter as a GGUF file, so the first step is a conversion.

Convert the PEFT adapter to a GGUF LoRA

convert_lora_to_gguf.py ships with llama.cpp. It reads adapter_config.json and adapter_model.safetensors and needs only the base model's config, not its weights:

pip install -r requirements/requirements-convert_lora_to_gguf.txt
python convert_lora_to_gguf.py ./qwen3-14b-stem-qa \
  --base-model-id Qwen/Qwen3-14B \
  --outtype f16 \
  --outfile qwen3-14b-stem-qa-lora-f16.gguf

Pass --base-model-id for Unsloth adapters

Without it, the script follows base_model_name_or_path in adapter_config.json. Unsloth writes the 4-bit training copy there (unsloth/qwen3-14b-unsloth-bnb-4bit for my adapter), and the conversion stops with NotImplementedError: Quant method is not yet supported: 'bitsandbytes'. Point it at the original model instead. The base model ID only supplies the architecture and layer shapes; the LoRA weights come from the adapter file either way.

My adapter is rank 32 on all seven attention and MLP projections of the 40 layers, which makes 560 tensors. Each conversion took under a minute on my laptop's CPU:

Adapter file	Format	Size
`adapter_model.safetensors` (as trained)	F32	513.9 MB
`qwen3-14b-stem-qa-lora-f16.gguf`	F16	256.9 MB
`qwen3-14b-stem-qa-lora-q8_0.gguf`	Q8_0	136.5 MB

Serve the base model with the adapter on top

llama-server takes the base GGUF with -m and the adapter with --lora, and serves an OpenAI-compatible API plus its own /completion endpoint:

llama-server -m Qwen3-14B-Q4_K_M.gguf \
  --lora qwen3-14b-stem-qa-lora-f16.gguf \
  -c 4096 --port 8090

On my laptop (Intel Core Ultra 9 285H, 32 GB RAM, no GPU) the server was ready about 15 seconds after start. The log prints one cannot use buft 'CPU_REPACK', fallback to CPU warning per adapter tensor, 240 of them here. They mean the adapter weights sit in a plain CPU buffer rather than a repacked one, and generation still works.

Each request can set the adapter's strength through a lora field, so one server answers as the base model and as the fine-tune:

curl http://127.0.0.1:8090/completion -d '{
  "prompt": "<|im_start|>user\nWhat is DNA?<|im_end|>\n<|im_start|>assistant\n",
  "n_predict": 160, "temperature": 0,
  "lora": [{"id": 0, "scale": 1.0}]
}'

With the scale at 0, Qwen3-14B opened a <think> block and was still reasoning when it reached the 160-token limit. With the scale at 1, the fine-tune answered in 74 tokens and stopped:

Deoxyribonucleic acid is a polymer composed of two polynucleotide chains that coil around each other to form a double helix carrying genetic instructions for the development, functioning, growth and reproduction of all known organisms and many viruses.

So the adapter was applied: the fine-tune skips Qwen3's reasoning block and answers directly. GET /lora-adapters lists the loaded adapters and their ids, and POST /lora-adapters sets the scale for requests that don't send one. Start the server with --lora-init-without-apply if the adapter should be off by default.

The Q8_0 adapter loads the same way. At temperature 0 its answer to the DNA question differed from the F16 adapter's by a few words ("development, survival and reproduction of all known living organisms" instead of "development, functioning, growth and reproduction of all known organisms"). At half the file size, that makes Q8_0 a reasonable default for this adapter.

Is a runtime LoRA slower than a merged model?

A little. I loaded the merged GGUF and the base-plus-adapter setup side by side, then alternated requests between them: 128 tokens each, temperature 0, four rounds, CPU only with 16 threads.

Setup	Prompt processing (tokens/s)	Generation (tokens/s)
Merged Q4_K_M GGUF	21.1	5.33
Base Q4_K_M + F16 LoRA, adapter off (scale 0)	22.0	5.23
Base Q4_K_M + F16 LoRA, adapter on (scale 1)	19.6	4.66

These are medians. With the adapter on, generation was about 13% slower than the merged file, and prompt processing about 7% slower. I measured CPU only. Alternating matters on a laptop: an earlier run, with a large download going in the background, varied more between identical requests than these setups vary from each other.

For one fine-tune that should always be on, the merged file is faster. The adapter route pays off when one base model serves several adapters, or the plain base model as well.

Which route should you use?

Route	You ship	Runs in	Use it when
Merged GGUF	One full model file (9.0 GB at Q4_K_M for a 14B model)	Ollama, llama.cpp, LM Studio	You want `ollama run` to keep working, or you hand the model to people who use Ollama
GGUF LoRA + base GGUF	A small adapter file plus a base model the user may already have	llama.cpp (`llama-server`, `llama-cli`)	You have several fine-tunes of one base, or you want to switch an adapter on and off per request
Safetensors adapter	The PEFT adapter as trained	vLLM (`--enable-lora`), Transformers, Unsloth	You serve on a GPU and want many adapters on one base (vLLM LoRA docs); I didn't test this route here
Stay on Ollama 0.34.0	Your existing Modelfile	Ollama 0.34.0	Only as a stopgap: you give up every Ollama release since September 2026

For most people who were using ADAPTER in Ollama, the merged GGUF is the shortest path back: the Modelfile loses one line and points FROM at the merged file. Keep the adapter as well, because it is the file you build every other format from.

FAQ

Can Ollama load a LoRA adapter?

Not since version 0.34.1, released in September 2026. Any Modelfile with an ADAPTER line fails with "Error: LoRA adapters are no longer supported", whether the adapter is a GGUF file or a safetensors folder. Merge the adapter into the model and import the merged GGUF instead, or serve the adapter with llama.cpp.

Which Ollama version removed LoRA support?

Version 0.34.1. Version 0.34.0, released on 5 September 2026, was the last one that applied an ADAPTER. The change came in pull request #14969, which also removed Ollama's built-in safetensors-to-GGUF converter and its quantizer.

Can I still use a model I created with an adapter before 0.34.1?

Ollama's source keeps the adapter layer of models that already exist and logs a deprecation warning when it loads one. You can't create a new one, and re-creating that model from its Modelfile will fail on the ADAPTER line. I didn't have an older adapter model to test.

How do I convert a LoRA adapter to GGUF?

Run llama.cpp's convert_lora_to_gguf.py on the folder that holds adapter_config.json and adapter_model.safetensors. If the adapter's config names a quantized training copy of the base (Unsloth writes a bnb-4bit repo there), pass --base-model-id with the original model. The converter needs only the base model's config, not its weights.

Does llama.cpp still support LoRA adapters?

Yes. llama-server and llama-cli load a GGUF LoRA with --lora on top of a base GGUF, including a quantized one, and llama-server can change an adapter's scale per request through a lora field. llama.cpp refuses an adapter whose architecture or tensor shapes don't match the base, but it can't tell two same-sized bases apart, so pairing the right base is still on you.

Why does ollama create --quantize fail on my GGUF?

The same 0.34.1 change moved quantization out of Ollama for GGUF models. Ollama 0.40.7 answers with "Error: create-time quantization is only supported for safetensors imports; quantize GGUF models before importing". Quantize the F16 file with llama.cpp's llama-quantize, then import the result.

Disclosure: written with AI assistance, from my own notes and test runs.

BLUF Meaning: Examples for ML Engineers and Data Scientists

Khadim Hussain — Sun, 18 Oct 2026 20:45:14 +0000

Originally published on khadim.tech.

In short: BLUF stands for bottom line up front. The first sentence of a message says what you need or what you concluded, and everything after it supports that sentence. In ML work, that means opening with the decision, the date or the business impact, and keeping metrics like ROC-AUC, the debugging story and tool names for later, or for the engineers who ask. Below are before-and-after examples for a production rollback, a delayed project, a GPU budget request, an A/B test, a client question, a chat message and an interview answer.

I recently made BLUF the rule for everything I write at work: status updates, emails, merge request descriptions and chat replies. I work remotely, in a different time zone from most of the people who read my messages, so a message is usually read once, quickly, between other things. When the ask sits in the third paragraph, it waits until the next day.

ML updates are especially easy to get wrong this way. The investigation is the part we find interesting, so that is where we start, and the reader has to get through the ROC-AUC numbers and the drift theory before finding out what we want from them.

What does BLUF mean?

BLUF stands for bottom line up front: put the conclusion, the recommendation or the request in the first sentence, and the supporting detail after it. The phrase comes from the US Army's correspondence regulation, AR 25-50, which tells writers to put the main point at the beginning and to use the active voice (Wikipedia summarises the history).

Kabir Sehgal, writing about military email for Harvard Business Review, describes the BLUF as a short opening statement that "declares the purpose of the email and action required." His example from the US Air Force:

BLUF: Effective 29 Oct 13, all Air Force Doctrine Documents (AFDDs) have been rescinded and replaced by core doctrine volumes and doctrine annexes.

A reader who stops after that sentence knows what changed, from when, and that they need to switch documents. Anything after it is optional reading.

The BLUF + SCR structure

BLUF tells you where the point goes. For what comes after it, I use a short version of the Situation, Complication, Question framework from Barbara Minto's Pyramid Principle, with the question replaced by the answer you are proposing:

BLUF:          what you need, or what you concluded, in one sentence a reader could act on
Situation:     one line of context the reader already agrees with
Complication:  what changed or what is blocking, in business terms
Resolution:    what you propose, by when, and what it gets them

A short reply is just the first line. A decision request to a manager or client gets all four, and each one stays at a sentence or two. Good news has no complication, so you skip it.

ML terms to cut, and what to say instead

Executives and clients read for impact, timeline, cost, risk and the decision they need to make. Tool names and metrics belong in the message only when the reader asked for them or is an engineer who needs them. These are the translations I reach for most:

Instead of	Say
ROC-AUC fell from 0.88 to 0.61	The model is now wrong on far more cases, and here is who that affects
Precision is 0.74	About 1 in 4 cases we flag is a false alarm
Data drift	Customer behaviour has changed since the model was trained
Overfitting	It does well on the data it learned from and worse on new cases
Hyperparameter tuning	A week of tuning to improve accuracy
p < 0.01	The result is very unlikely to be chance
CUDA out of memory on the current GPUs	Training needs a bigger machine, at a cost of X per month
Retrain on fresh data	Update the model with recent data, which takes N days

BLUF examples for ML engineers and data scientists

These scenarios are illustrative

The situations and numbers in examples 1 to 6 are made up to show the shape. Swap in your real figures. Example 7 uses a real result from my own work.

1. A model is failing in production

Before:

I was looking at the logs for the fraud model and noticed ROC-AUC dropped from 0.88 to 0.61. I think it might be data drift, because marketing launched a new campaign that changed the input distributions...

After:

BLUF: I need approval to roll the fraud model back to version 2.1 by 2:00 PM to stop legitimate customers being blocked at checkout.

Situation: Version 3.0 has been live for 48 hours.

Complication: The new marketing campaign changed how customers behave, and accuracy has fallen 27%, so good transactions are being rejected.

Resolution: Rolling back restores normal checkout immediately. We then retrain 3.0 on the new traffic, which takes 3 days.

2. A project is delayed by a data problem

Before:

We're blocked on the churn model. The upstream pipeline is broken and the schemas don't match, so my dataframe keeps throwing errors...

After:

BLUF: The churn prediction dashboard will slip one week, to November 15, unless the data pipeline is fixed today.

Situation: We are building the model that tells sales which accounts are likely to leave.

Complication: Last week's database migration dropped the timestamps from the activity logs, and training cannot run without them.

Resolution: I have asked Data Engineering for a fix. If it lands today, we still deliver on November 8.

3. Asking for a GPU budget

Before:

Our workstations are too slow. Training takes four days because we're on older consumer GPUs and the batch size is capped. We should move to cloud GPU instances...

After:

BLUF: I'm requesting $3,500 a month for cloud GPUs, which brings the support assistant's launch forward by three weeks.

Situation: We are training a support model to cut call-centre volume.

Complication: Each training run takes 4 days on our current hardware, which pushes the launch past the holiday season.

Resolution: Cloud GPUs cut a run to 3 hours. We launch three weeks earlier and save an estimated $20,000 in support costs.

The before version argues for convenience. The after version prices the delay, which is what the person approving the money is weighing.

4. Reporting an A/B test win

BLUF: I recommend moving the new recommendation model to 100% of traffic. In a two-week A/B test it lifted checkout conversion by 4.5%, at 99% confidence.

Situation: The test split traffic evenly between the current model and the new one.

Resolution: With your go-ahead, we deploy tomorrow morning. The projected gain is $12,000 a week.

There is no complication line, because nothing went wrong.

5. A client asks "is the model ready?"

Before:

Validation mAP is at 0.91 now and recall on the defect class is 0.97. We still see some false negatives on small scratches, mostly under low lighting, so we're adding augmentation...

After:

Not for fully automatic rejection yet, but it is ready to flag parts for a human to check. In testing it catches 97 of every 100 defects, and the line needs 99 before it can run without a person. The misses are mostly small scratches in poor lighting. Two more weeks of data collection should close that gap, and I'll send the next numbers on the 30th.

A client question gets an answer in the first word. "Not yet" with a usable alternative beats a page of metrics they have to interpret themselves.

6. A chat message

Labels look stiff in chat, so keep the order and write it as plain sentences:

Can't make Thursday 3 PM. Can we do Friday 11 AM instead? The GPU delivery moved to Thursday afternoon and I need to be there to sign for it.

The request comes first, the alternative second, the reason last.

7. An interview answer

Question: "Tell me about a time you improved a model in production."

I improved our inference speed by 70% by moving model serving to TensorRT, ONNX and Triton. The context was an internal inference engine used across the ML team...

The result is in the first sentence, and the story after it explains how. If the interviewer cuts you off after ten seconds, they already have the part that matters. Nobody says "BLUF" out loud in an interview; you just answer first.

Should you write "BLUF:" in the message?

In formal writing, such as status reports, escalations and decision requests, the label helps, as long as the readers know what it means. Sehgal drops the acronym in his corporate job because it would be unclear to his recipients, and starts with a bold "Bottom line:" instead. In chat, client messages and proposals I leave labels out entirely. The first sentence carries the bottom line and the rest is ordinary prose, because a message full of bold labels reads like a form.

How I use BLUF in my own writing

Every page on this site opens with an "In short" box that answers the page's question before the article starts. The SynthID test begins "Mostly, for what it is built to do," and then spends the rest of the page on the evidence. Search engines and AI answer tools quote passages, so a page with its conclusion in the first two sentences tends to be quoted with that conclusion attached.

I also wrote the rule into the instructions my coding agent follows, so any message it drafts for me starts with the bottom line, and so do its reports back to me. The test I use is the same everywhere: if the reader stopped after the first sentence, would they know what I need from them?

If you're preparing results for a stakeholder, or deciding whether a fine-tuned model is worth the effort, I'm happy to look at it with you.

FAQ

What does BLUF stand for?

Bottom line up front. The term comes from US Army correspondence rules, which put the main point or recommendation at the start of a memo instead of the end. Outside the military it is used for email, status reports and any message where the reader may only read the first line.

Should I write "BLUF:" at the top of the email?

Only if your readers know the term. Kabir Sehgal, who wrote about military-style email for Harvard Business Review, starts his corporate notes with a bold "Bottom line:" instead, because the acronym would be unclear to his recipients. The order matters more than the label.

What is the difference between BLUF and SCR?

BLUF says where the main point goes: first. SCR (situation, complication, resolution) is a way to arrange the context that follows it. Together they give one sentence with the ask or conclusion, then a line each on the background, what changed, and what you propose.

How do I explain model performance to non-technical stakeholders?

Say what the metric changes for them: customers affected, revenue, cost, time or risk. "About 1 in 4 transactions we block belongs to a real customer" lands where "precision is 0.74" does not. Keep the metric ready for anyone who asks for it.

Does BLUF work for good news?

Yes. Lead with the decision the good news supports, such as moving a new model to all traffic, then give the result that justifies it. A good result sent without an ask often gets a thumbs-up and no decision.

Disclosure: written with AI assistance, from my own notes and examples.

Training FLUX.2 and Kolors LoRAs on a space dataset

Khadim Hussain — Tue, 13 Oct 2026 07:26:26 +0000

Originally published on khadim.tech.

In short: A space-themed image generation project: a dataset of 1,964 image-caption pairs from NASA, Wallhaven and LAION-Aesthetics, auto-captioned with JoyCaption, and LoRA adapters trained on FLUX.2-klein (9B) and Kolors. The dataset has 3,300+ downloads on Hugging Face.

The dataset

Kiffusion is 1,964 image-caption pairs of space and sci-fi imagery, collected from NASA, Wallhaven and LAION-Aesthetics. Every image was captioned automatically with JoyCaption, so the captions describe composition and lighting in the detail a diffusion model needs, instead of relying on short alt text.

The LoRAs

SpaceVision is the set of LoRA adapters trained on that dataset, using SimpleTuner and Diffusers:

FLUX.2-klein (9B), a 38 MB adapter
Kolors, a 46.6 MB adapter

A LoRA trains a small set of extra weights instead of the whole model, so the adapters stay small enough to download and swap in seconds.

What got used

Download counts from Hugging Face, all time, as of October 2026:

Artifact	Type	Downloads
kiffusion-space-scifi	Dataset	3,306
spacevision-flux2-lora	LoRA for FLUX.2-klein	204
spacevision-kolors-lora	LoRA for Kolors	66

The dataset is used far more than the adapters, which suggests that a well-captioned niche dataset is the more reusable artifact.

Is SynthID reliable? I tested Google's AI image check on screenshots, stripped files and real photos

Khadim Hussain — Mon, 12 Oct 2026 18:40:48 +0000

Originally published on khadim.tech.

In short: Mostly, for what it is built to do. In my tests on October 12, 2026, Google's SynthID check in the Gemini app flagged a Gemini-generated image after its metadata was removed and again after a screenshot, and found nothing on a real photo. It missed the same AI image once it was pasted small into a real photo, and the new SynthID Detector website failed on every upload that day. A clean result only means no watermark from Google or its partners was found.

Google opened the SynthID Detector to everyone on October 7, 2026. Most of the coverage so far repeats the launch post, so I generated some images and tested the questions people search for. Does it survive a screenshot? Does it need the file's metadata? Will it flag a real photo?

What SynthID Detector is

SynthID is Google DeepMind's invisible watermark for AI-generated images, video and audio. Google's launch post says it has watermarked over 180 billion images and videos and 240,000 years of audio. The Detector reads watermarks from Google and its partners: OpenAI, NVIDIA, Kakao and, soon, Apple. You sign in with a Google, Apple or OpenAI account, then upload a file.

It is not a general AI detector. It answers one question: does this file carry a SynthID watermark? The same check is built into Search, Chrome and the Gemini app, which together handle over a million verification requests a day, according to Google.

How I tested it

I generated two photorealistic images with Gemini 3 Pro Image through the Gemini API (2400 × 1792 px). Google's image generation docs say "All generated images include a SynthID watermark." From one of them I made these test files:

the original file, untouched
the same pixels with the metadata removed (a pixel diff against the original is exactly zero)
a real screenshot: the image shown in Chrome, captured from the screen and saved as a 2048 × 1523 PNG
a real photo from NASA's public image library, taken at Kennedy Space Center in 2023
a second NASA photo with only the sky changed by Gemini
the AI image pasted small into the corner of the real photo

The Detector was the plan, but on October 12 all four of my uploads, between 4:36 and 5:33 pm UTC, ended in "Something went wrong! Please wait and try again later." That included a 166 KB file, so it wasn't file size. So I used the SynthID check built into the Gemini app: a fresh chat for each file, my personal account, and the question "Is this AI-generated?"

I kept to things a normal user would check. The Detector's terms forbid using its results to work out which transformations break the watermark, so I didn't build a grid of crops, filters and compression levels.

The results

Content Credentials (the C2PA standard) are signed metadata that record how a file was made. SynthID is the watermark in the pixels. Here is what Gemini said about each file:

File	Content Credentials in file	Gemini's answer	What it used
Gemini image, untouched	Yes, signed by Google LLC	"created using artificial intelligence by Google LLC, followed by subsequent editing using AI tools"	C2PA metadata
Same pixels, metadata removed	No	"Most or all of this image was edited or generated with Google AI." (2 of 2 runs)	SynthID
Screenshot of it (PNG)	No	"Most or all of this image was edited or generated with Google AI." (2 of 2 runs)	SynthID
Real photo (NASA, 2023)	No	"No reliable signals were detected indicating how the content was created"	Nothing found
Real photo, sky edited in Gemini	Yes, signed by Google	"created as a generative AI creation and subsequently edited using generative AI tools"	C2PA metadata
AI image pasted small into the real photo	No	"No reliable signals were detected"	Missed

Metadata removed, pixels untouched: Gemini still finds Google's watermark.

Does SynthID work on screenshots?

It did in mine. A screenshot changes the image: it's rescaled to fit the screen, re-rendered by the browser and saved in a different format. Gemini flagged it both times. The second answer also said "No reliable C2PA content credentials were detected for this file", so the detection came from the pixels.

A screenshot of the image, saved as PNG: flagged, with no C2PA credentials left in the file.

Not every screenshot test agrees. On October 8, Digital Information World reported that the Detector website flagged their image as a standalone file but not as a screenshot. Mine was cropped to the image and checked in Gemini, and theirs used the Detector, so the two aren't directly comparable. Either way, a screenshot is a weaker test than the original file.

Google's own claim is narrower. Its SynthID page says the image watermark is "designed to stand up to modifications like cropping, adding filters, changing frame rates, or lossy compression." Screenshots aren't on that list.

SynthID vs C2PA: the two labels inside a Gemini image

Every Gemini image I made carried two separate labels, and the check reads both.

	C2PA Content Credentials	SynthID
Where it lives	Signed metadata in the file (about 6 KB here)	In the pixels
What it records	Who made it, which tool, edit history	Only that a Google or partner model made it
Survives a re-save or screenshot	No	Yes, in my tests
Who can read it	Anyone, with open tools	Google's tools only

Removing the metadata, or re-saving the image as a 1080 px JPEG, deleted the C2PA manifest completely. The file then relies on SynthID alone. You can read the credentials yourself with c2pa-python (version 0.38.0 here):

import json
from c2pa import Reader

reader = Reader("gemini-image.jpg")
store = json.loads(reader.json())
manifest = store["manifests"][store["active_manifest"]]
print(manifest["signature_info"]["issuer"])
for assertion in manifest["assertions"]:
    if assertion["label"].startswith("c2pa.actions"):
        for action in assertion["data"]["actions"]:
            print(action["action"], action.get("digitalSourceType"))

Google LLC
c2pa.created http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia
c2pa.edited http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia

trainedAlgorithmicMedia is the IPTC term for media created by a generative model. If you'd rather not run code, contentcredentials.org/verify reads the same manifest in the browser.

With the metadata intact, Gemini answers from the C2PA credentials and doesn't mention SynthID.

Is SynthID reliable? What a result tells you

A positive result is strong evidence. Gemini identified the untouched file from its metadata, and the stripped copy and the screenshot from the watermark, while the real photo came back clean. One photo isn't a false-positive rate, though.

A negative result is weak evidence:

It only knows its partners. An image from a generator outside the SynthID scheme will always come back clean.
It missed a composite. The same AI image, pasted small into the corner of a real photo, came back "No reliable signals were detected." Digital Information World saw the same on the Detector website: an AI image covering more than half of a new image came back as unlikely to be from a SynthID partner.
The check has slipped before. In July, Lead Stories found that within one chat, Gemini repeated its verdict on the first file when asked about a second one, for images and videos. Google said on July 16, 2026 that a fix had rolled out globally. I still used a fresh chat for every file.

An AI image pasted small into a real photo (background: NASA, public domain): not detected.

How you ask matters

My first prompt was "Was this image created or edited with Google AI? Please check it for a SynthID watermark." On the metadata-stripped file, Gemini answered that it couldn't check for a watermark at all. Asked "Is this AI-generated?", which is Google's own suggested wording, it found the watermark both times. That was one run against two, but if Gemini says it can't check, ask again with the plain question in a new chat.

How to check an image yourself

In the Gemini app, upload the image in a new chat and ask "Is this AI-generated?" In my tests it answered from C2PA when the file had it, and from SynthID when it didn't.
On the SynthID Detector, sign in at synthid.com and upload the file. It covers Google's partners as well, and shows which parts of the image are most likely watermarked.
For Content Credentials, use contentcredentials.org/verify, or the code above, to see the signed history, if the file still has it.
Read a clean result as "unknown", not "real".

What about AI-generated text?

The image watermark is closed, but SynthID Text is open source. It ships in Hugging Face Transformers 4.46 and later as a watermarking config passed to generate(), with a Bayesian detector. Text detection is probabilistic, and I didn't test it here.

If you build image pipelines

Any step that decodes and re-encodes an image (resizing, thumbnails, format conversion) drops the C2PA manifest, as the 1080 px re-save above showed. If provenance matters to your product, carry the manifest through with the C2PA SDK rather than relying on the watermark alone. SynthID survived the re-save and the screenshot in my tests, but only Google's tools can read it.

FAQ

Does SynthID work on screenshots?

Sometimes. My screenshot of a Gemini image, cropped to the image and saved as a PNG, was flagged by Gemini's check in both runs, from the watermark in the pixels. Digital Information World's screenshot test on the SynthID Detector website failed on October 8, 2026. Use the original file whenever you can get it.

Is SynthID the same as C2PA Content Credentials?

No. C2PA Content Credentials are signed metadata stored in the file, and a normal re-save or upload removes them. SynthID is a watermark in the pixels themselves. Gemini images carry both, and Gemini's check reads whichever one it finds.

Can SynthID detect Midjourney or Stable Diffusion images?

Only if the generator embeds SynthID. Google lists itself, OpenAI, NVIDIA and Kakao as the companies whose watermarks the Detector reads, with Apple to follow. Anything else comes back as no watermark found, which says nothing either way.

Does SynthID have false positives?

A real photo came back clean in my test, but that is one photo, not a false-positive rate. Treat a positive result as strong evidence the image passed through Google's or a partner's AI tools, and a negative one as unknown.

Is SynthID open source?

The text watermark is: SynthID Text ships in Hugging Face Transformers 4.46 and later, with a reference implementation on GitHub. Image, video and audio detection is only available through Google's tools, such as the SynthID Detector and the Gemini app.

Fine-tuning gpt-oss-20b with Unsloth and running it in Ollama

Khadim Hussain — Sun, 11 Oct 2026 21:08:28 +0000

Originally published on khadim.tech.

In short: gpt-oss-20b fine-tunes with QLoRA on a single consumer GPU (Unsloth puts it at about 14 GB of VRAM). Shipping it is where the chat template matters: gpt-oss uses OpenAI's Harmony format, so the GGUF needs a Harmony template with <|return|> as a stop token, or Ollama gives gibberish or never stops.

I fine-tuned gpt-oss-20b for STEM reasoning and published it three ways: a LoRA adapter, a merged 16-bit model and GGUF files. Below are the settings and versions behind it, the export code, and the Modelfile that makes the GGUF behave in Ollama.

QLoRA settings for gpt-oss-20b

The published run, as recorded on the model card:

Setting	Value
Base model	openai/gpt-oss-20b (21B parameters, mixture of experts)
Method	QLoRA, 4-bit base weights
LoRA rank / alpha	32 / 64
Learning rate	1e-4
Batch size	1, with gradient accumulation 16
Optimizer	AdamW 8-bit
Epochs	1
Data	4,260 training and 474 evaluation examples of STEM Q&A with chain-of-thought
Result	train loss 1.087, eval loss 0.837
Framework	Unsloth + TRL

The full training config, with target modules and scheduler, is in configs/gpt_oss_20b.yaml in kllm, the small toolkit I use for these runs.

How much VRAM does fine-tuning gpt-oss-20b need?

QLoRA keeps the base weights in 4-bit and trains only a small adapter, so a 20B model fits on one consumer card. Unsloth's gpt-oss guide lists about 14 GB of VRAM for gpt-oss-20b with QLoRA and recommends at least 16 GB for stable runs. LoRA on unquantized BF16 weights needs about 44 GB, which is why QLoRA is the practical choice on one card.

The environment kllm is verified on:

Component	Version
GPU	RTX 5090 (32 GB)
OS	Ubuntu 24.04
CUDA	12.8 toolkit (13.0 driver)
Python	3.12.3
PyTorch	2.9.1+cu128
Unsloth	2026.1.4
transformers	4.57.3
vLLM	0.15.0

Pin transformers. vLLM 0.15.0 needs exactly transformers 4.57.3, and other versions fail with import errors. Install in this order, and force the pin last.

uv pip install -U vllm --torch-backend=cu128   # cu121 for RTX 40 series
uv pip install unsloth unsloth_zoo bitsandbytes
uv pip install --force-reinstall "transformers==4.57.3"

Export to LoRA, merged and GGUF with Unsloth

After training, the same model object gives all three formats. These are the calls kllm makes:

# 1. LoRA adapter (~61 MB): for people who already run the base model
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

# 2. Merged 16-bit model (~41 GB): for Transformers or vLLM, no adapter handling
model.save_pretrained_merged(f"{output_dir}-merged", tokenizer, save_method="merged_16bit")

# 3. GGUF for llama.cpp, Ollama and LM Studio, one call per quantization
model.save_pretrained_gguf("gguf/gpt-oss-20b-stem", tokenizer, quantization_method="q4_k_m")

quantization_method takes f16, q8_0, q4_k_m and the other llama.cpp types listed in Unsloth's GGUF docs. The GGUF files for this model came out at:

File	Size
f16	41.9 GB
Q8_0	22.3 GB
Q4_K_M	15.8 GB

If the GGUF step runs out of memory, Unsloth's docs suggest lowering maximum_memory_usage from its 0.75 default to around 0.5.

Does `save_pretrained_gguf` include the LoRA adapter?

The three save calls above produce different artifacts. model.save_pretrained(output_dir) writes the adapter and its configuration; the adapter from this run is about 61 MB and needs the base model to run. model.save_pretrained_merged(...) writes a full model with the adapter merged. model.save_pretrained_gguf(...) exports a runnable GGUF, not another small adapter file. The Q4_K_M GGUF here is 15.8 GB.

Check the export with prompts held out from training. A reported Unsloth PEFT wrapper export issue describes a path where a GGUF file was produced from base weights without the trained adapter. That report does not establish that this happened to my published model. It is a reason to compare the adapter and GGUF runs before handing either to users.

The Harmony chat template is what breaks

gpt-oss doesn't use ChatML. It was trained on OpenAI's Harmony format, where every message is wrapped in special tokens and the assistant writes on separate channels:

analysis for its chain of thought, which end users shouldn't see
final for the answer
commentary for tool calls

A final answer ends with <|return|>, which OpenAI's docs call "a valid stop token indicating that you should stop inference." Messages kept in the conversation history end with <|end|> instead, while supervised training targets should end with <|return|>. OpenAI's model card is blunt about it: the models "should only be used with the harmony format as it will not work correctly otherwise."

So the template you ship has to match the one used in training. Unsloth's docs name a mismatch as the most common reason a model gives gibberish or endless output on other platforms. And <|return|> has to be a stop token, or generation runs past the answer.

This exact question, how to template a fine-tuned gpt-oss for Ollama, is still open on OpenAI's forum.

A working Ollama Modelfile for fine-tuned gpt-oss

This is the Modelfile that ships with the GGUF repo:

FROM ./gpt-oss-20b-finetuned-q8_0.gguf

TEMPLATE """<|start|>system<|message|>You are a helpful assistant trained by OpenAI.

Reasoning: medium

# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
{{- if .System }}<|start|>developer<|message|># Instructions

{{ .System }}<|end|>
{{- end }}
{{- range .Messages }}
{{- if eq .Role "user" }}<|start|>user<|message|>{{ .Content }}<|end|>
{{- else if eq .Role "assistant" }}<|start|>assistant<|channel|>final<|message|>{{ .Content }}<|end|>
{{- end }}
{{- end }}<|start|>assistant"""

PARAMETER stop "<|return|>"
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER num_predict 2048

The template loops over .Messages so that a conversation keeps Harmony's structure: each earlier answer goes back in as a final-channel message closed with <|end|>, and a SYSTEM line becomes a Harmony developer message. Ollama's own gpt-oss template does the same and also handles tools and the think level; ollama show gpt-oss:20b --template prints it if you need those.

Why a TEMPLATE with only .Prompt breaks the second message

The first version of this Modelfile used {{ .Prompt }} alone. A reader, Mihai_LeanZero, pointed out on the Hashnode copy of this post that Ollama treats such a template as a legacy one. Ollama's template.go appends {{ .Response }} to any template that mentions neither .Messages nor .Response, then renders the whole template once for every earlier user and assistant pair. I checked it on Ollama 0.40.7 with the API's _debug_render_only option, which returns the prompt without running the model. For a second question, the old template produced:

<|start|>system<|message|>…<|end|><|start|>user<|message|>What is DNA?<|end|><|start|>assistantDNA is the molecule that carries genetic information.<|start|>system<|message|>…<|end|><|start|>user<|message|>And RNA?<|end|><|start|>assistant

The earlier answer has no channel header and no <|end|>, the system block repeats, and a SYSTEM message disappears. The template above renders the same conversation as:

<|start|>system<|message|>…<|end|><|start|>user<|message|>What is DNA?<|end|><|start|>assistant<|channel|>final<|message|>DNA is the molecule that carries genetic information.<|end|><|start|>user<|message|>And RNA?<|end|><|start|>assistant

A single question renders byte for byte the same with both templates, so ollama run with one prompt looked fine either way. Chat clients that send the whole history are where the old one went wrong.

Setting reasoning effort

Reasoning: medium in the system message sets how much the model thinks in its analysis channel before it answers. Harmony accepts low, medium and high, and medium is the default. To change it, edit that line in the TEMPLATE and run ollama create again. Ollama shows the analysis channel as "Thinking...", so low is the setting for short, fast answers.

ollama run hf.co or a Modelfile?

With the Modelfile, the template is the one you wrote:

ollama create gpt-oss-20b-stem -f Modelfile
ollama run gpt-oss-20b-stem

Ollama can also pull straight from Hugging Face:

ollama run hf.co/khadim-hussain/gpt-oss-20b-stem-reasoning-GGUF:Q4_K_M

That route doesn't read the Modelfile in the repo. Per Hugging Face's Ollama docs, it uses the chat template stored in the GGUF's tokenizer.chat_template metadata, or a file named template in the repo. The quantization tag is case-insensitive, and without a tag Ollama picks Q4_K_M. If you publish a Harmony model, put a template file in the repo or point people to the Modelfile.

Which format people actually download

All-time Hugging Face downloads as of October 2026:

Format	gpt-oss-20b	Qwen3-14B
GGUF	513	274
Merged 16-bit	70	42
LoRA adapter	46	51

Most people want a file they can run on their own machine. If you only publish one format, make it a GGUF with a working template. The adapter is worth adding for anyone who wants to keep training.

Troubleshooting

The failures documented in kllm's troubleshooting guide:

Symptom	Fix
Training process dies with no error	Out of memory. Check `dmesg \
{% raw %}`UnboundLocalError` mentioning dropout	Set `lora_dropout: 0.0`
`ImportError: cannot import name ... from 'transformers'`	`uv pip install --force-reinstall "transformers==4.57.3"`
`Python.h: No such file or directory`	`sudo apt-get install python3.12-dev`

The full project, with the Qwen3-14B run and the download numbers, is in the STEM reasoning LLMs case study.

If you need a model trained and tested for your own task, see my LLM fine-tuning service.

Frequently asked questions

How much VRAM do you need to fine-tune gpt-oss-20b?

With QLoRA, Unsloth's gpt-oss guide puts gpt-oss-20b at about 14 GB of VRAM and recommends at least 16 GB for stable runs. LoRA on BF16 weights needs about 44 GB. kllm, the toolkit I trained with, is verified on an RTX 5090 with 32 GB.

Can I run a fine-tuned gpt-oss-20b in Ollama?

Yes. Export it to GGUF, then either run ollama create with a Modelfile that carries the Harmony template, or pull it with ollama run hf.co//:Q4_K_M. The second route uses the chat template embedded in the GGUF file, not the Modelfile in the repo.

Why does my fine-tuned gpt-oss model output gibberish or never stop?

Usually the chat template. The template at inference has to match the one used in training, and Harmony ends a final answer with <|return|>. If that token isn't a stop token, generation runs past the answer.

Which GGUF quantization should I use for gpt-oss-20b?

Q4_K_M (15.8 GB for this model) is the smallest file and the one Ollama picks by default. Use Q8_0 (22.3 GB) if you have the memory and want output closer to the 16-bit model.

How do I set reasoning effort for gpt-oss in Ollama?

Harmony reads it from the system message as Reasoning: low, medium or high, and medium is the default. In a Modelfile, change that line inside the TEMPLATE and run ollama create again.