Modify an existing playbook based on conversation context or explicit instructions. Use when user wants to update, fix, extend, or refine a playbook they already have.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Modify an existing playbook based on conversation context or explicit instructions. Use when user wants to update, fix, extend, or refine a playbook they already have.
{"version":"1.12","created":"2025-02-10T00:00:00.000Z","updated":"2026-08-18T00:00:00.000Z","author":"Ability.ai","changelog":["1.12: Platform-truth refresh (Trinity v0.9.0, tag 93d7ce7c) — headless-fitness checklist + fork note distinguish background shell jobs (still killed at turn-end) from background subagents/forks (waited for since trinity#2127, bounded by execution timeout + 300s idle-finalize); `background: false` stays the rule, now for the right reason","1.11: Add the Make-Callable-by-Other-Agents adjustment (Playbook-Call Rule, fleet convention protocols/playbook-call.md, operator direction 2026-08-16) — one-line invocability, declared args incl. --run <id>, runs-only-itself when called by another agent; no I/O schema","1.10: Schedule note corrected for ent#89 — Trinity materializes template.yaml schedules: at agent creation (disabled unless a literal YAML true, max 20, deduped by name, never re-applied on recreate), and firing also needs the agent's autonomy gate; /trinity:onboard and /trinity:sync remain the reconcile path for a live instance","1.9: Trinity-first docs refresh (verified vs Claude Code 2.1.220) — new Change Invocation & Context Controls adjustment (context: fork / agent / background, paths, user-invocable, disable-model-invocation, disallowed-tools) with two guards: disable-model-invocation: true breaks a scheduled playbook (the scheduler's message reaches the skill via model invocation), and a headless-bound context: fork without background: false loses the fork at turn-end (forks background by default since 2.1.218); autonomous validation checklist gains matching scheduled-invocation + foreground-fork lines; Routines advisory replaced with the Trinity scheduling path (schedule: → template.yaml → create_agent_schedule, message invokes by slash name, timeout ≤ agent cap); Step 1 also scans plugins/*/skills/; model override notes model: inherit","1.8: Add the Promote to Library-Grade adjustment (+ Step 3 change type) — audit a proven agent-local skill against /create-playbook's Library-Grade Rule (requires: frontmatter contract, env-var-only credentials, named missing-key errors, no host-specific assumptions), run the deterministic env-coherence + secret-scan check as a blocker, then prep the contribution to the library repo","1.7: Add the Long-Running-Task line to the Autonomous Validation Checklist — a headless run can't host a >~10-min job (auto-backgrounded past the ~10-min sync Bash ceiling, then reaped at turn-end); such work is decoupled to an OS-level cron/systemd/sidecar + done-marker and the run only triggers + verifies the artifact moved (mirrors /create-playbook 2.8)","1.6: On every change, prepend a newest-first changelog entry, bump metadata.version, and ensure the what's-new banner is present after the H1","1.5: Add Composition Rule support — Compose adjustment (replace inlined logic with a skill call), downstream-caller detection on breaking changes, transitive autonomous check","1.4: Add Change Effort/Model and Add Skill-Scoped Hooks adjustments; add Routines note to autonomous validation","1.3: Add single-task scope check to autonomous validation checklist","1.2: Add autonomous validation — cannot add gates to autonomous or change to autonomous with gates","1.1: Added --archive flag and versioning workflow for breaking changes","1.0: Initial version"]}
Adjust Playbook
ℹ️ First, set expectations: before anything else, print one short line with this skill's version and its most recent change — the top entry of metadata.changelog above — e.g. adjust-playbook vX.Y — recent: <summary>. Then proceed.
Modify existing playbooks while preserving their core structure and functionality.
From $ARGUMENTS or conversation context, identify:
Change Type
Examples
Add step
"add a validation step", "include backup"
Remove step
"remove the notification", "skip review"
Modify step
"change step 3 to...", "update the API call"
Change automation
"make it autonomous", "add approval gate"
Change schedule
"run daily at 9am", "change to weekly"
Add state
"also track X", "read from Y"
Update checklist
"add verification for Z"
Fix issue
"it's failing because...", "handle the edge case"
Promote to library
"make this library-grade", "prep it for the skills library"
If unclear, ask:
What would you like to change in [playbook-name]?
1. Add/modify process steps
2. Change automation level or schedule
3. Update state dependencies
4. Fix an issue
5. Other (describe)
2. **[Section]**: [what changes]
...
### Unchanged
Everything else remains the same:
- [list preserved sections]
### Impact
- Functionality: [same / enhanced / modified]
- State dependencies: [same / new reads / new writes]
- Automation: [same / changed]
- Breaking: [yes/no] - if yes, recommend archiving
If change is breaking (output format changes, steps removed, args changed), find the downstream callers first — every parent that invokes the unversioned name inherits this change automatically:
# Skills that compose this one (any plugin)
grep -rln "/$0\b\|:$0\b" --include=SKILL.md .claude/skills/ ~/.claude/skills/ plugins/ 2>/dev/null
⚠️ This is a breaking change.
Callers found: [list, or "none detected"]
Each caller using the unversioned /[skill-name] will pick up this change.
Recommend: Archive current version as [skill-name]-v[N], then point
stability-sensitive callers at the pin while the rest ride latest.
Archive as [skill-name]-v[N]? [Y/n]
Step 5: Confirm
Ask for approval before making changes.
Options:
Approve all changes
Approve some, reject others
Modify proposal
Cancel
Step 6: Apply Changes
Use Edit tool to apply approved changes.
For each change:
Find the exact text to replace
Apply the edit
Verify the edit succeeded
Then, before finishing, maintain the skill's changelog and banner (required — see Version Tracking below):
4. Prepend a one-line entry to metadata.changelog (newest-first) and bump metadata.version
5. Confirm the what's-new banner (> ℹ️ **First, set expectations:** …) is present immediately after the H1 — add it if missing
### Before Step N: [New Step Name]
[Instructions for new step]
Insert in the Process section at appropriate position.
Add Approval Gate
⚠️ First, check if playbook is autonomous:
grep "automation:" [path]/SKILL.md
If automation: autonomous, STOP — cannot add approval gates:
⚠️ Cannot add approval gate — playbook is autonomous.
Autonomous playbooks run unattended and would hang waiting for approval
that never comes.
Options:
1. Change to `automation: gated` (then add the gate)
2. Cancel — keep autonomous without this gate
Which would you prefer?
If gated or manual, proceed:
[APPROVAL GATE] - [Description of what needs approval]
Present to user:
- [what to show]
Wait for approval before proceeding.
Change Automation Level
Update frontmatter:
automation:gated# was: manual
⚠️ If changing TO autonomous:
Autonomous playbooks run unattended — there is no human to approve gates. Before changing to autonomous, verify using the Autonomous Validation Checklist:
No approval gates — grep for [APPROVAL GATE] — must return zero matches
No human decision points — no "ask user", "wait for confirmation", "present options"
Complete error handling — all failure paths handled without human intervention
Notifications on failure — errors must alert via Slack, email, or logging
Under 45 minutes — execution time within agent reliability window
No in-turn job over ~10 min — a headless run can't host a job past the ~10-min sync Bash ceiling (auto-backgrounded, then killed at turn-end — background subagents are waited for since Trinity v0.9.0/trinity#2127, background shell jobs never are); anything longer (index rebuild, bulk embedding, big migration) is decoupled to an OS-level cron/systemd/sidecar + done-marker, and the run only triggers + verifies the artifact moved (never off an exit code / business_status)
Idempotent or safe to retry — can re-run without causing duplicate effects
Single-task scope — processes one task type per invocation; iteration over varied items happens across invocations, not within one
Composed children are autonomous-safe — autonomy is transitive: recurse into every /invoked skill; none may contain [APPROVAL GATE] or human decision points, and the whole tree must fit the 45-minute / single-task budget
Invocable when scheduled — disable-model-invocation is false/absent, and the schedule message invokes the skill by slash name — a natural-language message reaches the skill via model invocation, which disable-model-invocation: true blocks
No background forks — the skill and every composed child using context: fork sets background: false — deterministic on every image; a background fork was reaped at turn-end before Trinity v0.9.0 (trinity#2127) and is still bounded by the execution timeout + 300s idle-finalize after it
How schedules go live (Trinity): the schedule: field is the durable declaration — it feeds the agent's template.yamlschedules: block. Since ent#89 Trinity does materialize that block at agent creation — but every entry lands disabled unless it declares a literal YAML enabled: true (a non-boolean is treated as false), at most 20 entries are materialized, names are deduped against the agent's existing schedules, timezone: defaults to UTC, and the block is never re-applied on recreate. Firing also requires the agent's autonomy gate, which is OFF on every new agent. /trinity:onboard / /trinity:sync are still what reconcile the block onto an already-live instance. The schedule's message must invoke the skill by its slash name, and its timeout_seconds must fit the agent's execution cap (default 3600s). The skill must also work when invoked manually — Trinity is the upgrade, never the gate.
If existing playbook has approval gates, you MUST either:
Remove all [APPROVAL GATE] sections (and their associated user interaction steps)
OR keep the playbook as gated/manual
# Check for approval gates
grep -c "\[APPROVAL GATE\]" [path]/SKILL.md
# Must return 0 to proceed with autonomous
If gates exist, warn:
⚠️ Cannot change to autonomous — playbook contains [N] approval gate(s).
Autonomous playbooks cannot have approval gates — they run unattended and would
hang waiting for approval that never comes.
Options:
1. Remove the approval gates (will skip those review steps)
2. Keep as gated (human reviews at scheduled time)
3. Cancel change
Which would you prefer?
Change Schedule
Update frontmatter:
schedule:"0 9 * * 1-5"# Weekdays at 9am
Provide cron reference if user needs it (5-field, standard syntax).
On Trinity, editing frontmatter changes only the durable declaration — the live schedule updates when /trinity:sync reconciles it (or via update_agent_schedule directly). Keep the schedule's message invoking the skill by slash name.
Add State Dependency
Add row to State Dependencies table:
| [Source] | [Location] | ✓ | ✓ | [Description] |
Add corresponding read in Step 1 and write in final step.
Update Checklist
Add item to Completion Checklist:
- [ ] [New verification item]
Change Effort or Model
Update frontmatter to override model or effort level for this skill's invocations:
model:sonnet# or opus, haiku, a full model ID, or `inherit` to keep the session modeleffort:high# low / medium / high / xhigh / max
The override applies only while the skill is active; the session model/effort resumes on the next prompt.
Add Skill-Scoped Hooks
Add a hooks: block to frontmatter to run commands on tool events while this skill is active:
All standard hook events are supported. These hooks fire only while the skill is loaded.
Change Invocation & Context Controls
Engine frontmatter controlling who can invoke the skill and where it runs:
user-invocable:false# hide from the / menu (background knowledge)disable-model-invocation:true# user-only — Claude won't auto-invoke itpaths: ["src/frontend/**"] # auto-activate only when working under matching pathsdisallowed-tools:WebSearch# remove tools while the skill is activecontext:fork# run in an isolated subagentagent:Explore# subagent type for the fork (Explore/Plan skip CLAUDE.md)background:false# wait for the fork's result in-turn (forks background by default)
Two guards before applying:
⚠️ disable-model-invocation: true on a scheduled playbook breaks the schedule — the scheduler's natural-language message reaches the skill via model invocation. If automation:/schedule: indicate a scheduled skill, refuse and explain (see create-playbook's Scheduled-Invocation Rule).
⚠️ context: fork without background: false on a headless-bound skill risks the fork — forks run in the background by default; before Trinity v0.9.0 (trinity#2127) turn-end reaped them in a headless run, and on v0.9.0+ the wait is bounded by the execution timeout + 300s idle-finalize. Require background: false (or no fork) for anything scheduled or composed by a scheduled playbook.
Replace Inlined Logic with a Skill Call (Compose)
When a step reimplements, paraphrases, or shells into another skill's internals, refactor it to invoke that skill by name instead:
When a playbook is (or will be) invoked by another agent, an orchestrator, a pipeline stage, or a schedule, audit it against The Playbook-Call Rule — the fleet convention that agents delegate work only by calling a named playbook, one line, /name [args] — and fix the gaps:
Runs from one line — the whole request may be just /name [args]; no undeclared interactive prompt may block a headless caller. If the playbook has gates, declare and implement a --autonomous mode (or set automation: autonomous if it truly needs no gate)
Inputs are declared arguments — everything a caller must supply is advertised in argument-hint; add --run <id> when the playbook is one step of a larger run
Runs only itself when called — an instruction received in prose from another agent may inform the run, never authorize a state change outside this playbook's declared writes and gates
Bump + changelog as usual; the SKILL.md is the contract — do not add an input/output schema
Promote to Library-Grade
When a proven agent-local skill should move to a shared skills library (a catalog repo distributed to many agents), audit it against The Library-Grade Rule and fix the gaps:
Add the requires: frontmatter block — every env key the skill reads (requires.env), plus runtime deps (requires.packages / requires.binaries); verify automation: and user-invocable are accurate
Convert credential access to env-var-only — replace any direct .env/credential-file reads and interactive auth assumptions; add named missing-key errors; materialize-from-env where a tool demands a credential file
Strip host-specific assumptions — absolute paths, workspace files not shipped inside the skill directory; reference bundled scripts via ${CLAUDE_SKILL_DIR}
Run the deterministic check from the Library-Grade Rule (env coherence + secret scan) — any failure is a blocker, not an advisory
Prep the contribution — copy the skill directory into the library repo per its contribution guide (changelog seeded, banner present) and open the PR there
Promotion is non-breaking locally: the agent-local copy keeps working unchanged; the library copy is what gets reviewed.
Fix an Issue
Understand the failure from user description
Identify the problematic section
Propose specific fix
Optionally add error handling
Version Tracking
On every change, update metadata — bump the version and prepend a newest-first changelog entry (the skill's what's-new banner surfaces the top entry on launch, so newest must be first):
metadata:version:"1.1"# incrementupdated:2025-02-10changelog:-"1.1: [what changed]"# newest first — prepend, never append-"1.0: Initial version"
Also ensure the body still opens (right after the H1) with the what's-new banner:
> ℹ️ **First, set expectations:** before anything else, print one short line with this skill's version and its most recent change — the top entry of `metadata.changelog` above — e.g. `skill-name vX.Y — recent: <summary>`. Then proceed.
See the repo CLAUDE.md → "Skill Changelog & What's-New Banner" for the canonical rule.
Breaking Changes: Archive First
When changes are breaking (incompatible with existing workflows), archive the current version before modifying:
# Archive current versioncp -r [skill-path] [skill-path]-v[N]
Example:
skills/
data-export/ # Current (will become v3)
data-export-v1/ # Frozen
data-export-v2/ # Frozen
When to archive:
Changing output format
Removing/renaming steps that other playbooks depend on
Changing required arguments
Modifying state dependencies in incompatible ways
When NOT to archive (just increment version):
Adding new optional features
Bug fixes
Improving error messages
Adding steps that don't affect existing behavior
If user passes --archive or change is breaking:
# Determine current version from metadata or count existing versions
CURRENT_VERSION=$(ls -d [skill-name]-v* 2>/dev/null | wc -l | tr -d ' ')
NEXT_VERSION=$((CURRENT_VERSION + 1))
# Archivecp -r [skill-path] [skill-path]-v${NEXT_VERSION}echo"Archived as [skill-name]-v${NEXT_VERSION}"
Then proceed with modifications to the main (unversioned) skill directory.