This is a ref struct, the same tradeoff that keeps the BCL's own System.Text.ValueStringBuilder internal. Three ways it bites:

• Caught by the compiler: storing it in a field, capturing it in a closure, or using it across a let!/do!. There is therefore no closure-taking helper API — a parameter typed ValueStringBuilder byref -> 'R does not compile at all.
• Not caught: passing it by value. A copy shares the same backing array, so if either side grows or disposes, the other is left pointing at memory the pool may have handed to somebody else. This is why no member returns this: fluent chaining would copy.
• Not caught: a stack-allocated span outliving its frame. F# has no stackalloc expression, and a span built by hand from NativePtr.stackalloc is invisible to escape analysis — returning one compiles silently. Allocate in the function that uses it, never in a loop.

It has a plain Dispose() and does not implement IDisposable, so use does not apply — dispose from a try/finally. Dispose is idempotent.

When to use it: a hot path that builds one string per call and consumes it immediately. Measured against StringBuilder from 16 to 1,048,576 characters (ValueStringBuilderBenchmarks): never slower, and a third to a half of the allocations. When not to use it: anywhere the value must escape the building function — which is most code, since it cannot be returned, stored, or passed — or anywhere not hot enough to be worth the danger above. When in doubt use StringBuilder.

Example

The one supported shape — a local let mutable, plain statement calls, disposed in a finally:

 let describe (name: string) (count: int) =
     let buffer = Array.zeroCreate<char> 64
     let mutable sb = ValueStringBuilder(Span<char>(buffer))
     try
         sb.Append("name=")
         sb.Append(name)
         sb.ToString()
     finally
         sb.Dispose()