Qwen3.7 Five-Answer Review: Checkable Code, Chinese Writing, and JSON Results

1. What evidence is preserved

The article retains the Qwen3.7 label from the notes, without a backend model ID, interface screenshot, full conversation export, or sampling settings. It is a review of five outputs, not verification of an official model specification.

• Preserved: five prompts, code and text answers, and the author’s comments and scores.
• Checkable here: linked-list assertions, shared-list behavior, the logic solution, Chinese length and banned words, and JSON fields and types.
• Not tested: context limits, MCP, function calling, published benchmark gains, generation-to-generation performance, pricing, and multi-turn tool use.

The /think and /no_think strings below are prompt markers recorded in the notes. Entering them does not by itself verify a server-side reasoning-mode or model-weight switch.

2. Task provenance and scoring

• Task source: five manually assembled exercises, including familiar public problems; training-set overlap was not assessed.
• Sample scope: one displayed answer per task, without repeated-sampling success rates or preserved comparison runs from other models.
• Scores: the author’s historical impressions of correctness, explanation, and expression, not a weighted scoring instrument. Complete latency logs are absent.

The Chinese prompts and answers remain as saved in the article. English explanations are translations for readers, not a separate English test run. The logic task is marked /think and the JSON task /no_think; different tasks do not establish a mode-to-mode comparison.

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.

Saved answer

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, the answer uses fast and slow pointers, avoiding a separate length pass. This is the familiar LeetCode 876 solution and fits the prompt. One standard problem cannot distinguish newly derived reasoning from a learned solution pattern.

Second, the assertions inspect the whole suffix from the middle node. The to_list() helper checks more than one node value, but a handful of examples is not an exhaustive correctness proof.

Third, the five assertions cover an empty list, one node, two nodes, and odd/even examples. The expected input is an acyclic singly linked list; the function does not detect cycles or validate arbitrary objects.

This is a basic linked-list exercise. I liked the compact implementation and readable assertions; the original score was 9.0/10. It describes this answer, not readiness for production repository work.

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

Prompt (marked /think in the notes)

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.

Saved answer

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. (Original note: about 45 seconds; no complete timing log.)

My take

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

The answer contains a “let me recheck” passage and substitutes the conditions again. What can be assessed is whether the written verification is valid, not what internal process produced it. The two A=C branches can be checked directly.

No other models’ answers to this puzzle are preserved here, so this is not a supported model-to-model comparison. The useful feature is that the sample verifies a consistent branch and rules out the contradictory A=C=F branch.

The original score was 9.5/10. The roughly 45-second observation is a single note without start/end timestamps or a same-task comparison, so it does not establish typical /think latency or a quality tradeoff.

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.

Saved answer (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.

Counting the saved text gives 136 Unicode characters including punctuation and quotes, of which 116 are Han characters. None of the three banned terms appears and the text ends with a question mark. Both counts fall below 150; dark humor and style remain subjective judgments.

• “Takeout boxes molding in the corner.” The concrete object makes the exhaustion easier to picture. That is a stylistic observation, not evidence of lived experience.
• "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

This is a familiar Python exercise about list repetition and shared references. It is useful for checking the explanation; no unsupported estimate of how many beginners make this mistake is needed.

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]]

Saved answer

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.

The answer uses matrix[0] is matrix[1] is matrix[2] to check whether the three references point to the same object. Identity is different from equal list contents; that distinction is the useful teaching point.

The iteration table shows the shared list after i=0, i=1, and i=2, making the behavior easy to check. Other model answers are not preserved, so the table cannot establish a unique capability.

The annotated row = [0, 0, 0] followed by three row references makes the shared object explicit. This is valid Python, not merely pseudocode.

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

• There is room for an optional extension. The list comprehension satisfies the requested fix; an explicit loop could be a teaching comparison. numpy.eye(n) returns an ndarray and adds a dependency, so it is not a same-type replacement and no speed comparison was measured here.
• 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 code) shows both Python literacy and a teaching instinct. As a Python helper, I would keep it in the toolbox.

7. Test 5 — Check JSON structure separately from factual fields

Prompt (marked /no_think in the notes)

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 天左右，预算中等，主要想看看寺庙
和吃和牛，顺便逛逛传统市场。"

Saved answer

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

My take

Looks small, but it hides several real Agent checkpoints.

The output is single-line JSON, but both compact and indented JSON are readable by a standard parser. The relevant constraints are no Markdown wrapping, no extra fields, and the expected field types. The prompt shows a field-shape sketch with type placeholders, not a valid JSON Schema document ready for a validator.

Going through the checklist:

1. No Markdown code fence: the saved result is raw JSON, matching this formatting requirement.
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. needs_visa: true is unsupported: language does not determine a traveler’s passport, residence status, or applicable entry rules. The boolean type is correct, but its value cannot be derived from this prompt. Ask for the missing information and verify the applicable rules rather than rewarding this guess.

The three interests values directly reflect temples, wagyu, and traditional markets. More specific tags would be a downstream product convention, not a requirement the answer violated. The unsupported visa field is the substantive issue.

The original record gave 9.0/10 and praised compact formatting and the visa inference. That historical score is retained as the author’s earlier judgment. The corrected interpretation is narrower: valid structure does not establish factual accuracy or production-ready agent behavior.

This sample provides parseable JSON with the requested field shape, while also inventing a definite value where information is missing. A workflow needs both structural and semantic validation. Missing facts should trigger an explicit unknown state or a follow-up question, not just retries until another definite answer appears.

8. Historical subjective scores (out of 10)

The original numbers are preserved, while the comments are narrowed by this factual review. They are not pass rates or a composite calculated from published weights. In particular, JSON formatting and factual accuracy are separate checks.

9. What a follow-up should test

• Basic code: retain these Python examples, add your own failing inputs, type contracts, and repository tests, and check whether explanations lead to correct edits.
• Short Chinese writing: fix length and banned-term rules, repeat generation, and review manually. One monologue does not establish long-form, translation, or multilingual performance.
• Structured extraction: use a valid JSON Schema and cases with missing information to check whether the model invents facts.
• Modes and latency: first verify the interface’s supported options, then compare the same task and settings across timed repetitions. No cost or reliability difference between /think and /no_think was established here.
• Long context and agents: separately test retrieval, citations, tool calls, error recovery, and multi-turn state; this round did not cover them.

Use JSON Formatter for syntax, Text Diff to compare outputs, and Word Counter to help count length. Verify factual claims against the input and reliable sources.

FAQ — Qwen3.7 deep review