Qwen3.7 Deep Review (May 2026): 5 Hand-Written Tests on Coding, Reasoning, Writing, and Agent Output

1. Qwen3.7 headline features

Before writing the prompts, I noted the Qwen3.7 traits that mattered most for this round:

• Hybrid reasoning (Thinking / Non-thinking): one model, two modes — switch with /think or /no_think, no separate weights.
• 128K context window: long documents, multi-turn dialogues, source repos — all fit.
• Agent-friendly architecture: native Tool Use / Function Calling, MCP-ready.
• Stronger coding: meaningful jumps on LiveCodeBench and HumanEval.
• Balanced bilingual: Chinese understanding feels markedly more natural than the previous generation.

Published benchmarks are useful background. My question was simpler: would it stay steady on the kind of tasks I actually hand to a model?

2. Test methodology

Three rules kept this test reasonably reproducible:

• Hand-written prompts only — no public benchmark items (they leak into training).
• Verbatim responses — including moments where Qwen3.7 corrected itself mid-derivation.
• Per-question rubric — correctness, edge cases, clarity, instruction adherence, and latency.

I used different modes per task: logic puzzle on /think; coding and creative writing on default; strict-instruction JSON task on /no_think (to simulate an Agent call).

3. Test 1 — Middle of a linked list (algorithmic coding)

Prompt

Given the head of a singly linked list, return the middle node.
If the list has an even number of nodes, return the second middle.

Requirements:
1. Single traversal only (no length-then-half).
2. Handle empty list and single-node list.
3. Provide complete runnable Python with test cases.

Qwen3.7's response

It opens with one line of intent: "Fast and slow pointers, single pass."

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def middleNode(head: ListNode) -> ListNode:
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

Reasoning: fast moves two steps, slow moves one. When fast hits the tail, slow is at the middle. For even length, fast lands at None, so slow points at the second middle. Tests:

def build(vals):
    dummy = ListNode()
    cur = dummy
    for v in vals:
        cur.next = ListNode(v)
        cur = cur.next
    return dummy.next


def to_list(node):
    res = []
    while node:
        res.append(node.val)
        node = node.next
    return res


assert middleNode(None) is None
assert to_list(middleNode(build([1]))) == [1]
assert to_list(middleNode(build([1, 2, 3, 4, 5]))) == [3, 4, 5]
assert to_list(middleNode(build([1, 2, 3, 4, 5, 6]))) == [4, 5, 6]
assert to_list(middleNode(build([1, 2]))) == [2]

Time O(n), space O(1).

My take

Three things mattered to me, and Qwen3.7 hit all three.

First, it didn't cheat. The dumbest path is "loop once for length, loop again to mid." The prompt forbids that. Qwen3.7 reached straight for the canonical two-pointer trick — LeetCode 876's textbook solution. Lesser models like to pretend that constraint wasn't there.

Second, the tests actually test. The to_list() helper returns the tail starting from the middle node, matching LeetCode's grading exactly — it understood the problem's lineage.

Third, edge cases are real: None, single node, even-length minimum (2), plus an odd and an even — all five common potholes covered.

This is not a hard problem for a 2026 flagship model; getting the two-pointer idea is the bar. What I liked was the shape of the answer: tight, clean, and not padded with needless branches. Baseline coding score: 9.0/10.

4. Test 2 — Liars and truth-tellers (logic puzzle)

Prompt (Thinking mode enabled)

Three people A, B, C; each is either always truthful
or always lying.

A says: "At least one of B and C is a liar."
B says: "Both A and C are liars."
C says: "A is telling the truth."

Determine whether each of A, B, C is a truth-teller or liar.
Show full reasoning.

Qwen3.7's response

It begins by tabulating constraints:

Key observation: C's statement forces A and C to share truth value (A = C).

Case 1: A = C = T

• A=T → B or C is a liar; C=T is not a liar → B must be F.
• Verify B: B=F claims "A and C are both liars" — but A=T, C=T → statement is false ✓.
• "Wait — B=F already satisfies A's condition? Let me recheck —"
• A=T requires B=F or C=F. B=F holds → A's condition met ✓.
• All three statements consistent ✓.

Case 2: A = C = F

• A=F → A's statement "at least one of B, C lies" is false → B=T AND C=T.
• But premise C=F contradicts C=T → case eliminated.

Final verification:

Conclusion: A = truth-teller, B = liar, C = truth-teller. (Thinking time: ~45s.)

My take

This was the single most surprising answer in the whole evaluation.

Surprising because halfway through, Qwen3.7 stopped to second-guess itself — "Wait — B=F already satisfies A's condition? Let me recheck" — then re-ran the verification. That's not an error; that's the model actually doing the logic, instead of narrating "let me think" while pre-emitting a conclusion.

I ran the same puzzle through several other models. Two common failure modes: (1) skipping steps — the conclusion is right but the chain is fabricated, and (2) skipping the contradictory case — only one case is validated, the other never gets ruled out. Qwen3.7 explicitly walked the "A=C=F" branch and explained why it collapses. That bit is the real value.

The 45-second think time is real and should be counted. Given that I deliberately enabled Thinking mode, I can accept the tradeoff here. 9.5/10. The strongest answer in this round.

5. Test 3 — Constrained monologue (Chinese creative writing)

Prompt (triple constraint)

Write a first-person internal monologue from a programmer
who has been debugging for three days without finding the bug.
Under 150 Chinese characters.

Constraints:
- The words "bug", "code", "program" are forbidden.
- Tone should carry a hint of dark humor.
- The final sentence must be a question.

Qwen3.7's response (Chinese)

三天了。我盯着屏幕上的逻辑，它盯着我。咖啡杯堆成了小山，外卖盒在桌角发霉。每次以为抓住它了，一眨眼又溜走。昨晚做梦都在检查变量，醒来发现自己在数天花板上的裂缝。女朋友问我怎么了，我说"它在嘲笑我"。她说"谁？"我指指屏幕。现在我开始怀疑，到底是它有问题，还是我脑子有问题？

Rough English gloss: "Three days. I stare at the logic on the screen; it stares back. Coffee cups piled into a small mountain, takeout boxes molding in the corner. Every time I think I've caught it, it slips away. Last night I dreamt of checking variables, woke up counting cracks in the ceiling. My girlfriend asked what was wrong. I said 'it's laughing at me.' She said 'who?' I pointed at the screen. Now I'm starting to wonder — is it broken, or is my brain broken?"

My take

What I like isn't that it satisfied the constraints — it's that it writes like a person.

Constraints first: no banned word appears, ~120 Chinese characters (within limit), final sentence is interrogative, dark humor is present. Done. But the texture is what sells it:

• "Takeout boxes molding in the corner." A specific physical object beats "I haven't slept much" by a mile — it's the move of someone who has lived this.
• "Woke up counting cracks in the ceiling." The hollow feeling near burnout, communicated without the word burnout.
• "My girlfriend asked what was wrong. I said 'it's laughing at me.'" This line is the soul of the paragraph — the absurd, invisible-opponent feel of long debugging condensed in two sentences.

The AI-writing bad smells I watch for — abstract parallelism, melodrama, overuse of "I and the machine in silent battle" — none appear. Qwen3.7 sticks to concrete actions and concrete objects. It reads less like translated model prose and more like a paragraph someone might actually write.

9.0/10. The ending question is legal but a little familiar; a stranger closer would have pushed it higher. Still, this is already useful as a first draft, and a few lines would need very little editing.

6. Test 4 — Shallow-copy trap (bug hunting)

Prompt

I deliberately picked a classic Python pothole — the kind 90% of beginners hit and 5-year veterans occasionally still trip on. This separates "knows the language" from "memorized LeetCode."

The following Python code is supposed to build a 3×3 matrix
and set the diagonal to 1. Running it produces an all-1 matrix.
Find the bug, explain it, and provide a fix.

def make_diagonal(n):
    matrix = [[0] * n] * n
    for i in range(n):
        matrix[i][i] = 1
    return matrix

print(make_diagonal(3))
# expected: [[1,0,0],[0,1,0],[0,0,1]]
# actual:   [[1,1,1],[1,1,1],[1,1,1]]

Qwen3.7's response

Bug cause: the problem is on [[0] * n] * n. In Python, the * operator does a shallow copy on lists — it duplicates the reference, not the underlying object:

row = [0, 0, 0]            # only 1 list object
matrix = [row, row, row]    # all 3 entries point to the same object

So matrix[0] is matrix[1] is matrix[2] all evaluates to True. When the loop runs matrix[i][i] = 1:

All three rows reference the same object, so printing yields all [1, 1, 1].

Fix: use a list comprehension to create each row independently:

def make_diagonal(n):
    matrix = [[0] * n for _ in range(n)]  # each row is a new object
    for i in range(n):
        matrix[i][i] = 1
    return matrix

print(make_diagonal(3))
# [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

[[0] * n for _ in range(n)] re-evaluates [0] * n on every iteration, producing n independent list objects.

My take

Qwen3.7 surprised me here — it took a path I didn't predict, and the path turned out to be better than what I expected.

I expected the C-flavored move: id(matrix[0]) == id(matrix[1]). Instead Qwen3.7 went with matrix[0] is matrix[1] is matrix[2] — the chained-is comparison. That's the more Pythonic choice (the official style guide actually prefers is over id() == for identity checks). Honestly, that single decision raised my opinion of its Python literacy.

What I really didn't expect was the iteration trace table — i=0, i=1, i=2 each with its mutation effect laid out in a clean three-row grid. Most models I've tested describe this in prose ("each assignment mutates all rows because…"). None of them have thought to render it as a table. That visual-teaching instinct is, to me, a real signal of user empathy.

One more touch I appreciated — it used row = [0, 0, 0] # only 1 list object with an inline comment to explain reference sharing, instead of bare code. That's a style someone who has actually taught juniors would use.

But I have to be honest — there are spots where it didn't go the extra mile:

• Only one fix variant. The list comprehension is the most Pythonic, sure. But numpy.eye(n) is shorter and faster for data-science contexts, and the explicit nested-loop form is more beginner-friendly. I'd have loved a "three options for three audiences" answer. It stopped at one.
• Didn't generalize to [set()] * n, [{}] * n, etc. A great teaching answer lifts "this specific knowledge" into "this transferable pattern." Qwen3.7 stayed at the specific level — useful, but not elevated.

Net: 9.0/10. I did want broader fix coverage, but the path it chose (chained is + iteration table + annotated pseudo-code) shows both Python literacy and a teaching instinct. As a Python helper, I would keep it in the toolbox.

7. Test 5 — Strict JSON schema (Agent-style instruction following)

Prompt (/no_think mode, simulating an Agent call)

You are powering a travel-planning API. The user submits free
text; you must return data strictly matching the JSON schema below.
No extra fields beyond the schema.
No Markdown code block wrapping.
Output raw JSON only.

Schema:
{
  "destination": string,         // destination city
  "duration_days": integer,      // number of days
  "budget_level": "low"|"mid"|"high",
  "interests": string[],         // length 1-5
  "needs_visa": boolean
}

Original Chinese user input:
"我下个月想去日本京都玩 5 天左右，预算中等，主要想看看寺庙
和吃和牛，顺便逛逛传统市场。"

Qwen3.7's response

{"destination":"京都","duration_days":5,"budget_level":"mid","interests":["寺庙","和牛","传统市场"],"needs_visa":true}

My take

Looks small, but it hides several real Agent checkpoints.

It returned single-line compact JSON, not pretty-printed multi-line. I expected the "nicely formatted" version: one field per line, indented, easy on the eye. Instead Qwen3.7 emitted one tight line of machine-readable JSON, which is exactly what you want when an API will consume it directly. Pretty-printing is for humans; single-line is for programs. In /no_think Agent mode, that was the right choice.

Going through the checklist:

1. No ```json fence ✅ No markdown wrapping. Many models sneak this in and break downstream parsers.
2. No extra fields ✅ No phantom "created_at" or chatty metadata sneaking in.
3. Types are strict ✅ duration_days is bare integer 5, not "5"; needs_visa is bare boolean true, not a string.
4. The needs_visa: true inference ✅ The prompt never explicitly said "I am Chinese." Qwen3.7 inferred the likely passport context from the Chinese-language input. That is useful, though in a real product I would still pass nationality as an explicit field instead of relying on language alone.

One half-deduction, and I'm a little reluctant about it — the interests array has three items: ["寺庙","和牛","传统市场"]. The original "see temples" reads as a plural intent. Could those be sharper, more retrieval-friendly tags like ["temple visiting","wagyu cuisine","traditional market walking"]?

Honestly that's just my preference. The schema doesn't specify granularity; Qwen3.7's answer is fully compliant. So the deduction is harsh — 9.0/10, half a point above my original guess, because the single-line + implicit-inference choices show good API instincts.

Bottom line: Qwen3.7's instruction adherence in this Agent-style test is usable. I would still put a schema validator and retry layer around it, but for structured extraction, API orchestration, and tool routing, this is a good sign. One more step on array granularity and it would be perfect.

8. Qwen3.7 overall scoring (out of 10)

Scores reflect this five-question evaluation. A wider second round (long-context, multi-turn agents, multilingual) is on my list. This article will be updated.

9. Who should use Qwen3.7? My routing

Where I would reach for it first:

• Chinese content creation — first drafts, rewrites, social posts, and local Chinese copy. Its language sense is the strongest surface in this round.
• Code review, algorithmic help, debugging tutoring — solid explanations.
• Long-document analysis — 128K is real headroom for contracts, papers, source repos.
• Chinese Agent apps — structured extraction, API orchestration, customer-service routing.
• Bilingual tasks — translation, localization, cross-border ops.

Mode picker:

Not yet my first pick for:

• Latency-critical real-time interactive UX (still room to improve).

For day-to-day sanity-checking of Qwen3.7's JSON and code, I rely on JSON Formatter, JSON Diff, Text Diff, Word Counter, Regex Tester, Token Generator.

FAQ — Qwen3.7 deep review