playbooks

home / skills / yousufjoyian / claude-skills / meta-pattern-recognition

meta-pattern-recognition skill

/problem-solving/meta-pattern-recognition

This skill helps you detect universal meta-patterns across domains, extract abstract forms, and apply them to new contexts for scalable insights.

This is most likely a fork of the meta-pattern-recognition skill from mamba-mental
npx playbooks add skill yousufjoyian/claude-skills --skill meta-pattern-recognition

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.9 KB
---
name: meta-pattern-recognition
description: Spot patterns appearing in 3+ domains to find universal principles
---

# Meta-Pattern Recognition

## Overview

When the same pattern appears in 3+ domains, it's probably a universal principle worth extracting.

**Core principle:** Find patterns in how patterns emerge.

## Quick Reference

| Pattern Appears In | Abstract Form | Where Else? |
|-------------------|---------------|-------------|
| CPU/DB/HTTP/DNS caching | Store frequently-accessed data closer | LLM prompt caching, CDN |
| Layering (network/storage/compute) | Separate concerns into abstraction levels | Architecture, organization |
| Queuing (message/task/request) | Decouple producer from consumer with buffer | Event systems, async processing |
| Pooling (connection/thread/object) | Reuse expensive resources | Memory management, resource governance |

## Process

1. **Spot repetition** - See same shape in 3+ places
2. **Extract abstract form** - Describe independent of any domain
3. **Identify variations** - How does it adapt per domain?
4. **Check applicability** - Where else might this help?

## Example

**Pattern spotted:** Rate limiting in API throttling, traffic shaping, circuit breakers, admission control

**Abstract form:** Bound resource consumption to prevent exhaustion

**Variation points:** What resource, what limit, what happens when exceeded

**New application:** LLM token budgets (same pattern - prevent context window exhaustion)

## Red Flags You're Missing Meta-Patterns

- "This problem is unique" (probably not)
- Multiple teams independently solving "different" problems identically
- Reinventing wheels across domains
- "Haven't we done something like this?" (yes, find it)

## Remember

- 3+ domains = likely universal
- Abstract form reveals new applications
- Variations show adaptation points
- Universal patterns are battle-tested

Overview

This skill helps spot patterns that recur across three or more domains and distill them into reusable, domain-agnostic principles. It focuses on extracting the abstract form of a pattern, documenting its variation points, and proposing new applications. The outcome is faster problem solving, reduced duplication, and clearer design guidance.

How this skill works

The skill scans examples from multiple domains and highlights similar structural shapes (e.g., caching, layering, queuing). It then abstracts the common mechanics, lists variation axes (what changes per domain), and suggests candidate applications where the pattern could transfer. Finally, it flags red flags that indicate a missed meta-pattern or reinvention.

When to use it

  • Design reviews where multiple teams solve similar problems differently
  • Architecture synthesis across systems (software, org, hardware, policy)
  • Postmortems to surface recurring root causes and controls
  • Product ideation to repurpose proven solutions in new contexts
  • Technical debt assessment to reveal duplicated implementations

Best practices

  • Collect at least three distinct domain examples before generalizing
  • Express the pattern in an abstract form free of domain-specific jargon
  • List variation points explicitly: resources, limits, failure modes, recovery
  • Validate applicability with small experiments or prototypes before full adoption
  • Document trade-offs and where the pattern should not be applied

Example use cases

  • Identifying caching as a universal performance primitive across CPU, CDN, and LLM prompt layers
  • Turning rate limiting patterns from networks and APIs into token-budget controls for LLMs
  • Applying pooling concepts from databases and thread management to connection and function-instance governance
  • Mapping layering patterns from networks to organizational responsibilities and product modules
  • Using queuing patterns from messaging to design backpressure in user-facing workflows

FAQ

How many examples do I need to consider a pattern 'meta'?

Aim for three or more reasonably independent domains; that threshold reduces the chance the pattern is accidental.

What if a pattern seems similar but has major differences?

Capture those differences as variation points. A valid meta-pattern tolerates systematic variations but preserves core mechanics.