playbooks

home / skills / mamba-mental / agent-skill-manager / meta-pattern-recognition

meta-pattern-recognition skill

/skills/problem-solving/meta-pattern-recognition

This skill identifies universal patterns by spotting repeats across three or more domains, enabling proactive design insights and reusable abstractions.

npx playbooks add skill mamba-mental/agent-skill-manager --skill meta-pattern-recognition

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

Files (1)
SKILL.md
2.0 KB
---
name: Meta-Pattern Recognition
description: Spot patterns appearing in 3+ domains to find universal principles
when_to_use: when noticing the same pattern across 3+ different domains or experiencing déjà vu in problem-solving
version: 1.1.0
---

# 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 finds recurring patterns that appear across three or more domains and extracts them as reusable principles. It helps teams generalize technical and organizational solutions so they can be applied in new contexts. The goal is to turn repeated solutions into concise abstract forms and actionable variations.

How this skill works

The skill scans examples from multiple domains, highlights matching shapes, and summarizes the abstract form independent of original context. It then catalogs variation points and suggests candidate applications where the pattern can be reused. Finally, it validates applicability by checking constraints and trade-offs across domains.

When to use it

  • Designing systems where similar problems recur in different teams or stacks
  • Refactoring architecture to reuse proven solutions
  • Inventing features that may map to existing operational patterns
  • Training teams to recognize universal practices
  • Evaluating whether a novel solution is genuinely unique

Best practices

  • Require evidence from at least three distinct domains before declaring a meta-pattern
  • Describe the abstract form in domain-agnostic language
  • List variation points: what changes, why, and trade-offs for each variant
  • Document concrete examples and edge cases where the pattern fails
  • Use the pattern to generate candidate solutions and prototypes, not to force-fit designs

Example use cases

  • Identify caching as a universal performance tactic across DBs, HTTP, and LLM prompts and propose a unified caching layer
  • Extract layering as an organizational principle to restructure product teams and software stacks
  • Spot queuing patterns to design resilient async workflows across services and user interfaces
  • Reuse pooling concepts to optimize resource governance for connections, threads, and model instances

FAQ

How many examples do I need to declare a meta-pattern?

Aim for at least three distinct domains or problem spaces; fewer examples mean higher risk of overfitting.

What if a pattern has important domain-specific constraints?

Capture those as variation points and failure modes; meta-patterns are guidance, not rigid rules.