Skip to main content
skill CX Codex

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

Defines AI assistant and IDE profiles, build contracts, and capability interfaces under src/contexts/tools/ in the framework.

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 tools -a claude-code
Open on GitHub

What tools does

The skill configures target platforms inside src/contexts/tools/. Each supported assistant or editor lives as an AiTool<C> or IdeToolConfig object in profiles/<tool>/profile.ts, where C defines the exact intersection of Has* capability interfaces. Profiles supply target metadata, rewriteContent transformation rules, and build contracts for aidd translate.

Boundary rules are strictly enforced: outside contexts cannot import modules until added to PUBLIC_MODULES in context-boundary.arch.test.ts. Barrel index.ts files are prohibited across the codebase. Moving tool-specific logic outside the profile directory will fail the architecture ratchet tests.

This skill does not execute the canonical-to-native translation pipeline, which belongs to translate. Manifest distribution and install orchestration are handled by separate contexts.

What it helps with

  • Add an AI tool or IDE profile under src/contexts/tools/
  • Configure a ToolBuildContract for aidd translate
  • Define a new Has* capability class in domain/contracts.ts
  • Implement custom rewriteContent logic for a target platform

Example prompts for the agent

  • Add a new IDE profile under src/contexts/tools/ and define its build contract
  • Create a new capability class in domain/capabilities/ with strict readonly parameters
  • Update rewriteContent for the target tool profile in profile.ts

How to install tools

1Skills CLI (Vercel)

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

2Manually: put the files in place

~/.claude/skills/tools/SKILL.md

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

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

Questions about tools

How to install tools in Claude Code?

Run npx skills add ai-driven-dev/framework --skill tools -a claude-code. The skill file is placed in ~/.claude/skills/tools/SKILL.md.

What does the tools skill do?

It configures how target AI tools and IDEs are modeled inside the framework repository. It manages tool profiles, capability classes, and build contracts.

When should you avoid using the tools skill?

Do not use it to run translation pipelines, distribute plugins, or orchestrate installations. Those concerns are delegated to translate, distribution, and framework.

Source text

SKILL.md · MIT
---
name: tools
description: >
  Defines or modifies what the project targets, under src/contexts/tools/ — an AI/IDE tool
  profile, its build contract, the content-translation capability classes it composes
  (agents/skills/commands/rules/hooks), and its own native-plugin adapter. Use when adding a new
  AI or IDE tool, changing a tool's Has* capability intersection, adding or modifying a
  capability class, or declaring a tool's `aidd translate` build contract. Do NOT use for the
  canonical-to-native translation pipeline itself — use `translate`. Do NOT use for where plugin
  content comes from — use `distribution`. Do NOT use for manifest or install orchestration — use
  `framework`.
---

# Tools

`tools` is what the project targets and how each target is configured. Every AI assistant and
IDE the CLI supports is one `AiTool<C>` or `IdeToolConfig` object in
`contexts/tools/domain/profiles/<tool>/profile.ts`, where `C` is the intersection of `Has*`
capability interfaces the tool actually supports. `translate` depends on `tools` (never the
reverse) to call the tool's own `rewriteContent` and to read its build contract — a tool profile
is data and behavior the rest of the CLI is handed, not a place that reaches out to fetch or
install anything itself.

## What goes in

| Concept | Location |
|---|---|
| A tool's identity, capabilities, content-rewrite | `domain/profiles/<tool>/profile.ts` |
| A tool's `aidd translate` build behavior | `domain/profiles/<tool>/build.ts` (only if the tool is a build target) |
| A string transform used by exactly one profile | that profile's own directory |
| A string transform shared by ≥2 profiles | `domain/formats/` |
| A content-translation capability class (agents/skills/commands/rules/hooks) | `domain/capabilities/` + a `Has*` entry in `contracts.ts` |
| Catalog/manifest shaping shared by ≥2 tools' build contracts | `domain/marketplace-catalog.ts` |
| A port only `tools` needs | `domain/ports/` |
| A tool's own plugin-CLI driver | `infrastructure/` |

## How

- `AiTool<C>` fields: read `domain/contracts.ts`. A list copied here aged at every field.
- `Has*` interfaces live in `contracts.ts`, always `readonly`, never optional —
  a tool either includes `Has<Name>` in its `C` intersection or does not have the field at all.
  Guard presence with `"name" in tool.capabilities`, never `instanceof`.
- `rewriteContent(content)` is one way, per tool, with no reverse and no shared base helper.
  See `references/content-rewrite.md`.
- A capability class ends in `Capability`, takes one params object, all fields `readonly`, throws
  `CapabilityConfigError` (from `kernel/errors.ts`) on an invalid combination, carries no
  application/infrastructure imports. See `references/capability-conventions.md`.
- `PluginsCapability` has three modes (`native`, `flat`, `unsupported`) and a `translationMode`
  (`marketplace` | `flat` | `null`) — see `references/plugins-capability.md`.
- Build behavior is ONE artifact-symmetric `ToolBuildContract` per tool, read by the two
  mode-generic orchestrators (`MarketplaceBuildStrategy`, `FlatBuildStrategy`) in `translate` —
  never a per-tool strategy class, never a per-tool or per-artifact-kind branch in an
  orchestrator. See `references/build-contract.md`.
- `registerTool(config)` is called once, at the bottom of `profile.ts`, never from a use-case.
- Follow the port/adapter rule in `.claude/rules/00-architecture/` for the shape of a port and
  its adapter, and the shared-module rule there before promoting a helper out of a single profile.

## Public surface

Nothing outside `contexts/tools/` may import a module this context has not declared public —
`tests/architecture/context-boundary.arch.test.ts` holds the list (`PUBLIC_MODULES.tools`). A new
module is invisible to `translate` and `framework` until it is added there; there is no
`index.ts` and there never will be (barrels are forbidden by the export rule in
`.claude/rules/01-standards/`).

## How it's tested

- `tests/contexts/tools/` mirrors `src/contexts/tools/` — one profile's `profile.ts`/`build.ts`
  gets a unit test asserting the `AiTool<C>` type is satisfied and each rewrite rule holds.
- `tests/architecture/tool-addition-cost.arch.test.ts` ratchets how many files outside a new
  tool's own directory must change to add it — keep new tool-specific logic inside the profile.
- See the `test` skill for tier conventions; capability/format round-trip tests are unit-tier.

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

Similar skills

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

tools by other authors comes first.

tools assistant-ui tools is a Claude Code skill for defining model-callable tools and rendering their calls in assistant-ui. It covers cases where a tool is not invoked, its UI fails to render, or its result never reaches the model. CX Codex +1 6,600installs tools launchdarkly tools is a Claude Code and Codex skill that creates tool definitions and links them to LaunchDarkly config variations. It guides setup through a remote MCP server. CX Codex +1 1,900installs tools finom Turns Vovk.ts procedures into an LLM tool array via deriveTools(). CX Codex +1 ★ 57repo stars k-skill-cleaner NomaDamas k-skill-cleaner analyzes coding-agent skill trigger counts and interviews the developer to recommend unused K-skills for removal. CX Codex +1 11,500installs codex-delegate amElnagdy The codex-delegate Claude Code skill sends bounded coding work to the OpenAI Codex CLI in the background. The orchestrator then checks the diff, reruns project gates, and lands the change. CX Codex +1 8,400installs printing-press-output-review mvanhorn printing-press-output-review — an internal reviewer skill for printed CLIs. It catches plausibility bugs in command output that rule-based checks and live verification miss. CX Codex +1 6,700installs stripe-directory stripe stripe-directory is a Claude Code skill that finds providers and organizations and their documented engagement paths. It runs before web search to choose a service, pay, or arrange an integration. CX Codex +1 4,400installs 10x-cli-guide przeprogramowani 10x-cli-guide guides 10xDevs CLI skill downloads, updates, and use. It also handles helper channels, tool profiles, course content, and CLI conflicts. CX Codex +1 3,200installs parallel-memory parallel parallel-memory — a skill that pulls past Parallel Task, Monitor and FindAll runs out of memory when they can help, and removes them on request. CX Codex +1 2,900installs

From the same set80

The whole set →
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 translate 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. 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 aidd-telemetry aidd-telemetry is a plugin for Claude Code that tracks token use in Claude Code and Codex sessions, grouped by task, model, or other dimensions. Records stay local. CX Codex +1 ★ 571repo stars

Project sponsors

Companies that keep this analytics open