I use two laptops and five different local agent tools across them (Hermes, Claude Code, Codex, Pi, and Agents).
I wanted a dead-simple way to keep my custom skills synced across all of them:
- keep one git repo at
~/code/skillson both laptops - have all 5 agent runtimes read my custom skills from there
- run a cron job in Hermes on both laptops to keep it synced
- don’t accidentally commit pre-installed/built-in vendor skills into my personal repo
Simple problem, right? Should be like 20 lines of shell or a tiny skill file.
Instead, I made the mistake of asking an agent to “design and implement the skill sync setup” without locking down every single detail first.
How the agent overengineered it into a monster
Because I left a few small questions open in my prompt, the agent decided to build an entire distributed sync engine to cover every possible edge case it could imagine:
- “What if a runtime doesn’t follow symlinks?” -> wrote custom copy/sync logic
- “What if a local edit conflicts with remote?” -> invented a backup/staging state model
- “How do we tell user skills apart from vendor-bundled skills?” -> wrote a complex classifier script
- “What if the cron job fails partway?” -> added state files, manifests, and recovery hooks
None of those decisions were “wrong” individually, the model was just trying to make sure its script wouldn’t fail on any edge case. Put together, it turned a 5-line git pull + symlink job into hundreds of lines of brittle sync machinery that I would hate debugging 6 months from now.
The one part the agent actually got right: mtime clustering
Out of all the stuff the agent came up with, one idea was actually clever.
Some agent tools dump their built-in vendor skills into the exact same directory where you put your custom skills. How do you know which folders are yours vs bundled skills installed with the tool?
Look at the SKILL.md modification timestamps (mtime):
- Bundled vendor skills all get created at the exact same second when you install/update the tool (one tight timestamp cluster).
- Custom skills you wrote yourself have timestamps spread out over days/weeks after that.
And instead of baking that into a black-box Python script, it works way better as a plain-English rule for the agent running the sync: check the mtime clusters, treat clearly newer ones as user-authored, and if anything looks ambiguous, stop and ask me instead of auto-committing it.
Write the workflow in plain English first
I threw out all the generated sync scripts and replaced the whole thing with a short plain-English SKILL.md file: sync-local-skills-to-github.
The rules in that file are literally just:
~/code/skillsis the single source of truth on both laptops.- Local agent skill folders are install targets.
- Update already-tracked skills when the local copy is newer.
- Use
SKILL.mdtimestamps (mtime) to spot new custom skills vs bundled catalog skills. - Never auto-push an ambiguous local skill - ask first.
- Never patch runtime code or add wrapper scripts without asking.
Whenever you give an agent an infra/tooling task with missing details, its default instinct is to write more code and invent architecture to cover the ambiguity. Tell it upfront: when something is ambiguous, ask me - don’t build a subsystem for it.
Related: high thinking budgets make agents harder to control.