In the previous article, I continued evaluating the Simplified Chinese translation workflow for A Tour of Go.
What actually changed at that point was no longer the Protection Policy, but the Translation Engine.
After independent translations of representative pages and anonymous multi-model reviews, ChatGPT performed the best overall, making it the most worthwhile translation source to continue validating at a larger scale.
Previous article:
However, when the previous article ended, I had not yet decided to immediately retranslate all 103 official lesson pages.
What I could confirm at the time was only:
ChatGPT is worth validating further with an expanded sample.
If it maintains its advantage after expansion, I would then assess whether it is worth replacing the existing official zh-CN translation.
Once I actually moved forward, this “expanded sample” did not stop at a dozen or so pages.
Instead, it went all the way to:
103 / 103All 103 official lesson pages currently in A Tour of Go ultimately had a new ChatGPT Chinese candidate generated.
But what truly needed to be solved at this stage was no longer:
“Can ChatGPT translate a single A Tour of Go page?”
The real question became:
Without an OpenAI API, how can ChatGPT’s high-quality full-page translation capability be genuinely integrated into the existing engineering workflow, while avoiding repetitive manual copy-pasting across 103 pages?
What ultimately played a key role was:
ChatGPT
+
GitHub
+
Existing local translation and validation tools1. The full-page translation principle remained unchanged this time
First, one point needs to be clarified.
This retranslation did not change the basic translation unit of A Tour of Go.
The original GLM-5.2 workflow already adhered to:
One complete present.Section
=
One complete lesson pageSo the root cause of the change in the quality approach this time was not a shift from sentence translation to full-page translation.
Both rounds of the workflow were inherently full-page translations.
What actually changed was:
Translation EngineThese existing capabilities were retained:
Complete lesson page
↓
Default protection
↓
Full-page translation
↓
restore
↓
candidate
↓
Unified validatorIn other words, I did not build a new system for page segmentation, structural protection, and validation just because I switched to ChatGPT.
The goal this time was:
To only replace the Translation Engine actually responsible for generating Chinese, reusing the already mature engineering components as much as possible.
2. 103 pages cannot rely on manual copy-pasting anymore
During the representative page experiment phase, manually copying a few full pages was acceptable.
But if scaled up to 103 pages, the problem immediately became different.
The most direct manual workflow would become:
Find the English page locally
↓
Copy the full translation input
↓
Switch to ChatGPT
↓
Paste
↓
Wait for translation
↓
Copy the Chinese result
↓
Switch back to local
↓
Save raw response
↓
Continue to the next pageIf all 103 pages were processed this way, the input and output alone would mean over two hundred mechanical copy-paste operations.
And there would be a constant need to verify:
Which Batch is currently being processed
Which page is currently being processed
Whether the input was copied completely
Whether the output was pasted into the wrong file
Whether structural characters changed during message passingIn the previous representative page experiment, I had already encountered structural drift caused by manual transfer.
So before actually starting the full retranslation, I became increasingly certain of one thing:
If I were truly going to retranslate 103 pages, I should eliminate manual text handling as much as possible.
However, at the time, I did not have the OpenAI API conditions suitable for direct integration into the existing toolchain.
So I ultimately adopted a different approach.
3. First, organize the 103 pages into fixed retranslation batches
The local project first added a dedicated retranslation input export capability.
Instead of temporarily opening a .article file and manually organizing the content to be handed over to the model.
The project now generates fixed translation inputs based on existing Default protection rules.
This gradually resulted in:
chatgpt-zh-CN-001
chatgpt-zh-CN-002
chatgpt-zh-CN-003
...
chatgpt-zh-CN-011Batches 001–008 completed the first full coverage of the 103 pages.
Batches 009–011 did not add new lesson pages; instead, they produced revisions for pages already completed.

The first few batches primarily progressed at 10 pages per batch.
Once the entire handoff and validation method stabilized, some batches expanded to 20 pages.
When Batch 008 was finally completed, the first full retranslation officially covered:
103 pagesOne thing to note here:
The number of candidates across the 11 batches cannot be directly summed up as the total page count.
There are always only 103 lesson pages.
Batches 009–011 are new revisions produced for existing pages.
4. GitHub became the handoff layer between ChatGPT and local tools
What truly reduced copy-pasting significantly at this stage was ChatGPT’s GitHub integration capability.
The local project first generated and committed the fixed Batch input.
For example:
data/retranslation-runs/zh-CN/chatgpt-zh-CN-008/inputs/After that, ChatGPT could directly read the committed files via GitHub:
Batch input
glossary
Translation rules
Necessary project contextThis way, I no longer needed to copy every full page from my local terminal or editor to ChatGPT.
After ChatGPT completed the full-page translation, the raw translation was similarly written back to the corresponding Batch via GitHub:
raw-responses/Thus, the process that originally required extensive clipboard operations was transformed into:
Local project
↓
Generate fixed Batch input
↓
GitHub
↓
ChatGPT reads Batch
↓
Complete full-page translation
↓
GitHub writes back raw response
↓
Local sync
↓
process / restore / validator
chatgpt-zh-CN-008 retranslation batch in GitHub. A Batch simultaneously stores inputs, raw-responses, candidates, validation, and retry records. GitHub serves as the data handoff layer between ChatGPT and the local translation pipeline.GitHub itself, of course, does not handle the translation.
Its role is to provide:
Stable, trackable data exchange.
ChatGPT does not need direct access to my local computer.
The local project also does not need to develop a new ChatGPT API Translation Engine specifically for this retranslation.
Both sides exchange data through files committed on GitHub.
The final division of labor gradually became:
ChatGPT
→ Read official translation input
→ Complete high-quality full-page translation
→ Write back raw translation
GitHub
→ Store and hand off input, output, and historical evidence
Local tools / Codex
→ input export
→ restore
→ validator
→ retry
→ candidate
→ TestingAs a result, the focus of my actual manual attention shifted from:
Constantly copying and pasting textto:
Checking batch status
Handling anomalous pages
Evaluating revisions
Reviewing stage resultsFor a scale of 103 pages, this difference is very significant.
5. Each batch of raw translations enters Git history separately
To ensure that ChatGPT’s raw results could still be tracked later, this stage also adhered to a fairly simple rule:
One batch of ChatGPT raw responses corresponds to an independent Git commit.
For example, a Batch would first have an input commit:
data: Add eighth batch of ChatGPT retranslation inputsThen the raw translation:
data: Add eighth batch of ChatGPT raw translationsAfter local restore and validator were completed, it would then commit:
data: Add eighth batch of ChatGPT retranslation candidates and validation resultsThis keeps the responsibilities of each stage clear.
In other words:
What the input was
↓
What ChatGPT's raw output was
↓
What candidate was generated after local processing
↓
What final result the validator producedThese are not mixed into a single modification.
For standard manual translation, this might seem a bit cumbersome.
But later on, when needing to trace why a certain page produced a new revision, or what exactly happened during a retry, this Git history becomes very valuable.
6. ChatGPT raw responses do not directly become official candidates
Another very important principle this time was:
ChatGPT’s returned Chinese text does not directly enter the official candidate pool just because the language looks good.
Each normal page retains at least four layers of content:
inputs
raw-responses
candidates
validationTaking basics/1 as an example:

basics/1 as an example, a normal page separately stores the actual translation input, ChatGPT’s raw response, the restored candidate, and the unified validator result. ChatGPT’s raw output does not directly become an official project candidate.Their respective responsibilities are:
inputs/basics-1.articleRecords what was actually given to ChatGPT.
raw-responses/basics-1.articleSaves the raw translation returned by ChatGPT.
candidates/basics-1.articleSaves the candidate, after deterministic restore, that is ready to enter the project’s unified validation.
Finally:
validation/basics-1.jsonRecords the validator’s result.
This way, once an anomaly occurs on a page, several completely different questions can be answered:
Was the original input correct?
Did ChatGPT change content it shouldn't have?
Was the restore correct?
Does the final candidate meet structural requirements?If only the final candidate were saved, these questions would easily become conflated.
7. ChatGPT continues to undergo the original unified validator
Changing the Translation Engine does not mean lowering the engineering threshold.
This remained unchanged throughout the retranslation process.
Regardless of whether the translation came from:
GLM-5.2
ChatGPT
Future other Translation EnginesIt should ultimately return to the same set of validators.
In other words:
The Translation Engine is responsible for generating Chinese, while the validator determines whether the result can proceed into the project.
No matter how high ChatGPT’s language quality is, if it breaks:
present.Section
Link targets
Code
Directives
Untranslatable technical identifiers
Other structures that must be preservedIt still cannot pass directly.
This is also why this time there was no separate construction of so-called:
ChatGPT validator
ChatGPT publisher
ChatGPT production workflowWhat was actually added was:
ChatGPT retranslation stagingThe subsequent deterministic validation continued to reuse existing capabilities as much as possible.
8. The 103 pages did not all pass on the first try
The true value of a batch workflow usually isn’t apparent when all pages go smoothly.
Rather, it is whether tracking can continue after failures occur.
During the first full retranslation of the 103 pages, two pages ultimately left a formal retry history:
moretypes/1
concurrency/1They appeared respectively in:
chatgpt-zh-CN-004
chatgpt-zh-CN-008
moretypes/1 and concurrency/1 both left an attempt-001-validation.json after the first processing, and then regenerated attempt-002.article. The failed attempts were not overwritten by the successful results, but were preserved as independent retry evidence.For example:
retries/moretypes-1/attempt-001-validation.json
retries/moretypes-1/attempt-002.articleThe validation result of the first failed attempt is saved.
The regenerated translation of the second attempt is similarly saved as a new attempt.
Then it re-enters the normal:
restore
↓
validator
↓
candidateInstead of:
First failure
↓
Delete
↓
Translate again
↓
Pretend the first time didn't happenUltimately, out of all 103 pages, only two required this formal second attempt.
9. Historical batches begin to serve as immutable evidence
As the number of batches gradually increased, I later clarified another rule:
Historical batches that have already been formed are no longer directly modified by hand.
If a page is later found to need adjustments, the old candidate is not modified retroactively.
Instead, a new revision batch is produced.
This is the main reason Batches 009–011 exist.
Ordinary translation drafts can usually overwrite the same file repeatedly.
But here, it is more important to know:
What the input given to ChatGPT was at that time
↓
What ChatGPT returned at that time
↓
What was restored at that time
↓
What the validator determined at that time
↓
Why a revision was needed laterSo these directories gradually ceased to be just temporary translation files.
They began to take on the role of:
Historical evidence
This principle becomes especially important when later promoting the new ChatGPT translation to an official canonical version.
However, that belongs to the next article.
10. Batches 001–008 ultimately achieved full coverage of 103 pages
After the first full retranslation concluded, the final statistics were:
Initial full-translation batches : 8
Pages in initial full translation: 103That is to say:
Batches 001–008 have provided all 103 official lesson pages with new ChatGPT candidates.
After that:
Batch 009
Batch 010
Batch 011Continued to process revisions for some pages.
So the entire retranslation phase can ultimately be summarized as:
8 initial full-translation batches
+
3 revision batches
=
11 ChatGPT batches
moretypes/1 and concurrency/1 retaining retry history.Final results:
Initial full-translation batches : 8 (001-008)
Revision batches : 3 (009-011)
Total ChatGPT batches : 11
Pages in initial full translation:
103
Unique pages across all batches:
103
Retry pages:
moretypes-1
concurrency-1
Repository status:
cleanAt this point, the experimental direction that was merely “worth expanding the sample” in the previous article has truly become:
103 / 103of complete ChatGPT retranslation results.
11. What was truly solved this time was not “whether ChatGPT can translate”
In retrospect, the problem truly solved at this stage was not:
Can ChatGPT translate A Tour of Go?
After the three representative page experiments in the previous article, this question actually already had a fairly clear answer.
The harder question was:
Without an OpenAI API, and without wanting to manually copy-paste 103 full pages, how can ChatGPT truly become a scalable Translation Engine?
The solution ultimately found this time did not involve building a complex new translation platform.
Rather, it reused existing capabilities as much as possible:
Existing full-page translation unit
+
Existing Default protection
+
Automatically exported fixed Batch input
+
GitHub data handoff
+
ChatGPT full-page translation
+
Raw response evidence
+
Existing restore
+
Existing validator
+
Limited retriesThe addition of GitHub was particularly crucial here.
It meant that ChatGPT and the local engineering no longer relied on extensive clipboard operations.
I did not need to copy 103 pages to ChatGPT one by one.
ChatGPT also did not need direct control over my local computer.
The local project, GitHub, and ChatGPT each handled the parts they were best suited for.
Ultimately, human focus shifted from:
Moving textto:
Evaluating quality
Handling anomalies
Deciding on revisions
Controlling release boundariesThis is what made the full 103-page retranslation something that could actually be pushed to completion.
However, at this point, it can still only be said that:
The 103 pages of new ChatGPT candidates have been fully generated.
It does not automatically lead to another conclusion:
These new translations are good enough to replace the current official zh-CN.
Because “translation completed” and “approved to become an official canonical version” should inherently be two different stages.
The next article will continue to document this part.
By then, the question to answer will no longer be:
Are the 103 pages fully translated?But rather:
After all 103 pages are fully translated, how to proceed with a complete semantic quality review, why the overall score was ultimately raised from the original ~94 to ~98, and how these ChatGPT candidates were safely promoted to official canonical status.

