Recently, I have been advancing the A Tour of Go multilingual translation project.
In the previous phase, I completed the translation of all course body text for the Simplified Chinese zh-CN. According to the current release scope, there are a total of 103 official release pages, and all of them have passed the project’s existing automated structural and page validation.
However, “passing automated validation” does not mean “ready for release.”
Automated validation is better at confirming:
- whether the
presentstructure is correct; - whether directives like
.playare missing; - whether link targets have changed;
- whether inline code structures are intact;
- whether emphasis structures are preserved;
- whether comments in the teaching code have broken the program structure;
- whether the candidate’s structure matches the English source page.
But it struggles to judge another category of issues:
Although this sentence is technically correct, is the Chinese too convoluted?
Or:
Although this term is understandable, does it match the more common expression in the Chinese Go community?
So, after all 103 pages entered ready, I did not start publishing immediately. Instead, I added a complete round of pre-release body text quality audit.
The final result was somewhat unexpected:
Out of 103 pages reviewed page by page, only 16 actually needed revisions.
1. Why not have ChatGPT re-translate all 103 pages
The simplest and crudest approach would be to hand all 103 pages back to ChatGPT.
But I did not agree with this approach from the start.
Because the current translations are not unverified drafts.
They have already gone through:
GLM-5.2 full-page translation
→ candidate
→ present parsing
→ protected structure validation
→ page structure comparison
→ ready
If I rewrote all 103 pages before release, it would mean:
To improve a few sentences with actual issues, I would be reintroducing changes to a large amount of content that was already ready for release.
And every change reintroduces:
- link shifts;
- inline code structure changes;
- emphasis structure changes;
- missing directives;
- technical meaning drift;
- fluctuations in Chinese style.
So the principle for this audit was not:
Can ChatGPT write it better?
But rather:
Is the current page already good enough to be published?
These two standards are very different.
2. Establishing A / B / C / D four-tier audit criteria for 103 pages
To prevent the audit from gradually turning into “wanting to rewrite a sentence every time I see one,” I first set four levels for all pages.
A: No modification needed
The translation is:
- technically accurate;
- natural in Chinese;
- reasonable in terminology;
- free of obvious reading obstacles.
Even if ChatGPT could produce an alternative expression, that does not constitute a reason for modification.
B: Optional polish
There are minor optimizations that can be clearly identified, but the current version is perfectly fine to publish.
In principle, this category is not modified.
C: Suggested modification
There are relatively clear issues, such as:
- obvious translationese;
- inconsistent terminology;
- English residue;
- expressions so convoluted they require a re-read;
- although the technical meaning is mostly correct, it already affects the reading experience.
D: Must modify
This category covers issues that genuinely affect technical meaning, such as:
- mistranslations;
- omissions;
- shifts in technical concepts;
- Chinese expressions that easily lead readers to misunderstand.
Later, during the actual audit process, I further adjusted one criterion:
“Technically correct” does not automatically earn an A or B.
If a sentence obviously reads like machine translation, and the reader needs to break it down to understand it, then even if the technical meaning it conveys is mostly correct, it should be classified as C.
This standard later directly affected a very typical page.
3. Representative C: technically correct, but “returns a function that returns…” is too convoluted
moretypes/26 is a very representative example.
This is the exercise page about function closures and the Fibonacci sequence.
The original translation was:
Implement a
fibonaccifunction that returns a function (closure) that returns successive Fibonacci numbers (0, 1, 1, 2, 3, 5, …).
Strictly speaking, this is not a technical mistranslation.
After reading it a few times, you can understand what it is trying to say.
The problem is:
“returns a function that returns…”
This nested structure clearly bears the marks of English syntax being directly mapped into Chinese.
So it was ultimately classified as C, not B.

It was ultimately changed to:
Implement a
fibonaccifunction that returns a function (closure), which in turn returns successive Fibonacci numbers (0, 1, 1, 2, 3, 5, …).
The technical meaning has not changed at all.
But the main structure of the Chinese sentence became clear immediately:
fibonacci
→ returns a closure
→ the closure returns successive Fibonacci numbers
This is also a point I became increasingly clear about later:
Pre-release quality audit is not about re-translating, but about fixing expressions that genuinely affect understanding.
4. Representative D: fmt.Println was incorrectly translated as main
Compared to Category C, Category D issues were much fewer.
Across all 103 pages, there were ultimately only 2 Category D pages.
One of them was flowcontrol/7.
The English original means:
Both calls to
powreturn before the call tomainwithinfmt.Printlnbegins.
But the original Chinese became:
Before
mainbegins execution, both calls topowhave already returned…
These two statements are not the same thing.
Because pow itself is called during the execution of main.
If we say:
Before
mainbegins execution,powhas already returned.
Then the execution order completely falls apart.

flowcontrol/7—incorrectly translating “before the fmt.Println call begins” as “before main begins execution”It was ultimately revised to:
Both calls to
powwill return beforefmt.Printlnis called withinmain.
This is a very clear Category D:
Must modify.
The other D appeared in moretypes/7.
The original Chinese described:
a[1:4]
as:
the 1st to 3rd elements of
a
But this Go slice actually contains:
the elements corresponding to indices 1, 2, and 3
In Chinese, “the 1st element” is usually understood as the first element at index 0.
So it was ultimately unified to:
elements at indices 1 to 3 in
a
Neither of these two Ds is about “writing it more beautifully.”
They are issues that could genuinely affect a beginner’s understanding of program behavior.
5. A Go Chinese terminology calibration was inserted midway through the audit
Originally, I thought this round of work only required auditing the body text of 103 pages.
As a result, after checking the concurrency lessons, I found:
- some pages used “信道” (channel);
- some pages used “通道” (channel);
- and some pages just kept
channel.
This raised a new question:
What exactly should determine Go Chinese terminology?
Later, I did not decide based on “which word appears more in the project.” Instead, I referred back to long-standing resources in the Chinese Go community and ultimately froze a set of project terms.
For example:
channel→ 通道type inference→ 类型推断untyped constant→ 无类型常量untyped numeric constant→ 无类型数值常量built-in→ 内置
I have already organized this part into a separate previous article, so I will not expand on it here.
But this terminology calibration also affected the final audit statistics.
For example, moretypes/15 originally had both appearing on the same page:
内建
内置
Two built-in translation methods.
Although this does not affect technical understanding at all, since the pre-release terminology baseline was decided to uniformly adopt:
内置
this page also entered Category C.
So the final number of official revisions increased from the initial 15 pages to:
16 pages
6. How many of the 103 pages ultimately needed modification
After all pages were audited and the terminology was calibrated, the final statistics were:
A: 87
B: 0
C: 14
D: 2
Total: 103
Those actually needing modification:
14 Category C
+
2 Category D
=
16 pages
That is to say:
87 / 103 pages remained as is.
I did not rewrite them just because ChatGPT could provide an alternative Chinese expression.
This is actually the part of this audit that I am quite satisfied with.
If a round of so-called “pre-release manual audit” ended up rewriting eighty or ninety of the 103 pages, I would instead suspect:
Was this an audit, or a re-translation?
And the current result is closer to the state I hoped for:
The model is responsible for producing the majority of the publishable translations, while the manual audit only finds the few genuine anomalies worth intervening on.
7. The 16 pages were not re-run through GLM, but received minimal precise revisions
After identifying the 16 pages, I did not call GLM-5.2 again.
Instead, I pinned down every modification first, including:
- the current text;
- the final suggested text;
- the reason for modification;
- whether it involves the glossary;
- whether it would affect the existing
presentstructure.
Then I handed them all to Codex for modification.
This step had several strict restrictions:
- do not modify the other 87 Category A pages;
- no opportunistic polishing;
- do not re-translate entire pages;
- do not modify
.play; - do not change link targets;
- do not bypass existing validators;
- do not touch the public UI;
- do not update project status docs.
Ultimately, only the following were modified:
16 candidates +
glossary.yaml
This is why this round of modifications ultimately maintained a very small diff.
8. A particularly valuable surprise: the validator rejected my manual revision
methods/19 is my favorite case in this round of work.
Not because the issue was severe, but because it truly validated the project architecture.
This page originally had the sentence:
A nil
errorindicates success; a non-nilerrorindicates failure.
The Chinese was obviously a bit awkward.
My initial revision suggestion was:
A nil
errorindicates success; non-nil indicates failure.
From a Chinese perspective, there is nothing wrong with this sentence.
It is even more concise than the final adopted version.
But after Codex modified it, the validator did not pass.
The reason was:
The English source structure required this sentence to retain two
`error`inline code structures, but my manual suggestion left only one.
In other words, in my attempt to make the Chinese more natural, I inadvertently deleted a protected inline-code span.

methods/19 was rejected by the validator for missing one inline code structureIt was finally changed to:
A nil
errorindicates success; a non-nilerrorindicates failure.
Running the validator again:
PASS
candidate OK: locale=zh-CN page_id=methods/19
This incident perfectly illustrates why this project insists:
Whether the translation comes from GLM-5.2, ChatGPT, or manual modification, it must pass through the same automated validation.
If a sentence was considered “of course correct” just because ChatGPT and I confirmed it manually, then this structural change would not have been caught.
And the validator does not care:
who modified the sentence.
It only cares:
whether the candidate still satisfies the structural constraints required by the source page.
This is exactly the property I want the entire process to have.
9. Teaching code comments also underwent a dedicated validation pass
This round also included a relatively minor but very representative modification in concurrency/6.
The body text had been translated into Chinese, but two English teaching comments remained in the select example:
select {
case i := <-c:
// use i
default:
// receiving from c would block
}
Ultimately translated to:
select {
case i := <-c:
// 使用 i
default:
// 从 c 接收会阻塞
}
The project had already specifically implemented protection, restoration, and validation for translatable teaching code comments.
So it was not the case that just because:
“they are just two comments”
they were modified and let through directly.
They still went through the full existing teaching-comment and structural validator.
And ultimately passed.
This again demonstrates:
Translatable does not mean structural protection can be bypassed.
10. Even an extra newline at the end of the file was cleaned up
After all 16 pages were modified, I had Codex perform a read-only diff audit on the 17 files.
There were no issues with the semantic changes, but it found:
10 candidates originally had no newline at the end of the file, but after manual editing, an extra
0abyte was accidentally introduced.
This of course would not affect Go Tour rendering.
Nor would it cause the validator to fail.
But it is a purely meaningless diff.
Since the goal this time was:
minimal, precise revisions
there was no reason to bring this kind of change into the final commit.
So the EOF state of these 10 files was specifically restored to their original state.
Final confirmation:
- body text unchanged;
- structure unchanged;
- 10 EOF noises eliminated;
- no additional changes in other files.
This kind of detail is not important in itself.
But it makes the final commit easier to audit:
Every diff should answer “why was this changed?”.
11. Ultimately, all 16 / 16 passed validation again
After all revisions were completed, the 16 pages were re-run through the unified validator.
Result:
16 / 16 PASS
Then the complete Go test was executed:
go test ./...
All passed.
Continue checking:
git diff --check
Also passed.
The complete result of this final round is:

5f77081Final summary:
audited pages: 103 / 103
A: 87
C: 14
D: 2
revised pages: 16 / 16
validator: PASS
go test ./...: PASS
git diff --check: PASS
And committed:
5f77081 fix: 完成 zh-CN 课程正文质量审计修订
After committing:
working tree: clean
12. From 103 pages ready to 103 pages passing pre-release quality audit
Before this, the project already had a very important commit:
584ce7d feat: 完成 zh-CN 全部课程页面翻译
It represents:
All 103 official release pages have completed translation and passed automated validation to reach ready.
And this new one:
5f77081 fix: 完成 zh-CN 课程正文质量审计修订
represents another phase:
All 103 pages have undergone a pre-release manual quality audit, and the 16 pages requiring adjustments have been revised and re-passed the same automated validation.
The implications of these two milestones are not the same.
The first answers:
Has the translation process been fully run?
The second answers:
Has the current translation undergone a complete pre-release quality check?
Now, both questions can be answered:
Yes.
13. Why ultimately “only modifying 16 pages” is actually a good result
Before this audit, I actually did not know how much would be changed in the end.
It could have been 10 pages, or it could have been 50 pages.
But ultimately:
Out of 103 pages, only 16 needed clear revisions.
I feel this ratio actually shows that the preceding translation process was already quite stable.
Especially since:
There were only 2 pages of Category D, which are genuine technical errors.
Most of the remaining content needing modification was:
- obviously awkward Chinese;
- inconsistent terminology;
- English residue;
- a certain expression that was not accurate enough;
- a sentence that, while understandable, was not suitable as published tutorial text.
This is quite close to the direction the project originally wanted to achieve:
It does not require manual sentence-by-sentence re-translation, but it must have the ability to catch the few genuinely anomalous pages before release.
If this expands to other languages in the future, I also do not want the process to become:
Model translates 100 pages
→ Human re-translates 100 pages
The significance of automation would be very limited then.
I prefer it to maintain its current structure:
Model full-page translation
→ Automated structural validation
→ Full quality audit
→ Revise only clear anomalies
→ Same automated validation
→ Release
14. Summary
What impressed me most about this round of 103-page body text quality audit was not:
how many sentences were changed.
But rather that the entire process began to form a fairly clear closed loop.
After the model generates the translation, automated validation is responsible for structural reliability.
The manual audit is not responsible for rewriting all pages, but only for judging:
which pages are genuinely worth intervening on.
After manual modifications, they do not receive special treatment just because “a human modified them.” Instead, they re-enter the same validator.
Ultimately:
All 103 pages audited, 87 pages kept as is, 14 Category C, 2 Category D, totaling 16 pages revised.
And that failure of methods/19 particularly confirmed to me:
Manual judgment and automated validation are not substitutes for each other, but complements.
Humans are better at noticing:
“Why is this sentence so convoluted?”
The validator is better at noticing:
“You just deleted a mandatory inline code structure to make it less convoluted.”
Having both present at the same time is closer to the release process I hope this project will ultimately have.
At this point, the course body text for A Tour of Go Simplified Chinese can basically be considered to have finished its pre-release wrap-up.
The next remaining focus is no longer the 103 course pages themselves, but another layer of content in the browser:
Public UI copy.
For example, what can still be seen on the page currently:
RunFormatResetSyntax- Previous / Next related interfaces
- Other public interactive text
The body text is done, and the next phase will be their turn.

