Unicorn pattern transfer

<!-- Last reviewed: 2026-03 -->

Pattern Transfer

Pattern Recognition Process

1. Identify the Problem Class

Ask: "What CATEGORY of problem is this?"

Surface Symptom	Core Problem Class
Notify components when data changes	State observation
Multiple async operations need coordination	Async orchestration
Expensive computation called repeatedly	Caching
Too many requests overload system	Rate limiting
Operation fails sometimes	Retry/resilience
Transform collection of data	Data transformation

2. Recall Prior Implementations

Ask: "Where have I encountered this problem class before?"

Map all known manifestations across languages, frameworks, and infrastructure layers.

3. Extract Canonical Solution

Ask: "What's the ESSENCE?" Strip language-specific syntax down to core steps.

Example -- State Management ESSENCE:
1. Central state container
2. Controlled mutation mechanism
3. Change notification system
4. Subscriber registration/unregistration

4. Map to Local Idioms

Ask: "How is this done HERE?" Translate essence into target domain's conventions, best practices, libraries, and naming.

Common Pattern Classes

Pattern Class	Problem	Key Implementations
State Management	Shared changing data	Redux, databases, event sourcing
Async Coordination	Multiple async operations	Promises, asyncio, goroutines
Caching	Expensive repeated operations	Memoization, Redis, HTTP cache
Rate Limiting	Prevent resource exhaustion	Token bucket, sliding window
Retry/Resilience	Handle transient failures	Backoff, circuit breaker
Data Transformation	Reshape data	Map/filter/reduce, pipes, LINQ

See references/pattern-catalog.md for detailed essence, manifestations, and transfer examples.

Transfer Protocol

Step 1: Extract ESSENCE

Remove language-specific details. Find core idea as numbered steps.

Step 2: Find IDIOMS

How does target language/framework express this? What libraries exist? What conventions apply?

Step 3: REIFY

Implement using local conventions. Verify it solves the original problem, not a distorted version.

Pattern Recognition Checklist

Classification:

• What CATEGORY is this problem?
• Have I seen this before?
• What's it called in different contexts?

Recall:

• Where have I solved this?
• What solutions exist elsewhere?
• What's the canonical implementation?

Extraction:

• What's the CORE idea?
• What's language-specific syntax vs essence?
• What constraints shaped the original?

Adaptation:

• What are idioms HERE?
• What conventions should I follow?
• What libraries/tools exist?

Verification:

• Does this solve the RIGHT problem?
• Is this the SIMPLEST solution?
• Have I introduced new problems?

Anti-Patterns

Anti-Pattern	Symptom	Instead
Pattern obsession	SingletonFactoryStrategyAdapter	Solve the actual problem simply
Inappropriate transfer	OOP patterns in functional languages	Use target paradigm's strengths
Cargo cult	"Saw Redux in tutorial, using everywhere"	Match tool to actual complexity
Premature abstraction	Extracting pattern from 1 use case	Wait for 2+ use cases

Quick Reference: Pattern Mapping

When You See	Pattern	Implementations
Notify on change	Observer	Events, hooks, pub/sub, triggers
Swap behavior	Strategy	Polymorphism, functions, DI
Add features	Decorator	@decorator, HOC, annotations
Expensive operation	Memoization	Cache, React.memo, materialized views
Too many requests	Rate Limit	Token bucket, throttle, semaphore
Transient failures	Retry	Backoff, circuit breaker, timeout
Object creation	Builder	Fluent API, config object
Single access	Singleton	Module pattern, DI, constants
Undo/redo	Command	Event sourcing, action history
Transform pipeline	Chain	Streams, LINQ, pipes, map/reduce

Integration with Other Skills

Skill	Integration
Code Reading	Recognize patterns in unfamiliar codebases faster
Estimation	Known patterns have known complexity
Language Learning	Map known patterns to new language idioms
Debugging	Pattern violations often indicate bugs

See references/transfer-examples.md for multi-scale examples and practice exercises.