Every developer who uses more than one AI coding tool knows the same frustration: you teach Claude Code your workflow once, then you teach Codex the same workflow again, and again in every new project. Peter Steinberger's open source repo agent-scripts solves that problem with an old, boring, reliable idea: keep one canonical copy of your agent setup, and symlink it everywhere it needs to be.
Key Takeaways
>
Agent-scripts is one developer's published system for sharing agent instructions, reusable skills, and helper scripts across Claude Code and Codex.
Its `scripts/sync-skills` script builds a per-machine mirror: whole-root links for Codex, a flat per-skill mirror for Claude Code, and shared `AGENTS.MD` pointers for both.
The repo has 7,408 stars and 646 forks on GitHub as of October 26, 2026, and is MIT licensed.
It is a personal setup made public, not a packaged installer: you clone it, run the sync script on each machine, and keep the repo as the canonical source.
The timing is good, because Agent Skills became an open standard in October 2026, with more than 70 platforms integrating it.
The problem: every agent wants its own copy
Claude Code and Codex do not read skills from the same place. Claude Code loads skills from `~/.claude/skills/<name>/SKILL.md`, exactly one level deep, while Codex scans nested directories under its own skills root, as Convika's comparison documents. Both tools auto-invoke a skill when a request matches its description, but a skill that lives in only one tool's folder is invisible to the other.
The usual fixes are all bad in the same way. Copying a skill into each folder creates copies that drift apart. Rewriting the same rules per project means every improvement has to be applied many times. And a shared document that no tool actually loads is just a note, not a workflow. As CodeWithYog put it in an October 2026 write-up of the repo, the real problem is "teaching the agent the same things again and again" across Codex and Claude Code (Medium).
What agent-scripts actually contains
The repo describes itself on GitHub as "Scripts for agents, shared between my repositories." Its README calls it the canonical place for four things:
`AGENTS.MD`: shared hard rules for Codex and Claude style agents.
`skills/`: reusable workflow skills, each with a `SKILL.md` file carrying YAML front matter with a name and a short, generic description.
`scripts/`: dependency-light helpers used across projects.
`hooks/`: local guardrails, such as skill validation.
That list matters because it shows the repo is a working setup, not a demo. The skills are the main routing layer: a short description decides when an agent loads a skill, and the body stays terse and operational. Public OpenClaw shared skills and repo-owned skills are exposed through tracked relative symlinks, so the canonical copy stays in its own repo. The currently symlinked repo-owned skills named in the README include `birdclaw`, `discrawl`, `gog`, `imsg`, `peekaboo`, `slacrawl`, `wacli`, and `wacrawl`.
Two helper scripts do most of the quiet work. `scripts/sync-skills` builds and maintains the mirrors, and `scripts/validate-skills` checks every `skills/*/SKILL.md` for valid front matter, and can run as a local Git hook. A `docs-list.ts` helper enforces summary metadata on docs, and a `browser-tools.ts` helper wraps Chrome DevTools commands for agent use.
How the sync script bridges two different tools
The core command is `scripts/sync-skills`, and the README stresses that it is idempotent: run it on every machine after cloning or adding skills, and it prints only changes, prunes broken or stale managed links, and never clobbers real files.
For Codex, it creates whole-root links, so Codex sees the full skills tree. For Claude Code, which only scans one level deep, it builds a flat per-skill mirror, with one symlink per skill pointing at the real skill directory. The same script links the shared `AGENTS.MD` to `~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, and `~/.claude/AGENTS.md`, so both tools read the same hard rules. Downstream repos are expected to carry a pointer-style `AGENTS.MD` that reads the shared file, rather than a copy of the rules: "READ ~/Projects/agent-scripts/AGENTS.MD BEFORE ANYTHING (skip if missing)."
When two sources provide a skill with the same name, the script resolves the collision in a fixed order: agent-scripts first, then manager, then codex-local, and it prints the skipped duplicates. That ordering is a design decision worth copying: a shared setup needs a rule for conflicts before conflicts happen, not after.
Aspect | Copying skills per tool | Agent-scripts symlink model |
|---|---|---|
Canonical copy | None, copies drift | One repo, pulled first before syncing |
Claude Code | Manual copy into `~/.claude/skills` | Flat per-skill mirror, one symlink each |
Codex | Manual copy into its skills root | Whole-root links |
Shared rules | Pasted per project | Pointer to one shared `AGENTS.MD` |
Name collisions | Silent overwrite risk | Fixed priority, skipped duplicates printed |
Stale links | Left behind | Pruned by the sync script |
Why this landed at the right moment
Agent-scripts is a personal system, but it sits on a standard that just went open. On October 22, 2026, Anthropic announced it had donated the Agent Skills name, logo, GitHub organization, and agentskills.io domain to the Agentic AI Foundation under the Linux Foundation. The announcement says more than 70 agent platforms, including ChatGPT, Cursor, GitHub Copilot, and VS Code, have integrated Agent Skills, with 1 million skills published and nearly 280 million installed.
That context explains why a repo like this is suddenly useful to more than its author. When skills were a Claude-only feature, a sync script was a personal convenience. When skills are a shared standard, the hard part becomes distribution: getting the same skill, at the same version, into every tool on every machine. A DEV Community guide from October 25, 2026 reaches the same conclusion, recommending one master copy in the shared standard location and symlinks into each agent's folder.
Watch the 30-second repo signal: Sync All Your AI Coding Agents With One Repo.
The honest caveats
Agent-scripts is explicit that it is Peter Steinberger's setup for his own local workspaces, and that honesty sets the right expectations. There is no installer, no hosted dashboard, and no promise that it fits your machine: the README paths assume a `~/Projects` layout, and you run the sync script yourself on each machine. The sync logic also has sharp edges the README documents at length, including a special repair mode for nested self-links in one legacy folder topology. If you adopt it, adopt the discipline too: pull the repo first, keep downstream repos on pointer files, and never hand-edit a mirrored copy.
It is also worth noting what the repo does not claim. It syncs skills and instructions between Claude Code and Codex. It does not make every agent tool in the world read the same configuration, and the wider Agent Skills standard, not this repo, is what other platforms integrate. Treat agent-scripts as a proven pattern with a working reference implementation, not as a universal agent control panel.
Why this pattern matters
The pattern generalizes beyond one developer's dotfiles. Any team that runs more than one agent tool faces the same drift: rules copied into three places, improved in one, stale in two. A canonical repo plus a sync script plus a collision rule is the smallest system that fixes it, and it uses tools every developer already understands: Git for versioning, symlinks for distribution, and a validation script as a guardrail.
For solo developers, it turns "set up my agents" from a recurring chore into a repeatable command. For teams, the same repo can carry shared review checklists, triage skills, and project rules, with every machine converging on the same version after one pull and one sync. That is the real idea inside agent-scripts: skills are only reusable if they are actually shared, and sharing needs a mechanism, not just good intentions.
If you use AI coding agents across tools, the repo is worth reading even if you never run it: steipete/agent-scripts. And if agent-driven auditing is your next step, see how a related skill applies the same "verify, do not just trust" discipline: Cloudflare's Security Audit Skill: Turn Your Coding Agent Into a Relentless Security Auditor.
Read this article in Indonesian: Agent Scripts: Satu Sistem Skill Coding AI untuk Claude Code dan Codex.
FAQ
What is agent-scripts?
It is Peter Steinberger's open source repo of shared agent instructions, reusable skills, and small portable helpers for his local workspaces, published at github.com/steipete/agent-scripts. Its sync script mirrors those skills into Claude Code and Codex.
Which tools does the sync script support?
Claude Code and Codex. Codex gets whole-root skill links, Claude Code gets a flat per-skill mirror, and both get pointers to the same shared `AGENTS.MD` file.
Do I need to install anything?
There is no packaged installer. You clone the repo, run `scripts/sync-skills` on each machine, and re-run it after adding skills or pulling updates. The repo itself is MIT licensed.
What happens if two skills have the same name?
The sync script resolves collisions in a fixed order: agent-scripts wins, then manager, then codex-local. It prints skipped duplicates and prunes broken or stale managed links without overwriting real files.
Is this the same as the Agent Skills standard?
No. Agent Skills is the open standard, donated to the Agentic AI Foundation under the Linux Foundation in October 2026. Agent-scripts is one developer's system built on top of that standard for syncing skills between two specific tools.
How popular is the repo?
It has 7,408 stars, 646 forks, and 706 commits on GitHub as of October 26, 2026. An older third-party figure of around 4,300 stars is stale; the live count is the one to use.