Make Your Coding Agent Speak Simple English: Turn Daily Work into Language Practice

The author describes their English proficiency: they can read simple technical English and recognize common development terms, but complex sentences with multiple conditions and references cause difficulty, leading to frequent reliance on translation. To integrate English practice into daily work, they configured their Coding Agent (Codex) to default to simple English while preserving accurate technical terminology.

Targeting Long Sentences

The main obstacle is not individual technical words like cache, request, or timeout, but sentences that pack conditions, causes, exceptions, and multiple references into one structure. The author illustrates with a hypothetical client behavior:

If the cached token has expired, the client requests a new token before retrying the original request, unless token refresh fails.

Rewriting the same logic with one main idea per sentence:

If the cached token has expired, the client requests a new token. If token refresh succeeds, the client retries the original request. If token refresh fails, the client does not retry the request.

All conditions, sequence, and failure branches are preserved, but each sentence handles less information, making it easier to follow. The rule for the AI: reduce sentence structural complexity while keeping explanatory completeness.

Choosing a Style Guide: Google over ACE

The author compared the Google Developer Documentation Style Guide and Attempto Controlled English (ACE). Google's guide emphasizes common words, shorter sentences, active voice, consistent terminology, and avoiding idioms — aligning well with reading developer docs, design explanations, and code comments. However, it does not guarantee comprehension for basic English readers. ACE restricts grammar for precise specifications and machine processing, which is overkill for daily troubleshooting discussions and implementation requests. The chosen combination: Google's clear writing principles plus personal readability rules.

Personal Simple English Rules

Use common everyday words and accurate technical terms.

Express one main idea per sentence; prefer active voice.

Minimize nested clauses; repeat nouns when pronouns are ambiguous.

Use the same term for the same concept; avoid synonym variation.

Aim for 8–15 words per sentence when practical, but prioritize completeness over a strict count.

Embedding Rules in Codex via AGENTS.md

To avoid forgetting the preference in busy moments, the author added the rules to Codex's user-level ~/.codex/AGENTS.md. Codex loads global instructions from the user directory ( ~/.codex or CODEX_HOME), with AGENTS.override.md taking precedence, and project-specific rules overriding earlier globals. The following content can be copied into the user instruction file:

## Simple English for work and learning

I know many software development terms.
I can read simple English, but complex sentences are difficult.
I want to improve my English through normal technical work.

Use simple English for replies, progress updates,
documentation, and code comments.
Reply in English by default, even when I ask in Chinese.
Honor explicit language requests and project requirements.
Keep the requested language of deliverables, such as Chinese articles.

Follow the Google Developer Documentation Style Guide
where relevant, with these additional rules:

- Use common everyday words and accurate technical terms.
- Aim for 8–15 words per sentence when practical.
  This is a target, not a strict limit.
- Express one main idea per sentence.
- Prefer active voice and clear subjects.
- Avoid nested clauses, idioms, slang, and figurative language.
- Use the same term for the same concept.
- Repeat a noun when a pronoun would be unclear.
- Briefly explain unfamiliar terms when needed.
- State the main point first, then explain reasons or steps.
- Preserve conditions, exceptions, and technical accuracy.
- Keep identifiers, commands, API names, and quotes unchanged.
- Do not rewrite unrelated content to enforce these rules.

Accept Chinese, English, and mixed-language requests.
Provide Chinese support when I request it.
If I say the English is too difficult, simplify it.
Add Chinese support as needed.

When I write in English, answer my question first.
Then, when useful, suggest one concise, natural rewrite.
Do not correct every minor error or turn work into a lesson.

After saving, start a new Codex session and ask it to summarize the English preference to verify loading. Test with a real task to confirm behavior.

Documentation and code comments must still follow project language requirements; existing files need not be rewritten. This preference primarily serves the author–Agent communication.

Reading Workflow: Try English First, Then Simplify, Then Translate

The author aims to change the habit of immediate translation. The new workflow:

Read the English response once.

If the conclusion, reasons, and next steps are clear, continue working.

If a sentence blocks understanding, ask the AI to rewrite it in simpler English while keeping all technical details and conditions:

Please rewrite this explanation in simpler English. Keep all technical details and conditions.

If still unclear or the task is urgent, request a Chinese explanation. After understanding, re-read the key English sentences to identify the blocking word or structure.

The process is illustrated in the diagram below: follow the blue main line when comprehension succeeds; use the orange side paths for stepwise help, then loop back to re-read; only after confirmation proceed to the green "continue work" stage.

For high-stakes content (data deletion, permission changes, production operations), the author verifies meaning directly, using Chinese if needed. Practice must not turn critical decisions into guesses. Translation is still used, but only for the truly difficult parts.

Writing Practice: Start with Real Requests, Get Rewrites

To practice expression without interrupting work, the author writes requests in their own English, inserting Chinese where stuck, lets the AI handle the task, then receives a natural rewrite. Example:

Please check this function. 我担心并发问题。

AI responds after handling the issue:

Please check this function for concurrency issues.

Next time, the author has a ready-to-use phrase. No need to master all concurrency-related English at once, nor correct every article error.

Common work requests suitable for self-written English:

Please explain why this test fails.
What happens if the request times out?
Please compare these two options.
Please keep the existing behavior.

Another technique: paraphrase the Agent's explanation in one's own words and ask for verification:

My understanding: the client retries only after token refresh succeeds.
Is that correct?

This checks both reading comprehension and expression; if the condition is misstated, the AI should correct the meaning first, then the language.

Tracking Progress: Observable Metrics

The author focuses on three conditions for the experiment: real tasks, relevant content, adjustable difficulty. Repeated exposure to similar phrasing across tasks allows reuse. Progress indicators (personal observations, not standardized tests):

Fewer full-translation requests for similar tasks.

Faster location of conclusions, conditions, and next steps.

Ability to restate in own words, not just a feeling of "I get it".

Spontaneous use of expressions that previously required AI rewriting.

Faster re-reading of the same material does not prove faster comprehension of new material. Occasional testing with unseen but similar explanations validates transfer. Once simple English flows smoothly, gradually reduce extra simplification and engage with more natural explanations and original docs, keeping help for unfamiliar complex content. Reading and writing practice do not replace listening and speaking training.

The immediate goal: tomorrow, when working with the Coding Agent, read one more English segment and write one more request by hand. When stuck, ask for help as needed, then continue the work. If you also use a Coding Agent daily, can read simple English but habitually translate long sentences, try adding these rules. Start with a familiar task and see if you're willing to read a bit more.

References

Google Developer Documentation Style Guide: Write for a global audience — official recommendations on simple words, short sentences, active voice, and terminology consistency.

Attempto Controlled English Language Manual, Version 3.0 — ACE's specification expression goals, grammar restrictions, and formalization uses.

OpenAI official documentation: Custom instructions with AGENTS.md — Codex global and project instruction discovery, precedence, and session loading.