没有不值得去解决的问题,也没有不值得去学习的技术!

How I Completed a Full Re-translation of A Tour of Go’s 103 Pages with ChatGPT and GitHub, Without an OpenAI API

Figure 2: The 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.

作者:

在

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:

Plaintext
103 / 103

All 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:

Plaintext
ChatGPT
+
GitHub
+
Existing local translation and validation tools

1. 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:

Plaintext
One complete present.Section
=
One complete lesson page

So 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:

Plaintext
Translation Engine

These existing capabilities were retained:

Plaintext
Complete lesson page
↓
Default protection
↓
Full-page translation
↓
restore
↓
candidate
↓
Unified validator

In 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:

Plaintext
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 page

If 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:

Plaintext
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 passing

In 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:

Plaintext
chatgpt-zh-CN-001
chatgpt-zh-CN-002
chatgpt-zh-CN-003
...
chatgpt-zh-CN-011

Batches 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.

Figure 1: The ChatGPT retranslation ultimately formed 11 batches. Batches 001–008 completed the initial coverage of all 103 official lesson pages, while Batches 009–011 were used for subsequent revisions; Batch 004 and Batch 008 each left one retry page.
Figure 1: The ChatGPT retranslation ultimately formed 11 batches. Batches 001–008 completed the initial coverage of all 103 official lesson pages, while Batches 009–011 were used for subsequent revisions; Batch 004 and Batch 008 each left one retry page.

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:

Plaintext
103 pages

One 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:

Plaintext
data/retranslation-runs/zh-CN/chatgpt-zh-CN-008/inputs/

After that, ChatGPT could directly read the committed files via GitHub:

Plaintext
Batch input
glossary
Translation rules
Necessary project context

This 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:

Plaintext
raw-responses/

Thus, the process that originally required extensive clipboard operations was transformed into:

Plaintext
Local project
↓
Generate fixed Batch input
↓
GitHub
↓
ChatGPT reads Batch
↓
Complete full-page translation
↓
GitHub writes back raw response
↓
Local sync
↓
process / restore / validator
Figure 2: The 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.
Figure 2: The 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:

Plaintext
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
→ Testing

As a result, the focus of my actual manual attention shifted from:

Plaintext
Constantly copying and pasting text

to:

Plaintext
Checking batch status
Handling anomalous pages
Evaluating revisions
Reviewing stage results

For 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:

Plaintext
data: Add eighth batch of ChatGPT retranslation inputs

Then the raw translation:

Plaintext
data: Add eighth batch of ChatGPT raw translations

After local restore and validator were completed, it would then commit:

Plaintext
data: Add eighth batch of ChatGPT retranslation candidates and validation results

This keeps the responsibilities of each stage clear.

In other words:

Plaintext
What the input was
↓
What ChatGPT's raw output was
↓
What candidate was generated after local processing
↓
What final result the validator produced

These 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:

Plaintext
inputs
raw-responses
candidates
validation

Taking basics/1 as an example:

Figure 3: Taking 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.
Figure 3: Taking 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:

Plaintext
inputs/basics-1.article

Records what was actually given to ChatGPT.

Plaintext
raw-responses/basics-1.article

Saves the raw translation returned by ChatGPT.

Plaintext
candidates/basics-1.article

Saves the candidate, after deterministic restore, that is ready to enter the project’s unified validation.

Finally:

Plaintext
validation/basics-1.json

Records the validator’s result.

This way, once an anomaly occurs on a page, several completely different questions can be answered:

Plaintext
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:

Plaintext
GLM-5.2
ChatGPT
Future other Translation Engines

It 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:

Plaintext
present.Section
Link targets
Code
Directives
Untranslatable technical identifiers
Other structures that must be preserved

It still cannot pass directly.

This is also why this time there was no separate construction of so-called:

Plaintext
ChatGPT validator
ChatGPT publisher
ChatGPT production workflow

What was actually added was:

Plaintext
ChatGPT retranslation staging

The 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:

Plaintext
moretypes/1
concurrency/1

They appeared respectively in:

Plaintext
chatgpt-zh-CN-004
chatgpt-zh-CN-008
Figure 4: 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.
Figure 4: 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:

Plaintext
retries/moretypes-1/attempt-001-validation.json
retries/moretypes-1/attempt-002.article

The 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:

Plaintext
restore
↓
validator
↓
candidate

Instead of:

Plaintext
First failure
↓
Delete
↓
Translate again
↓
Pretend the first time didn't happen

Ultimately, 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:

Plaintext
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 later

So 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:

Plaintext
Initial full-translation batches : 8
Pages in initial full translation: 103

That is to say:

Batches 001–008 have provided all 103 official lesson pages with new ChatGPT candidates.

After that:

Plaintext
Batch 009
Batch 010
Batch 011

Continued to process revisions for some pages.

So the entire retranslation phase can ultimately be summarized as:

Plaintext
8 initial full-translation batches
+
3 revision batches
=
11 ChatGPT batches
Figure 5: Final summary of the ChatGPT retranslation phase. Batches 001–008 achieved the initial full coverage of all 103 official lesson pages, and Batches 009–011 were used for subsequent revisions; the only official pages involved across all batches remain 103, with moretypes/1 and concurrency/1 retaining retry history.
Figure 5: Final summary of the ChatGPT retranslation phase. Batches 001–008 achieved the initial full coverage of all 103 official lesson pages, and Batches 009–011 were used for subsequent revisions; the only official pages involved across all batches remain 103, with moretypes/1 and concurrency/1 retaining retry history.

Final results:

Plaintext
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:
clean

At this point, the experimental direction that was merely “worth expanding the sample” in the previous article has truly become:

Plaintext
103 / 103

of 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:

Plaintext
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 retries

The 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:

Plaintext
Moving text

to:

Plaintext
Evaluating quality
Handling anomalies
Deciding on revisions
Controlling release boundaries

This 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:

Plaintext
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.

关于作者 · 持续学习与技术实践

我是一名拥有 15 年以上开发经验的技术从业者,自 2013 年起持续运营个人技术博客,记录工作与个人项目中遇到的真实问题,以及解决问题过程中的探索、实践和思考。

除了技术写作,我也在持续开发和维护自己的独立项目,探索新技术和新工具在实际场景中的应用。我始终相信,没有不值得去解决的问题,也没有不值得去学习的技术。

如果这篇文章对你有所帮助,欢迎浏览博客中的其他文章,也欢迎交流技术经验与想法。

关于我  ·  GitHub  ·  邮件联系