# cc-use-exp keeps six AI coding tools in sync from one repository, and its one-click installers pipe a script straight from main

> A layered configuration system that copies rules, skills and workflows into the user level directories of Claude Code, Codex, Gemini, Antigravity, Cursor and Copilot, offered through a plugin marketplace, four shell installers, or a checked out sync script, with new development moved to a paid successor project.

**doccker/cc-use-exp** — ⛔ No longer maintained → dev-agent-kit/recipes  让 Claude Code、Antigravity、Gemini CLI、Codex、Cursor 开箱即用的分层配置模板，总结十多年的日常开发经验

- Repository: https://github.com/doccker/cc-use-exp
- Website: https://github.com/dev-agent-kit/recipes.git
- Stars: 1,061 · Forks: 116
- Language: Python
- License: NOASSERTION
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/doccker-cc-use-exp

## The homepage field points at a different repository

The project's own notice says this repository has stopped updating and that all new capability has moved to dev-agent-kit/recipes, with new features shipping only there. The stated reason, in the Chinese text, is repeated copyright and license violations against the open source work, and the English paragraph of the same notice gives it as repeated license violations. Existing content is stated to remain available.

The move is visible in the metadata as well as the text. The repository's homepage field is set to the git URL of dev-agent-kit/recipes rather than to this project, and the description carries the same destination. A reader arriving through the repository page is told twice, in the file and in the sidebar, that the work continues somewhere else.

The commit record has not caught up with the notice. Three tagged releases exist, v1.0.38, v1.0.39 and v1.0.40, the last published on 2026-06-30, and the default branch was last pushed on 2026-08-26. The repository is not archived, so nothing here is technically frozen by the platform, only by the announcement.

Access to the successor is not open in the same way. The notice describes a paid group at a one-time price of 699 yuan, stated in the English paragraph as about 99 dollars, with lifetime updates and a private technical group, a WeChat contact and an email address for international users.

## One-click installers execute whatever is on main, while releases are tagged

Four of the six tools are installed by piping a remote script into bash. Codex has a shell path, and Gemini, Antigravity and Cursor each have one:

```bash
bash <(curl -sL https://raw.githubusercontent.com/doccker/cc-use-exp/main/tools/install-codex.sh)
```

The URL points at the main branch, not at a tag, and the script goes straight to bash with no checksum, no signature and no review step. The repository publishes versioned releases, v1.0.40 being the newest, and the installers do not use them. Anyone who runs that line twice on two machines a week apart can get two different configurations.

The alternative path is a clone and a script from the working tree:

```bash
git clone https://github.com/doccker/cc-use-exp.git
cd cc-use-exp
./tools/sync-config.sh
```

There is a Windows counterpart, a batch file, for the same job. That path is the reproducible one, because what runs is the commit you checked out rather than the current head of a branch.

For Codex there is also an in-session option, a skill installer command run from inside a Codex session, where updating means running the same command again. Two update models therefore coexist: re-run a command for Codex and Gemini, Cursor and Copilot, re-run a marketplace command for Claude Code.

## Two install methods for Claude Code, and only one of them is cross-tool

Claude Code is installed through its plugin marketplace, from inside a session:

```bash
/plugin marketplace add doccker/cc-use-exp
/plugin install cc-use-exp@cc-use-exp
```

Updating uses `/plugin update cc-use-exp@cc-use-exp`, which is a version-aware operation rather than a re-fetch from a branch.

A second method, `/skill-install`, performs a fuller sync, with `/skill-update` to refresh it. The difference is spelled out in a comparison table: the marketplace method needs no prerequisite and installs skills plus commands only, while the fuller sync requires the marketplace method first, adds rules and templates, and is the one that works across tools, including Gemini, Codex and Cursor. The marketplace route is Claude Code only.

So a cross-tool setup means running two commands in Claude Code and then running each other tool's own installer as well. The layering is deliberate rather than accidental, but it means a full configuration across six tools is six separate operations, each with its own update command and its own failure mode.

## Fourteen path mappings write into your home directory

The sync table is the part to read before running anything, because it enumerates where files land in a user account. The Claude Code directory goes to `~/.claude/`. The Antigravity templates go to `~/.gemini/config/` as the global configuration, while the older Gemini layout goes to `~/.gemini/`. For Codex, `global/AGENTS.md` is merged as a managed block into `~/.codex/AGENTS.md`, with separate handling for rules, instructions, skills and per-profile TOML files. Cursor gets skills, templates, a commands compatibility layer that maps command files into skill directories, and rules copied for compatibility. Copilot receives `copilot-instructions.md` and instruction files, and a local `AGENTS.md` in the repository, if one exists, is mapped to `~/.github/AGENTS.md`.

Two entries in that list are worth calling out. The Codex merge is described as a managed block merge rather than a copy, which implies the tool edits a marked region inside a file you also own. And the Cursor rules entry says the in-project `.cursor/rules/` path remains the primary one, so the user level copy exists for compatibility rather than as the source of truth.

Running the sync therefore touches six user level trees in one operation. The script is the same for all of them, so a mistake in one tool's layout is a mistake in everyone's account.

## Codex is deployed incrementally, and every other tool gets its own preservation list

Codex gets the most careful description. The deployment is incremental: it does not overwrite `~/.codex/` as a whole, and it does not touch `auth.json`, `history.jsonl`, logs, sqlite files or caches. It maintains only the managed `AGENTS` block, the managed profile files, rules, instructions and skills, and it does not change an existing default model, provider or `base_url`.

The other tools are described in the same paragraph with their own lists, and those lists differ. Claude Code keeps historical conversations and personal settings. Gemini keeps authentication such as `oauth_creds.json` along with runtime data. Cursor keeps settings, extensions and cache. Antigravity gets project templates copied into the global Gemini configuration directory, with a note that the project's own configuration source has been isolated into a separate directory to avoid conflicts.

Read together, this is four separate preservation policies written out by hand rather than one mechanism with a test. That is normal for shell installers, and it is also the part most likely to go stale: a tool that renames a runtime file turns one of these sentences into a claim that is no longer true, and nothing in the repository would catch it.

## One authoritative skill directory and a one-way sync with five flags

Skills have a single source of truth. The authoritative version is written in `.claude/skills/`, then `tools/sync-skill.sh` pushes it to Antigravity, Gemini, Cursor, Codex and Copilot. The script exposes five documented invocations:

```bash
./tools/sync-skill.sh                       # 同步全部 Claude skill 到 6 个目标平台
./tools/sync-skill.sh redis-safety          # 只同步指定 skill
./tools/sync-skill.sh --target codex        # 只同步到指定平台
./tools/sync-skill.sh --dry-run             # 仅打印计划，不实际操作
./tools/sync-skill.sh --force               # 覆盖已存在的 skill（默认跳过）
```

The comments are in Chinese, as is the rest of this document apart from one English paragraph in the migration notice. Sync all, sync one named skill, sync one target platform, print the plan without touching anything, and overwrite what is already there, which the last line says is not the default.

Two properties of the design follow. The direction is one way, so a skill edited in the Cursor directory is not carried back to Claude, and the default on a collision is to skip rather than to reconcile. A per-platform adaptation table follows, where Antigravity is handled by a direct copy plus cleanup of redundant frontmatter; the Gemini row is where this description ends.

## Layered loading is the design claim: rules resident, skills on demand, workflows called

The stated design is not a prompt collection but a maintainable configuration system, and the loading model is what makes that claim concrete. Rules stay resident, skills load when needed, and workflows are invoked explicitly, with the stated purpose of reducing the resident context burden.

That is a real trade, not a free win. Rules that are always loaded cost context on every session whether or not they are relevant, while skills that load on demand need a trigger good enough to find them. The project pairs the two with defensive rules intended to catch what it calls common failures: modifying tests to fit a bug, dangerous commands, and excessive refactoring.

The longest part of the document is about one specific class of those failures, and it is more concrete than the rest. It describes interface contract drift between front end and back end: a list endpoint returning an array while the front end reads a paginated object, a filter options endpoint returning an empty array while the list data plainly contains that state, and a list that has been fixed while the detail endpoint or the status options endpoint still answers in a different shape. The stated root cause is usually not insufficient front end tolerance but a back end that does not follow one unified success response format.

The proposed remedy is split three ways: a global principle to check the interface contract first when integration misbehaves, a dedicated skill named `cc-api-contract-safety` to inspect the success response wrapper, the pagination structure, where filter options come from and when temporary compatibility should be removed, and workflow persistence so the contract check and the cleanup condition are recorded in the task template instead of being forgotten after a temporary fix.

## Conclusion

This repository suits someone already running one of these six tools who wants a single place to keep conventions, and who prefers checking out a clone over piping a remote script into a shell. Three things decide it. Development has stopped here and moved to a paid successor, so treat what remains as a frozen snapshot. The one-click paths execute whatever sits on the main branch at that moment rather than a tagged release, so the manual clone path is the one that is reproducible. And the sync writes into six user level directories at once, so read the path table before running it.

## FAQ

### Is cc-use-exp still being updated?

The project's notice says this repository has stopped updating, that existing content remains available, and that all new development has moved to dev-agent-kit/recipes. The last tagged release was v1.0.40 on 2026-06-30 and the default branch was last pushed on 2026-08-26, though the repository itself is not archived. Access to the successor is described as a paid membership.

### What is cc-use-exp actually for?

It is a layered configuration system for AI coding assistants rather than a collection of prompts. Rules stay resident, skills load on demand and workflows are invoked explicitly to keep the resident context small, and the same set is synced into the user level directories of Claude Code, Codex, Gemini, Antigravity, Cursor and GitHub Copilot.

### How do I install cc-use-exp for Claude Code?

From a Claude Code session, run `/plugin marketplace add doccker/cc-use-exp` and then `/plugin install cc-use-exp@cc-use-exp`, updating with `/plugin update cc-use-exp@cc-use-exp`. That method installs skills and commands only and is Claude Code only. The fuller `/skill-install` command additionally syncs rules and templates and is the route that works across Gemini, Codex and Cursor.

### What does the cc-use-exp sync script change in my home directory?

It writes into six user level trees, including `~/.claude/`, `~/.gemini/`, `~/.gemini/config/`, `~/.codex/`, `~/.agents/skills/`, `~/.cursor/` and `~/.github/`. For Codex the deployment is incremental: it does not overwrite `~/.codex/` wholesale, leaves `auth.json`, `history.jsonl`, logs, sqlite and cache alone, and does not change an existing default model, provider or `base_url`.

### How do I update a skill across all six tools in cc-use-exp?

Write the authoritative version in `.claude/skills/` and run `./tools/sync-skill.sh`, which pushes to Antigravity, Gemini, Cursor, Codex and Copilot. It takes a skill name to sync one, a `--target` to sync one platform, `--dry-run` to print the plan without acting, and `--force` to overwrite an existing skill, since the default is to skip.

### What does cc switch have to do with cc-use-exp?

Nothing in this repository mentions cc switch. cc-use-exp is a configuration template set for AI coding CLIs and IDEs, covering Claude Code, Antigravity, Gemini CLI, Codex, Cursor and GitHub Copilot, and it contains no component named cc switch. The two names appear together only because both are associated with the same assistant tooling ecosystem.

## Sources

- [doccker/cc-use-exp on GitHub](https://github.com/doccker/cc-use-exp)
- [Issues](https://github.com/doccker/cc-use-exp/issues)
- [Project website](https://github.com/dev-agent-kit/recipes.git)
- [README](https://github.com/doccker/cc-use-exp/blob/main/README.md)
- [Releases](https://github.com/doccker/cc-use-exp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/doccker-cc-use-exp