After completing the first two batches of standard pages, I continued using the now-stable default approach to advance the A Tour of Go Simplified Chinese zh-CN translation.
This time, I processed the third batch of 10 standard pages, ranging from flowcontrol/7 to moretypes/3. The initial batch run was not a complete success: 8 pages entered ready, while flowcontrol/10 and moretypes/1 entered blocked.
If the goal were merely to increase the translated page count as quickly as possible, I could have temporarily skipped these two pages and left them for manual processing later. However, the current focus of the project is not just “how many pages are translated,” but rather calibrating the automated translation pipeline to achieve the following:
GLM-5.2 should generate results that pass complete automated validation on the very first translation attempt.
As a result, these two blocked pages became excellent real-world test samples.
After this round of continuous troubleshooting and fixes, the third batch ultimately achieved 10/10 ready, and the global status was updated to:
ready=45
pending=58
blocked=0

ready, with the current global status being ready=45, pending=58, blocked=0.The focus of this article is not what was translated in these 10 pages, but rather the more worthwhile issues that continuously surfaced behind them:
- Protected Tokens have not only content but also structural roles;
- The tokenization of static preformatted code blocks once hid the original block boundaries;
- Although Go identifiers in instructional comments were not lost, they could still become invalid due to changes in lexical boundaries;
- The automatic retry feedback after the first failure still had a string misclassification.
After resolving these issues, the project’s default approach did not evolve into a more complex structured translation system. Instead, it gradually became more aligned with the original goal: maintain full-page translation while protecting only the truly dangerous structures.
1. Third Batch First Run: 8 Pages Succeeded, 2 Pages Blocked
The third batch processed a fixed set of pages:
flowcontrol/7, flowcontrol/9, flowcontrol/10, flowcontrol/11–flowcontrol/14, moretypes/1–moretypes/3.
Most pages performed well. Except for flowcontrol/7, which failed to receive actual model responses in the first three attempts due to sandbox DNS/socket network failures, the first real GLM-5.2 output for most other pages passed validation.
The two blocked pages are what truly warrant analysis.
flowcontrol/10 repeatedly produced:
preformatted code block mismatch at index 1:
static preformatted block changed
While moretypes/1 repeatedly produced:
font span count mismatch:
expected 5, actual 3
At first glance, these appeared to be completely different problems.
But as I continued analyzing, I found that they both pointed to the same larger issue:
The model sees the Protected Tokens, but it does not know what structural role each Token plays in the original page.
2. flowcontrol/10: Token Content Preserved, but the Standalone Code Block Disappeared
The English source of flowcontrol/10 contains a static preformatted code block:
switch i {
case 0:
case f():
}
This code block itself should not be translated, so the existing mechanism replaces the entire block with a protectedPreformattedStatic token.
This is exactly where the problem occurred.
In the protected page actually sent to the model, the key part looked something like this:
⟪..._000001⟫does not call ...
In other words, the model did not see:
[A standalone code block]
[Subsequent standard paragraph]
But rather something like:
[A standard Token][Subsequent English]

flowcontrol/10 before the fix. 000001 represents the complete static code block, but the token is directly followed by does not call, making the input form look unlike a standalone block.Although the Prompt at the time repeatedly told the model “Tokens must not be deleted, modified, or copied,” 000001 only fell under the standard “single token must be preserved” rule.
The model did not know that:
000001is not a placeholder that can be freely inserted into a Chinese sentence; it is a complete block-level structure.
Consequently, it once generated:
当 `i==0` 时,⟪..._000001⟫ 不会调用 `f`。
The Token itself was not lost, and the payload restoration was completely correct. However, once the actual Go code was inserted back, the originally standalone preformatted block was downgraded to a piece of content in the middle of a standard sentence.
The validator correctly rejected this result.
3. The First Step Was Not Strengthening Validation, but Making the Prompt Explain the “Structural Role”
At this point, I chose not to add stricter constraints to the validator, nor did I revert to the previously abandoned “all Tokens must maintain their original global order” rule.
Because what was truly missing here was not new validation capability.
The validator had already identified the problem correctly.
What was actually missing was:
From the very first request, the model should know what each Protected Token represents.
Thus, the initial translation Prompt was adjusted to a “payload + structural role” approach.
For inline code pairs, they are allowed to move as a whole according to natural Chinese word order, but they must remain inline structures and cannot cross block-level boundaries such as preformatted blocks or directives.
For protectedPreformattedStatic, the model was explicitly told:
It represents a complete, standalone preformatted code block. It must remain an independent block and must not be embedded in standard paragraphs, headings, lists, or directive lines, nor merged with adjacent natural language.
For protectedDirective, it was explicitly stated that it represents a complete present directive line.
A crucial aspect of this modification is:
Maintaining the structural role does not mean maintaining the global order.
Chinese can still adjust normal word order, and inline code can still move with its semantic unit; the only restriction is that something originally acting as a block cannot be reinterpreted as inline content.
After modifying the Prompt, I initiated a completely clean first request for flowcontrol/10, without any historical retry feedback.
As a result, the first real GLM-5.2 response passed all validations.
This proved that the Prompt’s role description was indeed effective.
However, moretypes/1 soon made me realize: the Prompt alone is not enough.
4. A Deeper Issue: The Protected Input Itself Swallowed the Block Boundary
After re-examining the exact input boundaries for flowcontrol/10 and moretypes/1, I discovered a previously overlooked issue.
Taking flowcontrol/10 as an example, the English source originally was:
(For example,
switch i {
case 0:
case f():
}
does not call ...
The parsing logic of preformattedBlocks treats the blank lines at the end of the code block as part of the complete Present preformatted block.
This is semantically correct in Present.
However, after the translation protection phase replaced the entire block with a token, the trailing newlines used to separate the next prose paragraph were swallowed by the token payload as well.
Consequently:
\tcode\n\n
As a whole, it became:
⟪TOKEN⟫
The two newlines originally following the token also disappeared.
This is why the model ultimately saw:
⟪TOKEN⟫does not call
Instead of:
⟪TOKEN⟫
does not call

This issue made me reaffirm a very important principle:
The Prompt and the actual input must convey the same fact to the model.
If the Prompt says “this is a standalone block” on one hand, but the input looks like TOKENprose on the other, the model still has to guess and reconstruct the hidden structure itself.
Therefore, instead of further strengthening the Prompt here, I made a more fundamental but narrowly scoped fix:
I only adjusted the right boundary of the translation input protection for protectedPreformattedStatic, leaving the block separator originally present in the source outside the token.
That is to say:
source:
\tcode\n\nThe prose
After protection, it becomes:
⟪TOKEN⟫\n\nThe prose
After restoration, the original source can still be recovered byte-for-byte.
This modification did not change the Present semantics of preformattedBlocks, did not alter the validator, did not add Token metadata, and did not introduce slots or global order constraints.
It simply allows the model to actually “see” the boundary that this block always had.
5. moretypes/1: Block Fixed, but the Next Layer of Issues Surfaced
After fixing the static block input boundary, I ran another clean first-pass regression on moretypes/1.
This time, the previously obvious font span issue no longer appeared first.
The model was already able to correctly generate:
[static block token]
[Standard prose + inline pair]
This means the static token and the subsequent &, * inline code were no longer adjacent.
However, the validator immediately exposed the next layer of issues:
preformatted code block mismatch at index 3:
line comment mismatch at index 1:
referenced Go identifier count mismatch:
expected 1, actual 0
The problem occurred in the instructional comments.
The original text contained:
fmt.Println(*p) // read i through the pointer p
*p = 21 // set i through the pointer p
The final p here is a Go identifier that actually appeared in the same code block, so the project already protects it as protectedPreformattedIdentifier.
In other words, the protection mechanism already existed.
But the Prompt did not tell the model:
Once restored, this Token must still be a lexically independent Go identifier.
Thus, the model generated:
通过指针读取 i⟪...000015⟫
The Token was not lost, and the count was correct.
But after restoring 000015 → p, the result became:
通过指针读取 ip

moretypes/1, the Protected Token itself is fully preserved, but p is concatenated with the preceding natural language character i to form ip, which is no longer an independent Go identifier, so the validator correctly rejects it.This case is particularly representative.
It demonstrates that:
Passing Protected Token validation does not guarantee passing structural validation.
What the Token mechanism proves is merely:
- The Token did not disappear;
- It was not duplicated;
- It was not forged;
- The payload can be correctly restored.
However, after restoration, what lexical boundaries, containers, and structural relationships it exists within still requires a higher level of rule-based judgment.
6. What Continued to Be Added Was Not New Protectors, but the True Meaning of Existing Kinds
p had already been correctly tokenized, so there was no need to modify the protector here.
I only added the role description for protectedPreformattedIdentifier to the initial Prompt.
Now the model explicitly knows:
These Tokens represent Go source code identifiers referenced in instructional comments; they must be preserved as-is within their respective comments, and after restoration, they must still be recognizable as lexically independent Go identifiers. They cannot be concatenated with adjacent Chinese characters, English letters, numbers, or underscores.
At the same time, the entire instructional comment is still allowed to be translated and adjusted for natural Chinese word order.
After running another clean first-pass regression, the model output contained:
通过指针读取 i ⟪...000015⟫
通过指针设置 i ⟪...000017⟫
This time, there was a clear boundary before the token, and after restoration, p remained an independent identifier.
All automated validations passed, and moretypes/1 was restored to ready.

p. The final candidate further polished the Chinese word order to “通过指针 p 读取 i / 设置 i” (read i / set i via pointer p), and passed all validations.There is another detail here that I think is worth keeping.
After the model’s automated output passed validation, the instructional comment was:
fmt.Println(*p) // 通过指针读取 i p
*p = 21 // 通过指针设置 i p
Structurally, it was completely correct, but the Chinese was slightly stiff.
In the end, I only made a very minor manual polish to the candidate:
fmt.Println(*p) // 通过指针 p 读取 i
*p = 21 // 通过指针 p 设置 i
Then it went through the same unified validation suite again.
This also aligns with the principle the project has consistently upheld:
Manual intervention can improve the translation, but it cannot bypass automated validation.
7. Another Unexpected Issue: The Automatic Retry Feedback Was Actually Misclassified
While processing these two pages, another rather subtle issue was discovered.
The project had already implemented:
First translation
→ Validation failure
→ Generate retry feedback based on the failure reason
→ Inject into the next full-page translation
So when flowcontrol/10 and moretypes/1 initially failed consecutively, I suspected that the retry feedback was not being executed at all.
After checking the actual requests, I found that:
The feedback was indeed injected, but it was classified incorrectly.
For example, the actual error was clearly:
preformatted code block mismatch at index 1:
static preformatted block changed
But what the model received next time was:
上一次输出出现了未受保护的额外 present directive,
或改变了 directive 结构。
The reason was very specific.
The validator appends a unified diagnostic to structural errors:
check the named directive or protected content near the first difference
But the current TranslationValidation only stores:
Failures []string
There are no structured failure kinds/codes.
retryFeedbackForMode can only perform string matching on the full error text.
The old classification logic checked for directive first, resulting in:
Actual preformatted failure
+
"directive" in the unified suffix
=
False hit on directive feedback
The font span failure for moretypes/1 was also affected in exactly the same way.

directive, so the old string matching provided completely incorrect retry feedback.Currently, I have not introduced a new structured error system for this issue.
This time, I again opted for a minimal fix:
First, strip the fixed diagnostic suffix, then classify only the actual failure core. At the same time, add a dedicated preformatted branch, and ensure that font span / emphasis are identified before the generic directive.
After the fix:
preformatted
→ preformatted feedback
font span
→ font / emphasis feedback
Actual directive
→ directive feedback
Although this step is not an optimization of the “first-pass success rate,” it is very important.
Because no matter how much the first output is optimized, it is impossible to guarantee that all pages will always succeed on the first try in the future.
As long as limited retries still exist:
The reason told to the model after a failure must be the truth.
Otherwise, the so-called “smart retry” is actually just translating again based on the wrong direction.
8. Third Batch Ultimately 10/10 Ready
After this round of calibration, the two pages that initially entered blocked ultimately reverted to ready.
The third batch finally achieved 10/10 ready, with the global status:
ready=45
pending=58
blocked=0
status check also confirmed:
status OK: 103 pages for zh-CN
All candidates re-passed the unified candidate validate, and the full test:
go test -mod=readonly -count=1 ./...
Passed, and git diff --check had no issues either.
The final changes were committed:
be9413846f54e6679c79c0fc19957ac4e2a3f815
feat(i18n): 完成第三批并校准受保护翻译结构
Pushed to origin/main.
9. The Final Pages Not Only Pass Validation but Also Render Correctly
After completing all internal structural calibrations, I reopened the browser preview page for moretypes/1.
The final result is as follows.

moretypes/1. The lesson text, static code blocks, inline code, and instructional comments on the left all render normally, while the official Go example on the right remains unchanged.This page is highly suitable as a showcase for the final result of this round of calibration.
Because it happens to contain the multiple structures that caused issues this time:
- Standard Chinese body text;
- Inline code such as
*T,T,nil,&,*; - Multiple static preformatted code blocks;
- Translatable instructional comments;
- Go identifiers within instructional comments;
- The official code example referenced by the right-side
.play.
The final page looks very ordinary.
But it is precisely this “ordinariness” that the automated translation infrastructure should strive for: readers do not need to know how many Tokens, restores, Present parsing, and validators happened behind the scenes; they only need to see a normal, natural, and structurally complete Chinese course page.
10. The Most Important Conclusion of This Round
The most noteworthy aspect of this third batch is not that another 10 pages were completed.
More importantly, I gained a clearer understanding of “what Protected Tokens should protect.”
Earlier, it was easier to understand it as:
The Token’s primary task is to prevent the model from altering dangerous content.
This definition is no longer sufficient.
A more accurate statement would be:
Protected Tokens have both a payload and a structural role.
For inline pairs, the role is “still part of an inline structure”; for static preformatted tokens, the role is “still an independent block”; for directives, the role is “still an independent directive line”; for Go identifiers in instructional comments, the role is “after restoration, it must still be a lexically independent identifier.”
On the other hand, the structural role cannot be infinitely expanded either.
I still do not plan to restore:
All Tokens must maintain the original English global order
Because this would once again hinder normal Chinese word order adjustments.
The more appropriate boundary right now is:
Allow reorganization at the language level, but do not allow structural type degradation.
Besides this, there was another very important lesson from this round:
We cannot just require the model to “understand the structure”; the input itself must also present the structure correctly.
TOKENprose and TOKEN\n\nprose differ only by two newlines to a human, but for a Token that is supposed to represent a standalone code block, those two newlines are very real structural information.
Finally, the misclassification of retry feedback also reminded me once again:
What truly needs calibration in an automated translation pipeline is not just the model Prompt.
From:
Input
→ Prompt
→ Model output
→ Restore
→ Present parsing
→ Structural validation
→ Retry feedback
If any stage conveys incorrect information, it can ultimately manifest as a “model translation failure.”
This is also why I am increasingly inclined to prioritize resolving the general issues exposed during real batch runs before continuing to expand the page count.
11. Next Steps
After completing the third batch, the project now has 45 pages in ready, with the remaining 58 pages still as pending, and currently no blocked pages.
The next step could have been to immediately proceed to the fourth batch of standard pages.
However, after consecutively completing three real runs—and having completed continuous calibrations for the Prompt, protected input, instructional comment identifiers, and retry feedback in this batch—I plan to pause briefly and document this entire process.
When continuing to the fourth batch, what I care more about is no longer:
“Can all 10 pages ultimately be translated successfully?”
But rather:
After this round of adjustments, to what extent can the first-pass success rate of new standard pages actually be improved?
If subsequent large batches of pages can stably maintain a high first-pass success rate, then this project will have truly transitioned from “page-by-page development and calibration” into a continuously promotable automated translation phase.

