The premise: local models are private, but they can feel like knockoffs
The pitch for local LLMs is ownership and privacy. The author's complaint is that they often feel like a knockoff, especially on a mid-tier PC. Cloud Claude models seem to pick up quickly on who you are and how you want to be addressed. Local models don't do that out of the box.
The author's fix is to steer the model with short system prompts built around the parts of Claude they like best. The prompts are modeled on two models:
- Opus 5.5: the author's pick for research, design and coding-adjacent work.
- Sonnet 5.5: the author's pick for general chat. They describe it as warmer and more informal.
The author says Anthropic launched Opus 5.5 in September and that Sonnet 5.5 followed less than a week later. They also say Anthropic claims Sonnet 5.5's output runs more than 30% faster than Sonnet 5. Anthropic's own Opus 5.5 announcement backs up the communication angle. It says Opus 5.5 puts the most important information up front, avoids jargon and follows the writing rules you give it. That is close to what the author is trying to reproduce with a prompt.
The "knowledgeable friend" framing comes from Anthropic's published constitution for Claude. Anthropic describes Claude as being like a brilliant friend who speaks frankly and treats users as capable adults. A system prompt can borrow that tone. It cannot borrow the training behind it. Anthropic says the constitution is a core part of its model training process, and a local model never went through that.
The prompts, the setup and the models
The author runs everything in LM Studio. Their reasons are the system prompt box in the right-hand panel and the ability to save prompt-and-parameter combinations as presets. LM Studio's documentation says presets bundle a system prompt and other parameters into one configuration that can be reused across chats. You can fix a temperature, Top P or Max Tokens for a use case and switch between them. On Windows, presets are JSON files in %USERPROFILE%.lmstudio\config-presets. That makes them easy to back up or copy to another PC. The exact layout of the app may differ between versions.
The "Opus-style" prompt
The author shares this prompt as an example. It is organized into short labeled sections:
- Role: a sharp research, design and coding partner. Treat the user as a capable adult.
- Thinking: lead with the answer, then the reasoning. Be honest over agreeable, and say so if the plan has a flaw. Say "I'm not sure" rather than guess, and never invent facts or sources. Think step by step on hard problems.
- Style: plain, direct prose. Bullets or headers only for real lists. Match depth to the question. No filler openers and no closing offers.
- Code: working code first, a brief explanation after, and real risks flagged.
- A closing line: if something is unclear, state an assumption and proceed.
The "Sonnet-style" prompt is described but not reproduced in full. It tells the model to answer first and add only context that helps. It asks for a real opinion when one is requested. It keeps warmth but drops praise.
Both prompts are about 150 words. The author says that is under 1% of their usual 30k context window. They also say small models tend to do badly with long system prompts.
Which model got which prompt
| Model | Prompt | Author's role for it |
|---|---|---|
| Qwen 3.5 9B | Opus-style | Coding work |
| Qwythos 9B | Opus-style | Reasoning-heavy work |
| Gemma 4 E4B | Sonnet-style | General chat |
The author says Qwythos is a third-party reasoning retrain of Alibaba's 9-billion-parameter Qwen 3.5. They report roughly 35 tokens per second from Gemma and about 20 from the other two, all on an 8GB GPU. Those are one person's numbers. The article doesn't give the GPU model, quantization or runtime settings. Don't treat them as what you'll get on your machine.
What changed, according to the author
These are the author's reported results, not benchmarks:
- Qwythos: without a prompt, it opened by validating the idea and buried the verdict in a bolded numbered list. With the Opus-style prompt, the verdict came in the first sentence and replies were roughly half as long. On a design with a real flaw, the unprompted model called it "a bold move" that works if handled right. The prompted one said no and suggested a better layout.
- Qwen: without the prompt, it returned a function with the explanation buried in code comments. With the prompt, the code came first, followed by a short plain explanation. That explanation flagged what happens if the input list has nothing usable in it.
- Gemma: without the prompt, it gave breakdowns of every possible cause and treated basic questions like research assignments. With the Sonnet-style prompt it stayed closer to the point. It also wrote its reasoning out at the top and mentioned the knowledgeable-friend tone. That shows the prompt reached the model.
- Token use: the author estimates the Opus-style prompt cut token use on the same queries to about half. They say the Sonnet-style prompt on Gemma dropped usage from around 2,000 tokens per query to around 300.
The token figures come with no logs, sample size or counting method. Shorter output also isn't automatically better or more accurate. A system prompt takes up input tokens on every request. That is small here, but it is not free.
The failure case: "don't guess" versus "assume and proceed"
The most useful part of the experiment is where it went wrong. The Opus-style prompt tells the model to say "I'm not sure" instead of guessing. It also ends with an instruction to state an assumption and proceed. The author found that Qwythos still says when it doesn't know. But the "assume and proceed" line sometimes pushed it to guess anyway.
The two instructions pull in opposite directions, and the model has to pick one. A few ways to handle that, based on general prompt-engineering experience rather than anything tested in the article:
- Change the closing line to something like "separate known facts from assumptions, and ask a clarifying question if the missing detail would change the answer."
- Make that change on its own. Don't rewrite the whole prompt at once.
- Rerun the same set of test questions on the same model and settings.
- Check any factual answer against a trusted source.
How to try this on a Windows PC
This is a practical approach assembled from the author's workflow and LM Studio's documentation. The author's own testing was less formal.
- Pick one behavior to fix. For example, "verdict first" or "no filler openers."
- Write a short prompt in labeled chunks. Keep it near the author's 150-word mark. Small models can get confused by long instructions.
- Paste it into the System Prompt box. LM Studio shows a live token count for the system prompt, according to the 0.3.3 release notes.
- Save it as a named preset. Keep one per use, for example "code" and "chat."
- Compare before and after. Use the same model, same settings and a few representative questions.
- Check for conflicts. Look for instructions that contradict each other, as in the author's guess-versus-assume case.
LM Studio's docs also show other ways to use a system prompt. The lms chat command takes a system prompt through its -s flag, and the local chat API has an optional system_prompt field. The author didn't test either route. One caution comes from the Multigrid guide: if a preset carries a system prompt and your API request also sends one, the model may see both.
If the prompt seems ignored
A system prompt is not the same thing as the model's prompt template. The template structures messages for a particular model. LM Studio says it normally configures it from the model file's metadata, and in most cases you don't need to change it. It lets you override the template if the metadata is incorrect or missing. If a model ignores a system prompt entirely, a wrong template is one possible cause. This is a general troubleshooting idea, and the author doesn't report hitting it.
Analysis: what this does and doesn't show
It shows that style and format are very steerable on small local models. Verdict-first replies, code before explanation and shorter answers all moved in the direction the author wanted. The author reports that Qwythos followed the prompt best.
It doesn't show that a local model gains Claude's capabilities, knowledge or safeguards. Anthropic's Opus 5.5 announcement describes agent work, long code migrations and safety evaluations. A 9B model on a consumer GPU isn't doing that work, and a prompt doesn't change it. A model that sounds confident and direct can also be wrong more convincingly. That is why the "I'm not sure" instruction matters, and why the author's observed guessing problem is worth taking seriously.
The privacy framing is also broader than the evidence. Running locally keeps inference on your machine. The article doesn't document the network behavior, extensions or data flow of the author's particular setup. If privacy matters to you, verify your own configuration.
The practical takeaway is simple: you don't need a bigger GPU to make a local model more pleasant to use. A short, well-tested system prompt saved as a preset costs almost nothing. If the author's numbers hold up on your hardware, it can also trim output length and token use. Expect to iterate, and expect different models to respond differently to the same wording.