
Hey fellow prompt tinkerers — I've been running Qwen 3.5 through real tasks since it dropped in February, and the gap between "looks impressive on benchmarks" and "actually holds up in a live workflow" is exactly what I want to talk about.
I'm Hanks. I test AI tools inside real tasks, not demos. And here's my core question going into this one:
Can Qwen 3.5 produce reliable, structured outputs that survive contact with actual work — or does it fold the moment you push it off the demo track?
Short answer: prompting matters, but it isn't the only variable. The open-weight model has a 397B-parameter MoE architecture that activates 17B parameters per forward pass. That gives you a capable starting point; it doesn't make an unsupported factual claim true. The workflow around the model still has to supply sources and check results. Let's get into it.

The three routes worth separating are Qwen Chat, the hosted qwen3.5-plus API in Alibaba Cloud Model Studio, and the open-weight Qwen3.5-397B-A17B model you can run yourself or through a provider.
Qwen's launch post describes Auto, Thinking, and Fast modes in Qwen Chat. Model Studio documents a 1-million-token context window for qwen3.5-plus. The open-weight model card lists a 262,144-token default context for that model. Those are different products and configurations: the API's context specification is not a promise that a Qwen Chat account will accept the same amount of material, and a third-party host may set its own limits. Check the model, mode, provider, and available quota before repeating a prompt test.
I started with the API version. First task: multi-step research summarization. The output was confident, fluent, and wrong on two factual details. I can't put all of that on the prompt: the model may also have lacked a reliable source, retrieval, or an effective verification step. Here's what I changed in the workflow.

The single biggest mistake I see people make with Qwen 3.5 — and honestly any instruction-tuned LLM — is treating it like a search engine. If the task requires current or exact facts, a well-worded prompt alone can't verify them. Give the model the source material or enable an appropriate retrieval tool, then check the claims it makes.
Here's what worked across my 30+ writing sessions.
Don't ask for a finished piece. Ask for a skeleton first, then fill it in section by section. This is the approach that made the biggest reliability difference for me.
Instead of this:
Write a finished article about [topic] with facts, examples, and citations.
Do this:
Using only the source material below, propose an outline for [audience] answering [question]. For each section, list the claims it needs, the source passage supporting each claim, and anything the material cannot establish. Do not draft the article yet. Source material: [paste text or attach files]
Then, once the skeleton looks right, call each section individually. Ask Qwen to mark a sentence “needs verification” if the supplied material doesn't support it.
In my original log, the first-pass usable-output estimate moved from around 40% to north of 80% after I began working in bounded chunks. I'm keeping those figures as my recorded experience, not presenting them as a measured improvement anyone should expect: the article does not include the session-by-session counts or a fixed definition of “usable.”
Prompts that request counterexamples and self-checks can expose weak spots. A confidence score, by itself, isn't a fact check. Keep context concise but complete: include the task, essential constraints, and references.
I've been using a constraints block at the top of writing prompts:
Audience: [who will read this] Goal: [what they need to decide or do] Allowed sources: [supplied files or links] Output: [length and format] For each factual claim, identify its source. If a claim has no support in the supplied material, say so rather than filling the gap.
That last constraint gives Qwen permission to be uncertain. It helped me notice confident-sounding wrong answers earlier, but the final check still has to happen against the source.
I ran Qwen 3.5's coding capabilities through three real projects: a Python data pipeline, a simple web scraper, and a JSON transformer. The model is strong. But "strong" coding ability without a structured workflow still produces spaghetti.
The workflow that held up: Plan → Patch → Verify.
The trap most people fall into: asking for full rewrites. You get a working-looking piece of code, you paste it in, something breaks, and now you're debugging a 200-line black box.
What works better is diff-first prompting:
Read the relevant function and its tests. Explain the smallest change needed, then return a unified diff touching only the files required. State any assumption you made. Do not claim the patch passes until the tests have run.
For the Python pipeline, the output I wanted was a reviewable change to the affected function, not a replacement for the whole file. A tidy diff is easier to inspect; it isn't automatically safe to apply.
Test-gating adds one more constraint:
Before the patch, name the existing test to run and one test that should fail without this fix. After the patch, report the command, its actual output, and any remaining failure. If you cannot execute tests, give the commands and say “not run.”
Now the prompt asks for a verification path. Running that path is what tells you whether the patch works; asking the model to describe a test doesn't establish that it passed.

This is where the 1M-token Model Studio qwen3.5-plus specification can matter. You can supply long documents through a supported API workflow. But available input length, cost, and tool access depend on the service and configuration you're using; a large window also doesn't guarantee that a summary catches every qualification.
My three-stage research prompt chain:
Stage 1 — Outline the unknowns:
From these documents, list the questions the brief must answer. Separate questions the documents address from questions that still need evidence.
Stage 2 — Source-constrained synthesis:
Answer the supported questions only. For each material claim, give the document name and passage or page. Label an interpretation as an inference. Do not invent a citation for a missing answer.
Stage 3 — Gap identification:
Compare the draft with the source passages. List unsupported claims, omitted exceptions, and any answer that conflicts with the documents. Suggest what to verify next; do not silently repair a gap with a guess.
This chain makes the model show what it's using and what it's inferring. The gap-identification step has saved me from publishing summaries that looked complete but were actually half-speculation. For the two factual errors in my first API task, I don't have the original source passages and model responses in this article, so I won't manufacture a before-and-after transcript. The prompts above are reusable templates, not a reconstruction of that run.

Here's the thing that nobody talks about: people often blame the model when a prompt workflow breaks, but change the model, mode, source material, and instructions at the same time. Then they can't isolate what helped.
I keep a dead-simple prompt log. A plain text file per project:
Task and input material | model, provider, and mode | prompt version | output | factual or format error | change made | result after the change
One variable per iteration. That's it. Build a prompt suite from your real tasks and check outputs against a simple rubric: correctness, completeness, format, unsupported claims, tone. It sounds boring. It's the only way I can tell whether a change helped on more than one lucky response.
Over two weeks of logging with Qwen 3.5, three patterns emerged:
Those are my original observations, with the numbers preserved. The log's sample counts, error definitions, and before-and-after outputs aren't included here, so the percentages should not be read as a benchmark or a guarantee. A self-check can miss an error; it doesn't replace checking the source or running the code.
Prompt reliability isn't magic — it's a workflow problem that rewards iteration. If your Qwen 3.5 outputs feel inconsistent, check the source material, model and mode, prompt, and verification step before deciding which part failed.
At Macaron, we built our agent around this kind of structured task handoff: taking the output from a conversation and turning it into something you can work with across steps. If Qwen 3.5—or any model—keeps drifting between stages in your workflow, try the same task in Macaron and judge the output yourself.
Previous posts: