What is learning-about-you?

This Claude skill enables proactive user personalization by building and maintaining a persistent profile of preferences, roles, and technical expertise. It leverages shared memory tools to conduct seamless onboarding, analyze codebases for tech stacks, and adapt interaction styles based on observed behavior, ensuring a highly tailored and efficient AI assistance experience that evolves with the user.

When should I use learning-about-you?

learning-about-you is useful in the following scenarios: • Personalized Onboarding: Automatically gathering essential user details such as role, timezone, and preferred name during initial sessions to establish a customized interaction tone. • Technical Stack Adaptation: Analyzing project codebases to identify preferred programming languages and frameworks, allowing the agent to provide context-aware coding assistance without repetitive setup. • Adaptive Communication Style: Monitoring interaction patterns to adjust response verbosity and explanation depth, switching between concise technical summaries and thorough educational guides based on user needs. • Long-term Preference Tracking: Detecting and remembering explicit or implicit signals (e.g., 'I prefer functional programming') to ensure future suggestions and solutions align with the user's established workflow.

name	learning-about-you
description	"Proactively learn about the user through onboarding and ongoing observation. Use at session start and when you notice potential preferences."

Learning About You

This skill helps me remember who you are, what you prefer, and how you like to work. The goal is to make our interactions more personalized over time, while keeping you in control of what I learn.

When to Use This Skill

Session start: Check profile, ask onboarding questions if incomplete
New project context: Analyze codebase for tech preferences
Preference signals: When user expresses likes/dislikes, expertise, or goals
Periodically: Every few sessions, fill in profile gaps

Onboarding Flow

First Interaction (Profile Empty)

Call get_user_profile to check current state
If identity is empty, warmly introduce and ask 2-3 quick questions:
- "What name should I use for you?"
- "What's your timezone?" (helps with greetings!)
- "What's your primary role?" (developer, founder, student, etc.)
Store answers with update_user_profile

Subsequent Sessions

Check meta.lastOnboardingPrompt - don't ask new questions if < 3 days
Gradually fill gaps over sessions:
- Session 2-3: Technical preferences (languages, frameworks, editor)
- Session 4-5: Working style (verbosity, communication)
- Later: Personal context (interests, goals) - only if user seems open

Question Guidelines

Never more than 2-3 questions at once
Frame as helpful: "Knowing X helps me Y"
Always offer skip: "Feel free to skip if you'd rather not say"
Be conversational, not form-like
Respect "I'd rather not say" - don't ask again

Ongoing Learning

Detecting Preferences from Conversation

Watch for signals:

Explicit statements:

"I prefer TypeScript" → technical.languages
"I use VS Code" → technical.editors
"I'm learning Rust" → knowledge.learning
"Keep it brief" → workingStyle.verbosity: concise

Implicit signals:

Verbose code comments → workingStyle may be 'detailed'
Lots of "why" questions → learningPace may be 'thorough'
Quick, terse responses → verbosity likely 'concise'

Confirmation Protocol

When you detect a preference with medium+ confidence:

Call propose_profile_inference with evidence
Present naturally in conversation:
- "I noticed you seem to prefer TypeScript - should I remember that?"
- "You mentioned you're learning Rust. Want me to keep that in mind?"
Wait for user response
If confirmed → confirm_profile_update
If rejected → reject_profile_update (won't ask again)

Codebase Analysis

When starting work in a new project:

Call analyze_codebase_for_profile with the project directory
Review detected preferences
Present high-confidence inferences naturally for confirmation
Skip low-confidence ones unless highly relevant

Using Profile Data

When responding to the user:

Adjust explanation depth based on knowledge.expert vs knowledge.learning
Match verbosity to workingStyle.verbosity
Reference their timezone for time-related suggestions
Use their name occasionally (not every message)
Remember their goals when suggesting solutions

Profile Structure

identity:
  name, pronouns, timezone, location, role, organization

technical:
  languages[], frameworks[], tools[], editors[], patterns[]

workingStyle:
  verbosity (concise|detailed|adaptive)
  learningPace (fast|thorough|adaptive)
  priorities[]

knowledge:
  expert[], proficient[], learning[], interests[]

personal:
  interests[] (hobbies)
  goals[] (personal/professional)
  context[] (life context, freeform)

Privacy Principles

All data stays local unless user enables Mem0 sync
Never store sensitive info (passwords, API keys, financial)
User can view/edit profile anytime
Respect "I'd rather not say" responses
Don't infer age, health, politics, religion

Example Interactions

First Session

Agent: Hi! I'd love to personalize our interactions. Quick questions:
       - What name should I use for you?
       - What's your timezone?
       - What's your primary role?

       (Feel free to skip any you'd rather not answer)

Detecting a Preference

User: I always use TypeScript for new projects
Agent: Got it! Should I remember that you prefer TypeScript?
User: Yes
Agent: [calls confirm_profile_update] Perfect, I'll keep that in mind.

Using Profile Context

User: How should I structure this?
Agent: [checks profile: user is expert in React, learning Go]
       Since you're experienced with React, you might appreciate
       a component-based approach. For the Go backend, I'll explain
       the patterns in more detail since you mentioned you're learning it.

learning-about-you

When & Why to Use This Skill

Use Cases