I Didn't Translate My Website — I Managed the AIs That Did

This site is now bilingual. Everything you’re reading exists in German too, under /de/ — the guides, the homepage, the Kompetenzpfad, the whole lot. If your browser prefers German, the site takes you there on its own.

I run this site in English. I also live in Switzerland, where a big chunk of my potential readers would rather read German, and where I can actually do the quality control, because German is a language I speak. So the question had been sitting on my to-do list for months: translate the whole thing.

The honest reason it sat there so long is that the numbers are ugly. Twenty-five guides. Around 54,000 words. If I translated one guide a night after work, that’s a month of evenings, and by the time I finished guide 25, guide 1 would already be out of date. Translation is never a finished project. It’s a second copy of your site that you then have to keep in sync forever.

So I did the thing I keep telling everyone else to do: I stopped thinking about it as a writing task and started thinking about it as a management task. I didn’t translate my website. I built a small system of AI agents that did, and I supervised them. The bulk of it — architecture, a pilot, and all 25 guides live — took one day. The German homepage and the rest of the site chrome followed in a second session the next day.

Here’s exactly how, with the real numbers.

The trap: “AI can translate, so translation is solved”

Drop any of my guides into a general-purpose translation tool and you get German. Grammatically fine, done in two seconds, free. And any German speaker would clock it as machine-made inside a sentence.

Not because the words are wrong. Because everything around the words is wrong. German professional writing drifts formal and stiff by default: long nested sentences, nouns where verbs should be, a reflexive politeness that turns “you” into a starched “Sie.” My English voice is the opposite — short sentences, first person, the odd sentence that starts with “And.” A literal translation keeps my words and loses my voice. Technically correct, subtly dead.

The mental model that helped: the AI is a brilliant translator who has never met me. Fluent in both languages, faster than any human, and with zero idea how I write or what I care about — the same brilliant-new-hire problem that shows up everywhere with AI. You don’t fix that with a better model. You fix it by writing the brief down.

The reframe: you’re the editor-in-chief now, not the translator

This is the mental shift that makes the rest of it work, so I want to say it plainly before the how-to.

The instinct is to open guide one, paste it into an AI, get German back, tidy it up, move to guide two. That’s just you doing the same manual job with a faster typewriter. You’ll be exhausted by guide five.

The better model: imagine you’ve been given a team of twenty-five translators for one day. You would never hand each of them the raw file and hope. You’d write them a brief: how formal to be, which brand terms to leave in English, what your voice sounds like. You’d have one of them do a sample first so you could correct the brief before the other twenty-four start. And you’d spend your own day reading their output and making the calls they can’t make.

That’s the whole playbook. The AI is the team. Your job is the brief and the red pen. Everything below is just the concrete version of that.

Move 1: Build the plumbing before you write a word of German

The mistake would be to start translating and figure out the website part later. I did it the other way round, and it’s the right order. For an entire afternoon there was no German content on the site at all, just the machinery to serve it, sitting there inert.

Three decisions did most of the work:

URLs tell you your analytics for free. English stays where it is (goodaiguide.com/guides/...). German lives under a /de/ prefix with the same slug (goodaiguide.com/de/guides/...). I didn’t translate the slugs — a translated URL is a URL that breaks the moment you rename anything, and it forks your links for no reader benefit. The bonus: because every German page shares that one /de/ prefix, my analytics can count German visitors by counting one path prefix. I don’t need a separate tracking setup to answer “is this even working.” The URL structure is the measurement.

Auto-detect belongs at the edge, and it has to be shy. There’s a tiny piece of code sitting in front of the site that looks at a visitor’s browser language. If their browser strongly prefers German and they haven’t chosen otherwise, it sends them to the German version — but only on the homepage, never on a deep link, and never for Google’s crawler (search engines need to see both versions as they are). It remembers the choice in a cookie, and the language switcher in the header writes that same cookie. The rule I gave it: when unsure, do nothing. A wrong redirect is far more annoying than no redirect. And I built it self-arming: the redirect stayed switched off, automatically, until the German homepage actually existed — so I could ship the machinery weeks before the content without stranding anyone on a 404.

One template, two languages. The single most useful structural thing I did was make the English and German guide pages render from the same template — literally one file, not two copies. The two language versions physically cannot drift apart in layout, because there’s only one layout to drift. The German page is that same page, pointed at a German source file.

All of this together was about 900 lines of code across seven small files, plus a config change and a set of tests. It shipped with zero visible change to the site — which is exactly what you want from plumbing. If the architecture is good, launching it should be a non-event.

Move 2: Translate three guides by hand-holding, to discover the rulebook

Here’s where people rush and pay for it later. Before you translate 25 guides, translate 3 — slowly, watching closely — for the sole purpose of writing down the rules.

I picked three deliberately different guides: a voice-heavy opinion piece (does the AI keep my tone or flatten it?), a hands-on how-to full of copy-paste prompts (does it translate the prompts, and should it?), and a product-heavy piece thick with names like Claude and Copilot (does it know what to leave alone?).

Every time the AI made a choice I had an opinion about, that opinion became a written rule. A few that came out of my pilot:

• Address the reader as “du,” never the formal “Sie.” This one decision sets the entire temperature of the site. Formal German would make the whole thing feel like a bank letter.
• Swiss spelling, but not Swiss vocabulary. We write “ss” instead of the German “ß” — but I banned words that only a Swiss person would recognize, because plenty of my German readers wouldn’t. Neutral enough to work on both sides of the border.
• Don’t force-translate words Germans already say in English. No German professional says “Eingabeaufforderung” — they say “Prompt.” Same with Tool, Feature, Workflow, Use Case. The test I wrote into the rulebook: would I say the English word out loud in a German conversation over coffee? Then it stays English.
• A glossary of terms that must be identical everywhere. “The brilliant new hire” always becomes the same German phrase. “Fluency Path” always becomes “Kompetenzpfad.” Consistency the reader never notices — until it’s missing.
• Some things are brand assets and never translate. Product names, obviously. But also my certificate level names, which exist as real credentials; they stay English even inside German sentences.
• A banned-phrases list, in German. German has its own set of AI tells — the machine-translation equivalent of “in today’s fast-paced world.” I wrote them down so every agent would avoid the same ones.

By the end of the pilot the document was about a page long. That page is the most valuable artifact in the whole project. It’s the difference between 25 guides in one voice and 25 guides in 25 slightly-off voices. I QA’d the three pilot guides myself, corrected the rules where I disagreed, and only then considered the rulebook ready.

The bake-off: is the cheaper model good enough?

One sub-question I had to settle before scaling: which model? A more capable, more expensive one, or a faster, cheaper one? At 25 guides, that choice has real cost consequences.

So I ran a blind test. I had the voice-heavy pilot guide translated twice — once by each model, same brief — stripped the labels, and read both without knowing which was which. My honest verdict: mixed. Sometimes one read better, sometimes the other, and never by a margin I’d stake money on. Both kept my voice. Both followed the rulebook.

When the quality gap is that small, the decision makes itself: I took the cheaper, faster model for all the rest. This is a general lesson, not a one-off. People reflexively reach for the most powerful model for everything. But “good enough, run 25 times, fast and cheap” beats “marginally better, slow and expensive” for a job like this. The trick is that you can only know it’s good enough by testing on your content, with your rulebook — not by reading a benchmark.

Move 3: Fan out — one agent per file, all at once

With the plumbing built and the rulebook written, the last part was almost anticlimactic, which is the point.

I translated the remaining guides in batches, one AI sub-agent per guide, running in parallel. Each agent got the same cold-start package: the full rulebook, the source file, and the target path. Nothing else, because they start with no memory of each other, so the brief has to carry everything. Each one translated its guide, kept the exact structure, and reported back any judgment call it wasn’t sure about instead of quietly guessing.

The final guide batch was 17 at once. Seventeen agents, working simultaneously, finished in about 20 minutes. Each guide took a single agent three to seven minutes. If I’d done those 17 in sequence by hand, that’s most of a month of evenings; the machines did it over a coffee. The homepage, about page, Kompetenzpfad hub, and level pages followed the same pattern in a second session — five agents in parallel, same rulebook.

Then I sat in the one seat that matters: the editor’s chair.

What the AI got wrong (and what it got right that I didn’t expect)

I want to be honest here, because “I pressed a button and got a perfect German site” would be a lie, and it’s the wrong lesson anyway. The value wasn’t that the AI was flawless. It was that its mistakes were the kind a good editor catches in a read-through, not the kind that poison the whole project.

What I had to fix:

• It got helpful in the wrong way. One agent decided that “$30 a year” should become “30 francs” and that an example domain should end in .ch, to feel more Swiss. Thoughtful — and wrong. A translation must not change facts, and quietly localizing currency is exactly the Swiss-flavored drift I’d banned. I reverted it and added a rule: prices stay as they are.
• Parallel agents disagree, and someone has to rule. Two agents translated the same recurring term two different ways — one a long compound, one short. Left alone, the site would’ve called the same thing two different names on two different pages, exactly the kind of small inconsistency that makes something feel sloppy. I picked the short form, made it a rule, and it’s locked for every future file. The overruled calls become rules, so the same question never comes up twice. The rulebook gets a little smarter every session.
• Number formatting. German writes large numbers with a period where English uses a comma. Small things, but they’re the tells a native reader notices immediately.
• Cross-links between guides. Because the agents ran in parallel, an agent linking to another guide sometimes had to guess that guide’s German title, since its sibling hadn’t finished yet. A few guesses didn’t match the final titles, so I did one reconciliation pass at the end to line them all up.

And the thing I genuinely didn’t see coming: the AI found bugs in my English. To translate one guide faithfully, an agent had to read a sentence of mine very carefully — and flagged that I’d written “we chose the buy path” in a paragraph that then describes building everything in-house. It was a plain contradiction I’d read past a dozen times. It also caught two typos. Translation turns out to be the most thorough proofread your source will ever get, because a machine that has to render every word into another language can’t skim. I fixed the English too.

None of these were disasters. They were an afternoon of editing on top of a month of writing I didn’t have to do.

Where I chose to stop (for now)

“Translate the website” sounds like an all-or-nothing job, and it wasn’t. I translated the parts that carry the voice and the argument: the guides, the homepage, the Kompetenzpfad, the level playbooks. I deliberately left some things in English for now — the interactive quiz and certificate tooling, the individual tool reviews, the category pages. Partly they’re lower-value to translate, partly some are tangled up in code I’d rather migrate carefully than rush.

On a German page, a link to one of those still points to the English version, on purpose. A working English link beats a broken German one. That’s not a failure to finish. It’s shipping the valuable 80% now instead of holding everything hostage to the last 20%, and filling in the rest as it earns the effort.

The trade-off nobody mentions: translation is cheap, upkeep is forever

This is the part I’d most want a friend to hear before they get excited.

The translation itself is genuinely fast and genuinely cheap now. That’s real. But it’s a one-time cost, and it’s not the one that matters. The cost that matters is drift. English is my source of truth. Every single time I edit an English guide — fix a fact, sharpen a line, add a section — I’ve just made the German version a little bit wrong, and it stays wrong until I update it too. Publish an English guide and you’re not done; you owe a German translation before it’s really finished. A guide is now roughly one-and-a-half to two times the work it used to be, permanently.

That doesn’t go away with a better model. A second language isn’t a project you complete. It’s a second thing you maintain, for as long as the site exists. I went in with eyes open, because German-speaking professionals are exactly who this site is for, and it’s worth showing up for them properly. But if you’re weighing this for your own site: the translate button is free. The commitment behind it is not.

The numbers, in one place

• 25 guides translated, roughly 54,000 words of German — plus the homepage, about page, Kompetenzpfad hub, and four level playbooks.
• Two sessions on two days. Day one: architecture, pilot, and all 25 guides. Day two: the German homepage and site chrome.
• ~900 lines of one-time architecture code (URL routing, language switcher, auto-detect, shared templates), shipped with no visible change to the live site.
• A 3-guide pilot to write a one-page rulebook.
• A blind two-model test on one guide → cheaper model chosen, because the quality difference wasn’t real.
• 17 agents in parallel for the biggest batch, done in about 20 minutes; 3–7 minutes per guide.
• My own time went almost entirely into the rulebook and the final QA — the two things a machine can’t do for you.

What I’d tell you to do

If you’re staring at the same ugly numbers I was, the shape of the answer is:

1. Reframe it as management, not writing. You are hiring a team, not doing the typing. If that reframe feels wrong, the rest won’t work.
2. Build the boring plumbing first, and make launching it a non-event. Structure your URLs so your analytics come for free.
3. Pilot three, to write the rules. The rulebook is the deliverable of the pilot, not the three translations. Ninety percent of the quality lives in it — any decent model can translate; almost none will sound like you unless you tell it how you sound.
4. Test whether the cheap model is good enough on your content. It usually is. You only find out by looking, blind.
5. Fan out in parallel, then sit in the editor’s chair. Small units beat big ones — one file per agent keeps quality even and errors contained. Expect to fix facts the AI “helpfully” changed, formatting a native would clock, and naming disagreements between agents. Expect it to catch your own mistakes while it’s at it.
6. Decide where to stop. Ship the valuable 80% with honest English fallbacks, and go in knowing the real price: a second language is upkeep forever, not a weekend project.

The part that stays with me is the first and the last. I set out to get a German copy of my site, and I got that. But the more useful thing I got was the clearest proof yet of where the human belongs in this kind of work: not in the translating, which the machines now do at least as well as I would and a hundred times faster — but in the taste, the rules, and the judgment calls. Twenty-five guides is a lot of typing. It’s not a lot of deciding. The deciding is still the job, and it’s still mine.

None of this is unique to translation, which is why I bothered writing it up. Give the AI the context it doesn’t have, break the job into pieces it can’t mangle, keep a human on the decisions, and write down what you learn so you never re-learn it. The translate button was never the hard part. The system around it is the whole job.

If you want the companion pieces: why I let AI do the work and keep the taste for myself, and how the orchestrator-plus-sub-agents pattern actually feels.