Refactoring Text Like Code: The Mother Tongue Prompt Hack Behind a Published Book

Introduction

This article explains a practical method for using large language models and prompt engineering to treat written drafts like software code. The approach, called the Mother Tongue Prompt Hack, emphasizes giving core context in a native language, iterating through human-guided corrections, and using AI to refactor text surgically. The same workflow can accelerate development of extensions, drafts, and even entire books while avoiding common pitfalls of direct generation.

The Core Concept: Mother Tongue Prompt Hack

The central idea is that providing prompts in a native language reduces the cognitive translation cost when designing logic or narrative. Rather than relying on the model to produce a final piece in one pass, the workflow frames the interaction as a sequence of targeted refactors. The human supplies context and nuance in the native language; the AI proposes a draft; the human provides precise corrections; the AI applies those corrections repeatedly. This is a human-led iteration model that treats text like modifiable, testable code.

Case Study: Building a YouTube Timer Extension

An illustrative example is the development of a browser extension to track actual time spent watching YouTube. The project started with a simple prompt in Japanese requesting a visible time display for a YouTube tab. Early AI responses produced monolithic code. The human-guided strategy shifted the work into small steps: show the time, add a popup, add persistence, and then extend to non-YouTube sites. Incremental development made debugging and refactoring tractable.

Common Technical Challenges and How Refactoring Helped

• Time drift: Timers slowly becoming inaccurate. The fix involved computing deltas and reconciling elapsed time on focus and blur events.
• Sleep mode artifacts: The machine entering sleep caused false positive time accumulation. The solution was to compare system timestamps on wake to avoid counting suspended intervals.
• Background listening vs active watching: Distinguishing audio playback in another window from active attention required heuristics such as visibility APIs combined with audioContext checks.
• Intermittent crashes: Overnight failures were addressed by adding robust error handling and persistent state reconciliation during initialization.

Refactoring Text Like Code: Practical Workflow

Treating prose and instructions like code enables repeatable, auditable edits. The recommended workflow mirrors standard engineering practices:

• Small increments: Request the AI to produce just one feature or paragraph at a time.
• Precise corrections: Provide edits in the native language, specifying intent and constraints.
• Refactor commits: Capture each revision as a discrete change. This can be simulated as a sequence of commits or tracked with versioned files.
• Automated regression checks: For code projects, run tests. For text, use consistency checks and semantic prompts to ensure revisions preserve core meaning.

Tools and Best Practices

Integrated development environments and editor refactoring tools accelerate reliable changes. IDEs such as PyCharm and Visual Studio Code include refactoring features that handle renaming and moving files safely. When editing large documents, avoid simple find-and-replace for structural changes. Instead, use editor refactor tools or treat edits as tagged, importable segments that can be reassembled programmatically.

• Avoid blind find-and-replace: This can introduce naming collisions or break structure.
• Use tagging and import patterns: Mark sections with tags to import code or text and record references.
• Maintain an edit history: Capture the sequence of refactors so the narrative or logic can be audited and reverted if necessary.

Outcome and Publishing

Applying the Mother Tongue Prompt Hack produced a sequence of robust, human-reviewed drafts and a working browser extension. The same approach scaled to a manuscript by iterating on chapters as refactorable units, refining voice and technical accuracy through repeated cycles. The result demonstrates that AI-assisted production is most effective when guided by native-language context and disciplined, code-like refactoring.

Conclusion

The Mother Tongue Prompt Hack transforms the relationship between human intent and AI execution. By treating text as code, using native language for precise commands, and applying incremental refactors with the support of IDE-like tools, complex projects such as extensions and books can be developed more reliably and audibly. This methodology reduces translation friction, improves traceability, and enables human-led creativity at scale.