VerticalSlices: Skill for Claude Code

Wire convention-based discovery for a set of implementations behind an abstraction.

The pattern in one line

Inject IInstancesOf<TInterface> from Cratis.Types. Mark implementations with [Singleton]. Delete any services.AddSingleton<TInterface, Impl>() lines that registered them.

When this skill applies

The consumer of an abstraction needs to iterate, filter, or fan out to every registered implementation. Common shapes:

• *Handlers, *Filters, *Validators, *Formatters, *Strategies, *Providers, *Resolvers — anything plural that delegates to a set.
• A dispatcher that picks the right implementation by calling CanHandle(...) and forwarding to the matching one.
• A composite that fans a single input out to all implementations and aggregates results.

When it does NOT apply

• The consumer needs one implementation chosen at composition time → constructor-inject the concrete interface and let normal DI resolve IFoo → Foo.
• The method returns a sequence of values to a caller → IEnumerable<T> (or IReadOnlyList<T>, etc.) is still the right return type. The rule is only about injecting implementations of an abstraction.

Step 1 — Confirm the implementations are discoverable

IInstancesOf<T> discovers types by convention from loaded assemblies. The only requirements:

• Each implementation is a non-abstract public class.
• It implements the interface directly (not via another layer that hides it).

No assembly attribute is needed — the Cratis framework's type discovery picks them up automatically.

Step 2 — Mark implementations as singletons (default)

[Singleton]
public class EventResultHandler(IEventTypes eventTypes) : IReactorSideEffectHandler
{
    public bool CanHandle(ReactorContext context, object value) => /* ... */;
    public Task Handle(ReactorContext context, object value) => /* ... */;
}

Add using Cratis; if [Singleton] is unresolved.

Skip [Singleton] only when the implementation must be transient — i.e. it holds per-call state that cannot be shared. The convention IFoo → Foo still applies for transients; do not register them explicitly.