Conciseness

Bullet-form rules with terse, load-bearing rationales for non-obvious facts ("C# cannot use `with` on an F# record", "F# does not write the nullness of a byref element into the metadata") and no tutorial padding or explanation of concepts Claude already knows. The few explanatory sentences (e.g. why `<Nullable>enable</Nullable>` matters, why `%A` is not AOT-safe) carry project-specific information that cannot be assumed, so this fits anchor 5 rather than 4.

Actionability

Gives copy-paste-ready guidance: the exact .fsproj property block, exact member signatures ("static member TryParse(text, out result, out failure) : bool"), exact attributes ("[<Out; MaybeNullWhen(false)>]"), concrete surface types (IReadOnlyList<T>, ImmutableArray<T>), and an exact review command with output format ("Report each finding as `path:line: rule N: problem. fix.`"). Nothing is pseudocode and the common cases are covered, matching anchor 5; bulk executable examples are appropriately delegated to the verified references/patterns.md.

Workflow Clarity

"Before you start" gives a clear 3-step sequence, and the Review checklist plus Review mode (exact `git diff` command, most-severe-first ordering, defined output format) validate the review path; however the write path has no explicit build/test verification step — validation is only implicit ("A unit test calls `Create` for each literal"). This fits anchor 4 (clear sequence, minor validation gaps) rather than 5, which requires an explicit verify-and-fix loop.

Progressive Disclosure

The body states the rules and delegates all code to references/patterns.md, which exists in the bundle, is exactly one level deep, and is well signaled twice ("Read that file before you write new boundary code" and in Related). No bulk content is inlined that belongs in the reference, and the Related section navigates onward to repo docs — matching anchor 5.

Specificity

It enumerates concrete coverage — "parsed domain types, nullness metadata, TryParse/Create members, Match members for unions, collections, option and null, equality, ToString and AOT safety, and the .fsproj settings" — with no vague or fluffy language. The coverage list is comprehensive for the skill's declared scope, matching anchor 5 rather than 4 (which would require gaps in coverage).

Completeness

The what is explicit ("Rules for F# code that C# calls, and C# code that calls F#, in morphir-dotnet" with the covered topics) and the when is fully explicit with four concrete "Use when..." clauses plus a "Triggers include..." list. This matches anchor 5 (both what and when with concrete trigger phrases), not 4 where the when is only loosely specified.

Trigger Term Quality

Twelve explicit triggers include natural phrases users would say ("F# interop", "call F# from C#", "F# union in C#"), terms a user would paste from compiler output ("MaybeNullWhen", "oblivious"), and synonyms across both language directions plus file-oriented terms ("Nullable enable fsproj"). Coverage including synonyms is essentially complete, matching anchor 5 rather than 4.

Distinctiveness Conflict Risk

It claims a clear niche (the F#/C# boundary, scoped "in morphir-dotnet") with highly specific triggers ("CompiledName", "F# nullness", "parse don't validate") that no generic or neighboring skill would plausibly match. Minimal conflict risk matches anchor 5 rather than 4.