| name | creativity-idea-cluster |
| description | Group ideas into families by underlying pattern. Use when: (1) asked to organize or categorize generated options, (2) varied ideas or concepts referenced with areas of indistinction between them, (3) similar suggestions scattered across discussion without visible grouping, (4) multiple approaches mentioned that share unstated common ground. |
Idea Cluster
Organize generated ideas into families by recognizing what makes them fundamentally similar.
Instructions
When clustering ideas:
-
Lay out all ideas - Display every generated option without filtering yet, preserving original phrasing and including ideas that seem redundant or similar since apparent duplicates often reveal meaningful distinctions.
-
Look for shared DNA - Identify what makes ideas fundamentally alike by asking what underlying mechanism they use, what assumption they share, or what approach they take rather than focusing on surface features.
-
Name the families - Describe each cluster's unifying principle in 2-4 words that capture the essential pattern, avoiding generic labels like "technical solutions" in favor of specific mechanisms like "automated enforcement" or "social accountability."
-
Test cluster coherence - Verify each family holds together by checking whether ideas within a cluster could be combined or evolved into each other, whether someone pursuing one idea might naturally discover the others, and whether the cluster reveals a distinct strategic direction.
-
Capture orphans - Notice ideas that don't fit existing families since these outliers often represent genuinely different approaches worth preserving, either as standalone clusters of one or as signals that a family's definition needs expansion.
-
Map relationships between families - Determine which families complement each other, which are mutually exclusive, and which represent progressive evolution of the same core concept, revealing whether the idea space suggests combining approaches or choosing between fundamentally different directions.
Examples
Library engagement ideas
"After brainstorming 18 ways to increase library visits, the raw list feels overwhelming:
- Host author readings
- Create study pod reservations
- Add coffee shop
- Start book clubs
- Offer weekend workshops
- Install better WiFi
- Extend evening hours
- Add gaming stations
- Create maker space
- Launch mobile app
- Send personalized recommendations
- Host community meetings
- Add more seating
- Create quiet study rooms
- Start podcast recording booth
- Offer tech help desk
- Create teen space
- Add outdoor reading garden
Clustering by shared DNA:
Experience enhancement (make visiting more valuable):
- Coffee shop, better seating, outdoor garden, quiet study rooms, gaming stations, maker space, podcast booth
- Pattern: Add amenities that make the library a destination beyond books
Community connection (bring people together):
- Author readings, book clubs, workshops, community meetings, teen space
- Pattern: Create social reasons to visit through shared experiences
Practical service (solve everyday problems):
- Study pod reservations, extended hours, tech help desk, better WiFi
- Pattern: Remove friction and support people's immediate needs
Digital reach (extend beyond physical visits):
- Mobile app, personalized recommendations
- Pattern: Engage people outside the building
- Note: Only 2 ideas - might combine with another family or develop further
Relationships: Experience and community families reinforce each other (people stay longer for events if space is pleasant). Practical services support both. Digital reach works differently - it's about not visiting at all.
Strategic insight: Most ideas fall into 'make the building better' - only 2 address people who can't or won't visit physically. Worth generating more in that sparse family."
API design approaches
"After generating 12 API design options:
- GraphQL with schema stitching
- REST with HATEOAS links
- gRPC for internal services
- WebSocket streaming
- REST with versioned endpoints
- GraphQL federation
- Server-sent events
- Webhook callbacks
- REST with JSON:API spec
- tRPC for type safety
- Polling with ETags
- REST with API gateway
Initial attempt: Protocol types (GraphQL family, REST family, gRPC family)
That's too surface-level. Looking for shared DNA:
Schema-driven contracts (client and server share type definitions):
- GraphQL with schema stitching, GraphQL federation, tRPC, gRPC
- Pattern: Code generation from shared schemas, compile-time safety
Hypermedia navigation (server tells client what's possible):
- REST with HATEOAS, JSON:API spec
- Pattern: Client doesn't hardcode endpoints, discovers capabilities
Real-time push (server initiates updates):
- WebSocket streaming, server-sent events, webhook callbacks
- Pattern: Invert control - server decides when to send
Version isolation (multiple API generations coexist):
- Versioned endpoints, API gateway
- Pattern: Manage evolution through explicit separation
Efficient sync (minimize data transfer):
- Polling with ETags, GraphQL field selection
- Pattern: Client gets exactly what changed
- Note: Only 2 ideas but crosses other families - ETags work with REST, GraphQL selection is inherent
Orphan observation: 'gRPC for internal services' might belong in schema-driven but the 'internal' qualifier suggests a different concern - service boundary location rather than contract style.
Family relationships: Schema-driven and version isolation address different concerns (safety vs evolution), could combine. Real-time push works with any contract style. Hypermedia and schema-driven represent opposing philosophies - runtime vs compile-time coupling.
Decision clarity: We're not choosing protocols, we're choosing between compile-time safety (schema-driven) and runtime flexibility (hypermedia). That's the real fork."
Customer retention strategies
"Generated 20 ideas for reducing churn:
- Annual plan discounts
- Loyalty points
- Feature preview access
- Personalized onboarding
- Usage analytics dashboard
- Dedicated account manager
- Exit interview process
- Win-back email campaigns
- Referral bonuses
- Community forum
- Quarterly business reviews
- Free training sessions
- Downgrade path instead of cancel
- Competitor comparison tool
- Success metrics tracking
- Automated health scoring
- Enhanced support tier
- Slack integration
- Peer user groups
- Contract lock-in periods
Finding families:
Economic friction (make leaving costly):
- Annual discounts, contract lock-in, loyalty points
- Pattern: Financial barriers to exit
Relationship building (personal connection):
- Dedicated account manager, quarterly reviews, peer groups, community forum
- Pattern: Human investment makes leaving feel like abandoning people
Value demonstration (show ROI):
- Usage analytics, success metrics, competitor comparison, automated health scoring
- Pattern: Make value visible and measurable
Engagement deepening (increase integration):
- Slack integration, feature previews, training, downgrade path
- Pattern: Embed product into workflow and skills
Recovery mechanisms (win back lost customers):
- Exit interviews, win-back campaigns
- Pattern: Learn from and recapture churned users
- Note: Different timeframe than prevention
Family analysis:
Economic friction and relationship building might work against each other - lock-in feels manipulative when relationship is weak. Value demonstration strengthens relationship building - easier to build connection when ROI is clear. Engagement deepening and value demonstration reinforce - visible value encourages deeper integration.
Recovery is separate timeline - happens after other families failed.
Core tension revealed: Economic friction family represents 'trap them' while other families represent 'serve them better.' Clustering reveals we're mixing retention philosophies that may send contradictory messages."
