learn-pattern

name	learn-pattern
description	Extract reusable patterns from the current session and store as Tekio adaptations or memories
layer	utility
category	learning
triggers	["learn from this","extract pattern","remember this pattern","save what we learned","learn","what did we learn"]
inputs	[{"context":"Current session context or specific interaction to learn from"},{"scope":"Project scope for pattern storage"}]
outputs	[{"patterns":"Extracted patterns with confidence scores"},{"storage":"Where patterns were saved (Tekio adaptation or memory)"}]
linksTo	["debug","fix","refactor","sequential-thinking"]
linkedFrom	["cook","audit","team"]
preferredNextSkills	["verify","quality-gate"]
fallbackSkills	["sequential-thinking"]
riskLevel	low
memoryReadPolicy	full
memoryWritePolicy	full
sideEffects	["Creates Tekio adaptations in database","Creates memory entries in database"]

Learn Pattern

Purpose

Extract reusable engineering patterns from the current session and persist them for future sessions. Unlike Tekio wheel-turns (which learn from failures), this skill proactively captures successes, techniques, and insights mid-session.

Use this when:

• You just solved a non-trivial problem worth remembering
• A debugging technique worked well and should be reusable
• You discovered a project-specific pattern or convention
• A workaround was found for a known limitation
• A new architectural decision was made

Key Concepts

Pattern Types

Type	Description	Storage	Example
Error Resolution	How a specific error was fixed	Tekio (defensive)	"TS2322 in Neon queries → cast with as Record<string, unknown>[]"
Debugging Technique	Systematic approach that worked	Memory (solution)	"Galaxy canvas memory leak → useMemo for filtered data + useRef for animation"
Project Convention	Discovered project patterns	Memory (pattern)	"All API routes use getDb() singleton, never inline neon import"
Architectural Decision	Design choices with rationale	Memory (decision)	"Chose pgvector + pg_trgm hybrid over pure vector search for memory recall"
Workaround	Known limitation with mitigation	Tekio (auxiliary)	"Bash set -u + empty arrays → use ${arr[@]+\"${arr[@]}\"} safe expansion"
Performance Insight	Optimization that worked	Memory (insight)	"Promise.all for independent DB queries cut response time 60%"

Confidence Scoring

Each extracted pattern gets a confidence score:

Score	Meaning	Criteria
0.9-1.0	Proven	Verified by tests, applied 3+ times
0.7-0.8	High	Worked in this session, consistent with docs
0.5-0.6	Medium	Worked once, untested edge cases
0.3-0.4	Low	Hypothesis, not fully validated

Storage Decision

Is it about preventing a failure?     → Tekio adaptation (defensive)
Is it about detecting issues early?   → Tekio adaptation (auxiliary)
Is it about a better approach?        → Tekio adaptation (offensive)
Is it a project-specific convention?  → Memory (pattern/architecture)
Is it a reusable debugging technique? → Memory (solution)
Is it a design decision?              → Memory (decision)

Workflow

Phase 1: Review Session Context

Examine recent work in the session:

• What problems were solved?
• What techniques were used?
• What decisions were made and why?
• What errors were encountered and how were they fixed?
• What optimizations were applied?

Phase 2: Extract Patterns

For each pattern found, capture:

{
  content: "Clear, actionable description of the pattern",
  category: "solution" | "pattern" | "decision" | "architecture" | "insight",
  importance: 1-10,    // How broadly applicable
  confidence: 0-1,     // How well validated
  scope: "project/name", // Where it applies
  tags: ["#auto", "#learned", "#category"]
}

Phase 3: Dedup and Validate

Before saving, check against existing knowledge:

1. Search memory DB for similar content (similarity > 0.6 = skip)
2. Check Tekio adaptations for overlapping triggers
3. If duplicate found, update confidence/importance instead of creating new

Phase 4: Store

# For memory entries
npx tsx memory/scripts/memory-runner.ts save '<json>'

# For Tekio adaptations (from corrections/failures)
npx tsx memory/scripts/memory-runner.ts wheel-correct '<wrong>' '<right>' [scope]

Phase 5: Report

PATTERNS EXTRACTED: 3

  1. [solution] Promise.all for parallel DB queries (confidence: 0.9, importance: 7)
     → Saved to memory: abc123
  2. [defensive] Neon getDb() singleton prevents connection leaks (confidence: 0.8, importance: 8)
     → Saved as Tekio adaptation
  3. [pattern] Dashboard API routes follow getDb() + try/catch + NextResponse pattern
     → Already exists (updated confidence 0.7 → 0.85)

Best Practices

1. Extract at logical boundaries — after completing a feature, fixing a bug, or finishing a refactor
2. Focus on reusable patterns — skip one-time fixes that won't recur
3. Include the WHY — "Use getDb() because inline neon imports create connection leaks" not just "Use getDb()"
4. Set confidence honestly — a pattern used once is 0.5-0.6, not 0.9
5. Scope appropriately — project-specific patterns get project scope, universal ones get no scope
6. One pattern per entry — don't combine unrelated insights into one memory
7. Check for contradictions — if new pattern conflicts with existing memory, flag for resolution

Common Pitfalls

Pitfall	Impact	Fix
Saving trivial patterns	Memory pollution, low signal-to-noise	Filter: importance >= 5 for patterns
Missing the WHY	Pattern is remembered but not understood	Always include rationale and context
Over-confident scoring	False patterns get applied broadly	Start at 0.5, let repeated use increase confidence
Not deduplicating	Same pattern saved 5 times	Always search before saving
Too broad scope	Project-specific pattern applied globally	Scope patterns to project unless truly universal
Saving during exploration	Half-baked insights pollute memory	Only save after validation/verification

Examples

After Debugging a Memory Leak

Extracted pattern:
  Content: "React canvas animations with filter state: use useMemo for filtered
  data and useRef for values needed in animation loop. Never depend on state
  directly in requestAnimationFrame — use refs to avoid teardown/rebuild."
  Category: solution
  Importance: 7
  Confidence: 0.85
  Tags: #react #animation #performance #memory-leak

After Discovering a Convention

Extracted pattern:
  Content: "UltraThink dashboard API routes pattern: import getDb from @/lib/db,
  wrap handler in try/catch, return NextResponse.json with proper status codes.
  Never use inline neon() imports — they create connection pool issues."
  Category: pattern
  Importance: 8
  Confidence: 0.9
  Scope: ai-agents/ultrathink
  Tags: #convention #api #database

After a Security Fix

Extracted Tekio adaptation:
  Trigger: "SQL query with user input"
  Rule: "Always use websearch_to_tsquery() instead of to_tsquery() for user-provided
  search terms. to_tsquery() throws on special characters — websearch_to_tsquery()
  handles them gracefully."
  Category: defensive
  Confidence: 0.95

Integration with Session Lifecycle

Learn-pattern can be invoked:

• Manually — user says "learn from this" or "/learn"
• At session end — evaluate-session hook extracts patterns automatically
• After cook/ship — preferredNextSkill chain suggests learning
• After debug/fix — error resolution patterns are prime learning material