Skip to main content
skill CX Codex

translate · ai-driven-dev — Claude Code skill: what it does, how to install

Turns the framework's canonical source into native content for each tool: target-aware transforms, the plugin content translator, and the build strategies behind aidd translate and aidd sync.

MIT ★ 571 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ai-driven-dev/framework --skill translate -a claude-code
Open on GitHub

What translate does

This skill owns the layer that rewrites the framework's canonical Claude-format source into native content per tool. Transforms whose behaviour depends on the destination sit in domain/formats/. PluginContentTranslator in domain/content-translator.ts hands a plugin's files to the tool's own rewriteContent rather than duplicating that rewrite. The aidd translate use-case, FrameworkBuildUseCase, reads a ToolBuildContract for a given target and mode, then dispatches to MarketplaceBuildStrategy or FlatBuildStrategy. Neither strategy branches per tool or per artifact kind. runtime/wiring/translate.ts derives the "<target>:<mode>" registry by walking the registered tools, so nobody maintains a table by hand.

Placement has rules. A transform only one tool profile needs belongs in that profile's own directory. One shared by two or more profiles but identical whichever target it serves goes to contexts/tools/domain/formats/. What stays in translate/domain/formats/ is the transform that knows which target it writes for.

Only the framework context imports from here, and only modules on the PUBLIC_MODULES.translate list; an architecture test holds that line. A new build target means the tool declares a contract in tools, not a new case in this skill.

What it helps with

  • add a transform that writes content differently for each target tool
  • change PluginContentTranslator without reimplementing a tool's rewrite
  • add a build strategy behind aidd translate
  • wire a new tool into the build registry with no hand-kept rows
  • check which modules other contexts may import from translate

Example prompts for the agent

  • Add a target-aware transform for Cursor under domain/formats/, with a unit test on an input carrying the marker it rewrites.
  • The new tool declares its ToolBuildContract in tools — wire it into runtime/wiring/translate.ts.
  • Explain why PluginContentTranslator delegates to the tool's rewriteContent instead of rewriting content itself.

How to install translate

1Skills CLI (Vercel)

npx skills add ai-driven-dev/framework --skill translate -a claude-code

2Manually: put the files in place

~/.claude/skills/translate/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/translate/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about translate

How do I install translate in Claude Code?

Run npx skills add ai-driven-dev/framework --skill translate -a claude-code. The skill lands at ~/.claude/skills/translate/SKILL.md.

What does translate do?

It builds the pipeline that converts the canonical source into native content per tool: target-aware transforms, the plugin content translator, and the build strategies behind aidd translate and aidd sync.

How is it different from the tools, distribution and framework skills?

A tool's own profile, capability classes and build contract belong to tools. Where content comes from belongs to distribution. Manifest and install orchestration belongs to framework. This skill covers only what varies with the target.

Source text

SKILL.md · MIT
---
name: translate
description: >
  Builds the canonical-source-to-target-native translation pipeline under src/contexts/translate/
  — target-aware content transforms, the plugin content translator, and the build strategies
  behind `aidd translate` and `aidd sync`. Use when adding a target-aware transform, changing
  `PluginContentTranslator`, adding a build strategy, or wiring a new tool into the build
  registry. Do NOT use for a tool's own profile, capability classes, or build contract — use
  `tools`. Do NOT use for where content is fetched from — use `distribution`. Do NOT use for
  manifest/install orchestration — use `framework`.
---

# Translate

`translate` is the core: it turns the canonical, Claude-format framework source into
target-native content for every tool at once. It reaches two places and no others: `tools`, its
one outbound context edge, and `kernel`. Everything it reaches in `tools` is that context's
declared public surface (`contracts.ts`, `registry.ts`, `build-contract.ts`, and the handful of
capability and port modules listed as public), never an internal file. The whole graph is in
`.claude/rules/00-architecture/0-contexts.md`.

## What goes in

| Concept | Location |
|---|---|
| A transform whose behavior differs by target tool | `domain/formats/` |
| The plugin-files-to-installed-files translator | `domain/content-translator.ts` (`PluginContentTranslator`) |
| The canonical framework-doc shape | `domain/canon.ts` |
| The canonical single-plugin shape | `domain/plugin-distribution.ts` |
| Build targets and modes | `domain/build-target.ts` |
| The `aidd translate` use-case | `application/translate-source.ts` (`FrameworkBuildUseCase`) |
| A build orchestrator (one per mode, never per tool) | `application/strategies/` |
| Schema validation for marketplace/plugin manifests | `infrastructure/schema-validator.ts` |

A transform used by exactly one tool profile does not belong here — it lives in that profile's
own directory. A transform shared by ≥2 profiles but identical regardless of target lives in
`contexts/tools/domain/formats/` instead. What belongs in `translate/domain/formats/` is a
transform that is *aware* of which target it is producing for.

## How

- `PluginContentTranslator` takes one plugin's canonical files and one tool's `AiTool<C>`, and
  calls the tool's own `rewriteContent` — it does not reimplement a
  tool's rewrite logic, it invokes what `tools` declared. That function is one-way and has no
  inverse; the `tools` skill's `references/content-rewrite.md` says why, and names the trap an
  identity rewrite sets.
- `FrameworkBuildUseCase` (`aidd translate`) reads a `ToolBuildContract` per target and mode from
  `tools`, and dispatches to `MarketplaceBuildStrategy` or `FlatBuildStrategy` — both implement
  `BuildOutputStrategy` and iterate the six artifact kinds generically, with zero per-tool or
  per-kind branching. Adding a build target means the target tool declares a contract in `tools`;
  it never means adding a case here. See the `tools` skill's `references/build-contract.md`.
- `runtime/wiring/translate.ts` derives the `"<target>:<mode>"` build registry by iterating every
  registered tool and reading its contract — there is no hand-maintained per-tool row.
- Follow the use-case and orchestration rules in `.claude/rules/00-architecture/` for the
  application layer's shape, and the shared-module rule there before promoting a helper used by
  only one strategy into `shared-plugin-helpers.ts`.

## Public surface

Nothing outside `contexts/translate/` may import a module this context has not declared public —
`tests/architecture/context-boundary.arch.test.ts` holds the list (`PUBLIC_MODULES.translate`).
`framework` is the only context that imports from here (`framework → translate`); a module used
by `framework` must be on that list.

## How it's tested

- `tests/contexts/translate/` mirrors `src/contexts/translate/` — formats, content-translator,
  canon, and the two build strategies each have unit or integration coverage.
- `tests/golden/framework-build-golden.e2e.test.ts` snapshots a full build across every target —
  see `test` skill's golden/machine-independence rules before touching a snapshot.
- A new target-aware transform gets a unit test over a representative input carrying the marker it
  is meant to rewrite. A transform that is the identity for the fixture it was given is
  indistinguishable from one that never ran.

© ai-driven-dev · MIT · ai-driven-dev/framework

Similar skills

All skills for Agent setup: memory, context, orchestration →

translate by other authors comes first.

translate feiskyer Translates technical articles and texts from English or Japanese into Chinese while preserving formatting and technical accuracy. Useful when you need source material rendered in a language your audience reads natively. CX Codex +1 294installs translate vide The translate skill adds a new UI string to all six Android locale files and prepares translations into five languages. Use it when your app needs another user-facing string. CX Codex +1 1installs monorepo-setup patricio0312rev monorepo-setup lays out a Turborepo and pnpm monorepo: apps, shared packages, TypeScript and ESLint configs, and a build pipeline. CX Codex +1 283installs hyperflow Mohammed Abdelhady hyperflow is a Claude Code plugin that turns a session into a pipeline of spec questions, batched tasks, parallel workers under review, and cross-session project memory. ★ 1,013repo stars unity-build-pipeline gamedev-skills unity-build-pipeline is a Claude Code skill that configures and automates Unity 6.3 LTS builds with profiles and scripts. It runs for build automation or player-only reflection errors. CX Codex +1 11,100installs game-ci-cd-pipeline akillness game-ci-cd-pipeline scopes a messy Unity or Unreal build setup by signal tier first, then settles on one narrow pipeline packet to repair. CX Codex +1 297installs baoyu-translate JimLiu The baoyu-translate skill translates articles, documents, and text in three quality modes with custom glossaries. It triggers on translation commands or when a URL or file is provided with translation intent. CX Codex +1 26,300installs translate-book deusyu translate-book translates books from PDF, DOCX, EPUB, or Markdown with parallel sub-agents and exports the result as HTML, DOCX, EPUB, or PDF. CX Codex +1 2,100installs

From the same set80

The whole set →
01-bootstrap 01-bootstrap guides early SaaS architecture decisions and records them in aidd_docs/INSTALL.md. Use it while defining a new project’s stack and design. CX Codex +1 ★ 571repo stars checker checker — a subagent that judges finished work against a checklist, runs validation, and verifies the code serves the actual need. Reports findings with evidence, never edits. CX Codex +1 ★ 571repo stars 04-fact-check 04-fact-check verifies factual statements against authoritative sources and rewrites prose with citations, hedging claims that lack proof. Not meant for judging code. CX Codex +1 ★ 571repo stars distribution distribution — a skill for Claude Code, Cursor, Codex, GitHub Copilot and OpenCode that manages where plugin and marketplace content comes from and how to fetch it. CX Codex +1 ★ 571repo stars tools Defines AI assistant and IDE profiles, build contracts, and capability interfaces under src/contexts/tools/ in the framework. CX Codex +1 ★ 571repo stars framework framework — a skill for Claude Code, Cursor, and other platforms that tracks every installed file and coordinates project setup, recovery, diagnostics, and cleanup through a single manifest. CX Codex +1 ★ 571repo stars 00-async-dev 00-async-dev is a Claude Code skill that takes a task through the async-dev pipeline: repo setup, running a ready issue, and clearing review comments on a PR. CX Codex +1 ★ 571repo stars aidd-qa aidd-qa validates browser acceptance criteria against observable behavior and records short review videos. Useful right before submitting a completed task. CX Codex +1 ★ 571repo stars

Project sponsors

Companies that keep this analytics open