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
npx skills add ai-driven-dev/framework --skill translate -a claude-codeWhat 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
PluginContentTranslatorwithout 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
Cursorunderdomain/formats/, with a unit test on an input carrying the marker it rewrites. - The new tool declares its
ToolBuildContractintools— wire it intoruntime/wiring/translate.ts. - Explain why
PluginContentTranslatordelegates to the tool'srewriteContentinstead of rewriting content itself.
How to install translate
1Skills CLI (Vercel)
npx skills add ai-driven-dev/framework --skill translate -a claude-code2Manually: put the files in place
~/.claude/skills/translate/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/translate/
1Skills CLI (Vercel)
npx skills add ai-driven-dev/framework --skill translate -a codex2Manually: put the files in place
.agents/skills/translate/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add ai-driven-dev/framework --skill translate -a cursor2Manually: put the files in place
.cursor/skills/translate/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install ai-driven-dev/framework cli/.claude/skills/translate2Manually: put the files in place
.github/skills/translate/SKILL.md1Skills CLI (Vercel)
npx skills add ai-driven-dev/framework --skill translate -a gemini-cli2Platform CLI
gemini skills install https://github.com/ai-driven-dev/framework --path cli/.claude/skills/translateManually: put the files in place
.devin/skills/translate/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add ai-driven-dev/framework --skill translate -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.