agentleFS
kajisho5kajisho5/video-editing-skill/CLAUDE.md

video-editing-skill

CLAUDE.md12 starsChanged 6 days agoMITView on GitHub

This file has no runtime effect on the Skill. It exists so a session with no memory of prior conversations can pick up maintenance here correctly, without re-deriving decisions already made or re-litigating boundaries already settled. If anything here disagrees with the code, the code and docs/decisions.md win — update this file, don't trust it blindly. A deterministic, execution-only video editing Skill (SKILL.md, README.md). It turns a typed edit request into an operation graph, compiles it to typed calls of…

The file

We split this CLAUDE.md into the rules it gives an agent

2 rules. About 0 are common, 0 are distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Very specific:

    Every push to main runs .github/workflows/release.yml, one job: compute_version.sh decides the version, and only when that tag does not …

    line 66
  2. Very specific:

    Never edit that repo from here — verify compatibility by reading its adapter code and, ideally, running its check_contract() against this …

    line 120

≈ “Common” is an estimate: at least 1 in 5 of the 28,029 CLAUDE.md files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
CLAUDE.md

CLAUDE.md — durable state for whoever (human or Claude session) works on this repo next

This file has no runtime effect on the Skill. It exists so a session with no memory of prior conversations can pick up maintenance here correctly, without re-deriving decisions already made or re-litigating boundaries already settled. If anything here disagrees with the code, the code and docs/decisions.md win — update this file, don't trust it blindly.

What this repo is

A deterministic, execution-only video editing Skill (SKILL.md, README.md). It turns a typed edit request into an operation graph, compiles it to typed calls of an ffmpeg-skill tool, runs it inside a workspace boundary, and validates the result. It holds no editing judgement — what to cut, which camera, why — that belongs to the caller (video-production-agent or anything else). This is ADR-001 and it is the one rule every other decision in this repo defers to.

Source of truth, in order

  1. Code — src/video_editing_skill/. contract.py's skill_contract() is generated from operations.py / errors.py / compiler.py / ffmpeg_skill.py, never maintained beside them.
  2. docs/decisions.md — the ADR log (currently ADR-001 through ADR-036). Read it before changing anything that looks like a design decision; it explains why, not just what.
  3. docs/contract.md — contract versioning rules, pinned vs. additive blocks, drift classification. Read it before touching contract.py's PINNED_BLOCKS or top-level shape.
  4. docs/operations.md, docs/security.md — per-operation reference, security posture.
  5. README.md / SKILL.md — the user/agent-facing docs; contract_check.verify_docs() enforces that every operation type is mentioned in them, so they can't silently drift from code.

Contract discipline (read docs/contract.md and ADR-007 before touching contract.py)

Two independent version axes, both on skill_contract():

  • version (currently "0.8.0") — this package's release version. Free to move on any release.
  • contract_version (currently "7.0") — the version of the pinned shape (PINNED_BLOCKS in contract.py). Bumps only when a pinned block changes in a breaking way. A dependent pins a range against contract_version, never version.

Any change inside PINNED_BLOCKS (schema, skill_id, contract_version, operations, unsupported, errors, execution, capabilities, schemas, plus pinned ToolSpec fields) is breaking: bump contract_version (and version, since this package does not yet release independently of its contract), expect video-production-agent to re-pin, and regenerate the golden copy:

video-editing contract --json > tests/contract/contract.json
video-editing contract --check tests/contract/contract.json   # must report "ok"

New top-level keys or tools[] keys outside the pinned blocks are additive and don't need a version bump — that's how 0.1.0 gained media_compatibility, provides, contract_version itself, and the richer execution report without breaking the one known consumer.

Testing

cd tests && PYTHONPATH=../src python3 -m unittest discover -s . -p "test_*.py" -v

Offline suite (unit / paths / security / engine-contract with a fake engine) needs nothing beyond the standard library. test_integration.py's real-media matrix (scenarios A–O) needs a real ffmpeg-skill checkout reachable via VIDEO_EDITING_FFMPEG_SKILL_DIR / --ffmpeg-skill-dir / a well-known relative path — it's skipped, not failed, when one isn't found, which is normal for a sandboxed session. .github/workflows/tests.yml runs both, matrixed across OS/Python, plus ruff check, mypy, and contract --check.

Releases (ECOSYSTEM_ROADMAP step 6; same pattern as audio-production-skill / qc-skill)

Every push to main runs .github/workflows/release.yml, one job: compute_version.sh decides the version, and only when that tag does not exist yet it bumps pyproject.toml + src/video_editing_skill/__init__.py (bump_version_files.sh), regenerates tests/contract/contract.json, prepends CHANGELOG.md (render_changelog.sh, from git log, never from interpolated PR text), commits chore(release): vX.Y.Z, pushes an annotated tag and creates the GitHub Release (PyPI only if PYPI_API_TOKEN is set). The rule: auto-bump only when pyproject.toml equals the latest tag (patch by default, minor for feature/enhancement, major only for a hand-applied major/breaking label — release-drafter's labels, .github/release-drafter.yml, applied by autolabel.yml); otherwise the version in pyproject.toml is released as written. So the first release (no tag yet) is v<pyproject version> unchanged, and a breaking contract change is released by bumping version / contract_version by hand in its PR. Third-party actions are pinned by commit SHA (tag in a comment), copied from the sibling skills; dependabot (github-actions, pip) keeps them current. tests/test_release_scripts.py checks the version rule on throwaway git repos. Dependabot labels a PR major when its dependency moved a major version, so before release-drafter runs, .github/scripts/dependabot_release_labels.py removes major/breaking/minor/ feature/enhancement from Dependabot PRs unless a person applied the label (tests/test_release_labels.py).

Ecosystem relationships (verify live, never assume — these repos evolve independently)

  • ffmpeg-skill (dependency) — the only FFmpeg boundary. No version window since ADR-013: only a >=0.10.0 floor (ffmpeg_skill.MIN_VERSION, ADR-010's overlay -t bound, behaviour no flag reveals); everything that differs between releases is detected from the installed checkout (flags from _contract.py --json or --help, --quality/--crf, probe bt2020_or_hdr/hdr) or, for fit.py's 0.16.10 canvas rule only, chosen by the release that changed it. Don't reintroduce a ceiling; add a detection. CI runs the real-media suite against ffmpeg-skill 0.11.0 (pinned commit) and main, daily. The history below predates ADR-013. Verified against 0.9.0, 0.9.1, and 0.10.0 as of this writing (full real-media integration matrix green against a live 0.10.0 checkout); re-verify fit.py / join.py / overlay.py geometry and behavior before raising the ceiling. Known real gap, found by live verification against 0.10.0 (not assumed): fit.py still has no --height flag (only --width) and no other script offers single-video resize — RESIZE's height alternative (docs/decisions.md ADR-003) is genuinely blocked on ffmpeg-skill, not a small addition, despite how ADR-003 originally framed it; still blocked, next candidate is contract.versioning.next["0.4.0"]. 0.10.0's fit.py --crop-x/--crop-y (which edge FILL's crop keeps) was mapped into FILL.anchor in 0.2.0 (ADR-009) — verified end-to-end against a real 0.10.0 checkout (different anchors produce different delivered bytes, tests/test_integration.py::test_fill_anchor). ADR-010 separately verified 0.10.0's overlay.py bounds a looped-image composite with an explicit -t instead of -shortest, so OVERLAY no longer refuses an audio-less video input up front. fit.py's --rotate/--flip flags predate this ADR sequence entirely (never evaluated by ADR-002) and were mapped into a new ROTATE operation type in 0.3.0 (ADR-011); this Skill still uses only five ffmpeg-skill tools (probe, cut, join, fit, overlay) — ROTATE is a new type on the already-used fit tool, not a new engine tool. ffmpeg-skill 0.11.0 also shipped a video-layer + chroma-key overlay.py extension and stabilize.py / sequence.py / background.py, none of which are decided here yet — see kajisho5/video-editing-skill#11 items 2 and 3. fit.py's --smooth {none,blend,interpolate} flag (also pre-existing, verified directly against the real checkout) was mapped into an optional SPEED.smooth parameter in 0.4.0 (ADR-012) — again the already-used fit tool, not a new one; it only affects fit.py's own slow-down branch (factor < 1.0), a no-op on a speed-up, exactly as passing it to fit.py directly would be.
  • video-production-agent (consumer) — the only known caller. Its adapter (src/video_agent/tools/video_editing/adapter.py, check_contract()) range-checks version and validates the pinned blocks; it does not (yet) read contract_version. 0.2.0, 0.3.0 and 0.4.0 were all breaking releases (SUPPORTED_SKILL_VERSIONS there needed widening from ("0.1.",) to include "0.2.", then "0.3.", then "0.4.", before it would accept these contracts) — a known, accepted, disclosed consequence of the ADR-009 / ADR-011 / ADR-012 breaking releases, not a bug to fix from here; ADR-010's engine-version bump is additive on top and only affects contract_drift()'s engine key, not check_contract(). Never edit that repo from here — verify compatibility by reading its adapter code and, ideally, running its check_contract() against this repo's live skill_contract() before merging a contract change (see PR #3's description for the pattern).
  • AI-video-production-OS (parent architecture repo) — defines the cross-repository CapabilityContract (provides, contract_version, ...) this repo participates in as one of ten Skills. Its own docs/ROADMAP.md describes an 8-phase rollout; Phases 1–2 (schema + registry
    • per-Skill provides/contract_version retrofit) require zero changes to video-production-agent and are this repo's to do independently. Phase 3 onward (collision resolution, registry-driven execution) is explicitly the agent maintainers' work, not this repo's — do not start it here. Before doing OS-integration work, clone that repo and read docs/SPEC.md, docs/VERSIONING.md, docs/ROADMAP.md, and registry/ directly; don't trust a stale summary of them (including this one, over time).

Explicitly out of scope (do not implement here, ever, regardless of how it's asked for)

AI/LLM-driven editing decisions, automatic editing, a ProductionPlan or Decision Engine, a Context/Inference layer, speaker/scene/slide detection, camera-switching logic, semantic editing, ranking or scoring of edits, cloud execution, an MCP server, a plugin loader, or an arbitrary FFmpeg-argument wrapper. All of these belong to video-production-agent or a different Skill, if anywhere. If a request seems to need one of these, the right move is a typed, narrow OPERATION/CapabilityContract addition here plus the judgement staying in the caller — not an exception to ADR-001.

Status snapshot (update this section, don't let it go stale)

  • PR #1 (merged) — 0.1.0 core: 8 operations, contract, doctor, execution, real-media test matrix.
  • PR #2 (merged) — provides: publishes Capability ids for AI-video-production-OS discovery (ADR-006).
  • PR #3 (merged) — contract_version: independent shape-version axis (ADR-007).
  • PR #4 (merged) — this file: durable maintainer state, previously missing.
  • PR #5 (merged) — dependencies: publishes the ffmpeg-skill version range already enforced at runtime (ADR-008); moved the OS registry's dependency_version_ranges conformance check for this Skill from NOT_IMPLEMENTED to a real PASS.
  • PR #6 (merged) — trivial: kept this file's status snapshot current.
  • PR #7 (merged) — verified ffmpeg-skill 0.10.0 (full real-media matrix, 43/43); corrected ADR-003's RESIZE.height framing (engine-blocked, not a small addition, found live); flagged FILL.anchor as a genuine unblocked candidate. Documentation-only, additive.
  • PR #8 (0.2.0, ADR-009) — FILL.anchor (maps ffmpeg-skill 0.10.0's fit.py --crop-x/--crop-y, verified end-to-end against real media) and outputs[].encoding formalized in request_shape. Breaking by this repo's own convention: version 0.1.0 → 0.2.0, contract_version "1.0" → "2.0". video-production-agent needs its own follow-up to widen SUPPORTED_SKILL_VERSIONS before it accepts this contract — a known, disclosed, explicitly-authorized consequence, not an oversight.
  • PR #9 (ADR-010) — OVERLAY no longer requires audio: ffmpeg-skill 0.10.0 bounds its looped-image composite with an explicit -t instead of the audio-dependent -shortest, verified against real, audio-less footage. SUPPORTED_MIN moves to >=0.10.0,<1.0.0 (additive: engine/dependencies are non-pinned blocks, but video-production-agent's contract_drift() still lists engine, so its vendored snapshot needs the same one-field refresh PR #5/#28/#29 established the pattern for — done in the same change, alongside the SUPPORTED_SKILL_VERSIONS widening PR #8 already needed).
  • PR #10 (open, draft, not part of this line of work) — a separate session's proposed 0.3.0 release for RESIZE.height / CROP / IMAGE_INSERT once ffmpeg-skill shipped typed tools for them (kajisho5/video-editing-skill#11's context describes it as already merged, which was not the case as of this entry — verify its actual state on GitHub before assuming either way). Not addressed by this entry; if it later merges, whichever of it and the entry below lands second needs a version-number rebase, the same situation ADR-010 already had with PR #9.
  • PR #12 (merged, 0.3.0, ADR-011; issue kajisho5/video-editing-skill#11 item 1 only — items 2 and 3 are explicitly out of scope) — a new typed ROTATE operation ({degrees?: 90 | 180 | 270, flip?: h | v}, at least one required), mapped straight onto ffmpeg-skill fit.py's pre-existing --rotate/--flip flags (predates ADR-002 entirely; never evaluated until now). Groups with TRIM/CUT/SPEED/OVERLAY for the odd_frame refusal (it keeps every pixel losslessly) but, unlike them, its target frame can differ from the input's: width, height swap for a 90/270 turn. version 0.2.0 → 0.3.0, contract_version "2.0" → "3.0" (breaking by this repo's own convention: operations and capabilities both gained a key) — video-production-agent needs the same SUPPORTED_SKILL_VERSIONS widening ADR-009 already required. Real-media integration test added (tests/test_integration.py::OperationE2ETests::test_rotate); golden contract regenerated.
  • (this change, 0.4.0, ADR-012; issue kajisho5/video-editing-skill#13) — SPEED gains an optional smooth: blend | interpolate parameter, mapped straight onto ffmpeg-skill fit.py's pre-existing --smooth flag (verified directly against the real checkout: applies only inside fit.py's own factor < 1.0 slow-down branch, a no-op for a speed-up, no interaction with --method/ --max-speed). No new operation type, no new engine tool — SPEED.factor's existing behaviour and validation are unchanged, and omitting smooth compiles to byte-identical argv to before this change. version 0.3.0 → 0.4.0, contract_version "3.0" → "4.0" (breaking by this repo's own convention: operations.SPEED.parameters gained a key, the same shape of change ADR-009's FILL.anchor was) — video-production-agent needs the same SUPPORTED_SKILL_VERSIONS widening ADR-009 / ADR-011 already required. Real-media integration test added (tests/test_integration.py: SPEED with smooth="blend" and smooth="interpolate" against a slow-down factor, asserting distinct output bytes from each other and from the no-smooth baseline); golden contract regenerated.
  • (this change, ADR-013, no version bump: engine / dependencies are non-pinned blocks) — no ffmpeg-skill version window: flags, renamed flags (--crf → --quality), probe's hdr → bt2020_or_hdr, missing fit.py --rotate on 0.10.0 are detected; fit.py's 0.16.10 canvas rule is chosen by release; plan creates and removes the work dir for 1.x+ dry runs. CI integration is a matrix over ffmpeg-skill 0.11.0 (pinned) and main, plus a daily schedule. Upstream defects found and not masked: 0.12.x probe.py deletes an unreadable input; 2.4.1+ join.py leaves a one-frame hole at some plain cuts (test_pipeline_e2e fails on main for that reason, reason: fps).
  • (this change, ADR-014, ECOSYSTEM_ROADMAP.md steps 1–3; no version bump yet, though breaking by convention: operations / unsupported / capabilities changed — the release that ships it bumps version / contract_version and the agent re-pins) — unsupported reasons no longer claim an ffmpeg-skill tool is missing (doctor detects it: unsupported[].engine_tool_status); FREEZE (freeze.py) and REVERSE (reverse.py) are operations on optional engine tools (OPTIONAL_TOOLS: absent → that type MISSING as a doctor note, ok stays true). Real-media tests on a luma-ramp clip; green against ffmpeg-skill 0.11.0 (no freeze.py: FREEZE refused up front) and 2.21.0. Follow-ups: IMAGE_INSERT (roadmap step 4) and the CROP ownership ADR (step 5).
  • (this change, ADR-015, ECOSYSTEM_ROADMAP.md step 4; same unreleased breaking batch as ADR-014) — IMAGE_INSERT {duration, width?, height?, fps? (default 30, always passed)} on one image source → insert.py; its result is an ordinary operation, so CONCAT (and every other type) can take a still. insert is an optional engine tool (absent in 0.10.0): the floor stays 0.10.0. media_compatibility.IMAGE_INSERT.requires.video is false, the first such entry. No Ken Burns (--zoom / --pan) yet. Real-media test green against ffmpeg-skill 2.22.2.
  • (this change, ADR-016, ECOSYSTEM_ROADMAP.md step 5; same convention: breaking, version / contract_version not bumped here, the agent re-pins) — CROP {x, y, width, height} → crop.py, an optional engine tool (absent in 0.10.0). Ownership decided: pixel-rectangle crops are this Skill's (ecosystem.json gives it 尺・画角合わせ); the agent's own video_crop SkillSpec that calls ffmpeg-skill/crop directly is the duplicate to retire on the agent side. Also in the same PR (roadmap step 6): CHANGELOG.md, release workflow (release-drafter + autolabel + tag-based release, as in the sibling skills), dependabot, actions pinned by SHA.
  • (ADR-018, ECOSYSTEM_ROADMAP.md step 8) — options.segment_cache: a frame-precision CUT is cut range by range into <work>/segments/ (content-keyed), joined by join.py --copy; one changed range re-encodes one part. Needs ffmpeg-skill 2.24.0+ (--copy, detected; refused before execution without it). CONCAT's own join is unchanged.
  • (ADR-019, step 9) — TRIM / CUT precision: auto: cut.py lossless mode, --tolerance 0.2; execution.operations[].cuts passes through cut.py's per-cut choice. Boundary-GOP smart render: ADR-031.
  • (ADR-020, step 10) — PUNCH_IN {start, end, scale, subject}: cut / crop / fit / join in turn; window centred on the caller's box, kept in frame. Hard cut only (an ease needs a time-varying crop in ffmpeg-skill).
  • (ADR-021, step 11) — several aspects from one edit is a request graph (shared TRIMs, CROP per shot per aspect, CONCAT per aspect), examples/multi-aspect.json; no new type, no contract change.
  • (ADR-022, step 12) — sources[].ai_generated {generator, licence} (declared): marks: [AI_GENERATED] on every record / output containing it; CONCAT conforms the clip. Engine finding: join.py writes 30000/1001 as 2997/100.
  • (ADR-023, step 13) — CONCAT transition: stinger {stinger, cut_point, cover}: join, overlay --video --place, broll mix + audio --replace; switch on the cut frame. Cover declared (ADR-023), measured since ADR-032 (below).
  • (ADR-024, step 14) — video-editing propose (retakes from word timings: repeat / restart / fragment / filler; en default, ja profile): proposals with reasons only, applied: false; approved ids become CONDENSE segments (step 16).
  • (ADR-025, step 15) — propose static (scenes --shots static shots) / silence (silence --list), combine and / or: labelled span proposals. Edges = the engine's shot boundaries.
  • (ADR-026, step 16) — CONDENSE {segments, rules: {label: cut | keep | {speed}}, default}: cut / fit --duration / join; where approved proposals are applied.
  • (ADR-027, step 17) — CONDENSE output: removed: review file of only the cut spans + condense.review list.
  • (ADR-028, step 18) — outputs[].max_size {mb: 25}: export --max-mb (two-pass), measured, retried into [90 %, 100 %]; unreachable -> OUTPUT_ERROR with the engine's reason; under_floor when the picture needs fewer bits.
  • (ADR-029) — contract_version "4.0" -> "5.0", version 0.5.0 (bumped by hand): ADR-018 .. ADR-028 changed pinned blocks (PUNCH_IN, CONDENSE, precision: auto, stinger; capability_names, request_shape, response_shape) while 0.4.8 .. 0.4.18 kept "4.0". No behaviour change; versioning.next moves to "0.6.0" unchanged.
  • (ADR-031, step 9 completed) — TRIM / CUT precision: smart → ffmpeg-skill 3.2.3+ cut.py --smart: only the partial GOPs at each cut point re-encoded, the rest copied and checked by the engine; cuts.mode / cuts.smart (parts, or reason / reason_code) / cuts.fallbacks. Without --smart (detected) it runs as frame with reason_code: engine_without_smart. Opt-in (default stays frame; auto unchanged). contract_version "5.0" -> "6.0", version 0.6.0 by hand; next -> "0.7.0".
  • (ADR-032, step 13 ticked) — the stinger's frame at its cut point is measured before anything runs: ffmpeg-skill look --at writes it as a PNG with its alpha, alpha.alpha_coverage reads every pixel (stdlib), covered = none under 253/255. Not covered -> INVALID_INPUT stinger_not_covering (details.measured); unreadable -> stinger_cover_unmeasured; missing cut_point / cover -> stinger_no_cut_point / stinger_no_cover. look is an optional engine tool (additive). qc-skill still has no stinger check (handed over). Released as 0.7.0 (#45); contract_version stays "6.0".
  • (ADR-033) — plain CONCAT joins every input at whole frames of its rate, like a stinger CONCAT (one shared path): an input at another rate or variable-rate is conformed first (fit --fps --duration --method trim, nearest frame), a same-rate one whose length is not whole frames is cut (floor); the timeline is built from those lengths; the output rate is validated against the first input's without fps. Reproduced first: 23.976 clips in a 30 fps edit left a one-frame hole (avg 29.977), 30 fps clips in a 23.976 edit drifted 2 ms/clip from the timeline. Residual engine defect (join.py's millisecond lengths, 35-50 round-up clips can still hole) documented, not worked around. Additive; a patch release.
  • (ADR-034) — an xfade CONCAT takes the same whole-frame path (joins_whole_frames is every CONCAT), and its transition is rounded to the nearest frame of the edit's rate (whole_frames.transition, passed as the join's --duration); the timeline overlaps the clips by it. Reproduced first: xfade starts a transition only on a frame, so an offset between frames (0.5 s is 14.985 frames at 29.97 fps; 23.976 clips in a 30 fps edit) started the next clip's picture up to a frame after its sound and the timeline (every join of six 29.97 fps clips, 32-34 ms; the file a frame past the timeline). Residual engine defect: join.py writes xfade offsets to the millisecond, and one that rounds up past its frame (1 in 3 at 30 fps, ~1 in 2 at 29.97, none at 25) starts that transition exactly one frame late; documented, proposed to ffmpeg-skill, not worked around. Additive; a patch release.
  • (ADR-035 / ADR-036, step 19) — the overlay boundary: OVERLAY is plain still compositing; a video in params.image is INVALID_INPUT overlay_video_layer naming motion-graphics-skill video_overlay (was DEPENDENCY_ERROR kind_mismatch). Pinned operations / unsupported text changed: contract_version "6.0" -> "7.0", version 0.8.0 by hand.

Picking the next task

There is no standing task queue; the next gap is found, not assigned. To find it: re-read this file and docs/decisions.md for anything marked planned-but-undone (e.g. contract.versioning.next["0.7.0"] and kajisho5/video-editing-skill#11 items 2 and 3), re-check AI-video-production-OS's docs/ROADMAP.md / docs/ECOSYSTEM_CHANGELOG.md for this Skill's outstanding per-repo items, and re-run contract --check and the test suite to make sure nothing has silently drifted. Prefer small, additive, independently-testable changes that don't touch video-production-agent; anything that would (Phase 3+ of the OS roadmap, a breaking contract change) is a proposal to raise, not a change to push.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.