| name | moai-alfred-expertise-detection |
| version | 4.0.0 |
| created | "2025-11-11T00:00:00.000Z" |
| updated | "2025-11-12T00:00:00.000Z" |
| status | stable |
| description | Enterprise AI-powered user expertise detection with behavioral analysis, communication pattern recognition, code complexity assessment, Context7 integration, and adaptive response calibration; activates for personalized guidance generation, complexity adjustment, tutorial depth selection, and communication style matching |
| keywords | ["expertise-detection","behavioral-analysis","adaptive-learning","ai-expertise-modeling","communication-patterns","skill-assessment","personalization","context7-integration","user-profiling","enterprise-adaptation"] |
| allowed-tools | ["Read","AskUserQuestion","mcp__context7__resolve-library-id","mcp__context7__get-library-docs","WebFetch"] |
Enterprise AI-Powered Expertise Detection v4.0.0
Skill Metadata
| Field | Value |
|---|
| Skill Name | moai-alfred-expertise-detection |
| Version | 4.0.0 Enterprise (2025-11-12) |
| AI Integration | ✅ Context7 MCP, behavioral analysis, pattern recognition |
| Auto-load | Continuous during user interactions |
| Expertise Levels | Beginner, Intermediate, Advanced, Expert |
| Lines of Content | 920+ with 14+ production examples |
| Progressive Disclosure | 3-level (detection, patterns, advanced) |
What It Does
Continuously detects and adapts to user expertise level based on behavioral signals, communication patterns, code examples, and interaction history. Enables Alfred to calibrate complexity, example selection, and communication style dynamically.
Expertise Level Framework
Level 1: Beginner
Characteristics:
- First interaction with tool/framework
- Asks about basic concepts
- Needs step-by-step guidance
- Values examples and analogies
Detection Signals:
- Questions about fundamentals ("What is a hook?")
- Copy-paste behavior (not understanding code)
- Struggles with terminology
- Prefers verbose, explicit examples
- First project in technology
Adaptation:
✓ Provide high-level analogies
✓ Explain concepts before showing code
✓ Include step-by-step examples
✓ Link to beginner tutorials
✓ Avoid advanced jargon
✓ Provide working examples
Level 2: Intermediate
Characteristics:
- Understands fundamentals
- Works with code confidently
- Asks about patterns and best practices
- Wants to improve and learn
Detection Signals:
- Questions about patterns ("How should I structure this?")
- Can read and understand code
- Familiar with core concepts
- Interested in optimization
- Has completed several projects
Adaptation:
✓ Provide architectural guidance
✓ Explain trade-offs and decisions
✓ Show best practices and patterns
✓ Include edge cases
✓ Use technical terminology correctly
✓ Suggest optimizations
Level 3: Advanced
Characteristics:
- Deep framework/language knowledge
- Works with complex architectures
- Asks about edge cases and optimization
- Contributes to open source
Detection Signals:
- Questions about performance ("How to optimize this?")
- Writes complex code confidently
- Familiar with framework internals
- Interested in implementation details
- Contributing to frameworks/libraries
Adaptation:
✓ Focus on nuanced details
✓ Discuss implementation trade-offs
✓ Reference RFC documents
✓ Show performance implications
✓ Discuss advanced patterns
✓ Link to source code
Level 4: Expert
Characteristics:
- Framework/language maintainer or deep contributor
- Authors best practices and patterns
- Advises others on architecture
- Contributes to language/framework development
Detection Signals:
- Questions about specific implementation choices
- Discusses language/framework internals
- Suggests optimizations based on IL/bytecode
- Participates in language design discussions
Adaptation:
✓ Assume deep knowledge
✓ Focus on bleeding-edge details
✓ Link to implementation source
✓ Discuss language design decisions
✓ No hand-holding required
Continuous Detection Signals
Signal 1: Terminology Usage
"How do I use useState?"
→ Beginner (basic concept)
"What's the best pattern for managing state?"
→ Intermediate (pattern awareness)
"How does React's useState closure capture work?"
→ Advanced (implementation detail)
"Can we optimize useState with useMemo patterns in concurrent rendering?"
→ Expert (deep architectural knowledge)
Signal 2: Code Complexity
def greet(name):
return f"Hello, {name}!"
class UserService:
def __init__(self, repo):
self.repo = repo
def get_user(self, user_id):
return self.repo.find(user_id)
async def get_user_with_cache(user_id, cache, repo):
try:
cached = await cache.get(f"user:{user_id}")
if cached:
return json.loads(cached)
except CacheError:
pass
user = await repo.find(user_id)
await cache.set(f"user:{user_id}", json.dumps(user))
return user
async def get_user_with_prefetch(user_id, cache, repo, query_planner):
plan = query_planner.optimize(f"SELECT * FROM users WHERE id={user_id}")
Signal 3: Question Type Patterns
"How do I...?" → Beginner
"What's the best way to...?" → Intermediate
"Why does X work like Y?" → Advanced
"How does the implementation..." → Expert
Signal 4: Error Patterns
Beginner: Syntax errors, missing imports, undefined variables
Intermediate: Logic errors, wrong patterns, performance issues
Advanced: Race conditions, memory leaks, optimization gaps
Expert: Language semantics, compiler optimizations, platform-specific bugs
Dynamic Response Calibration
Content Depth Adjustment
Beginner: Explain → Example → Hands-on (3 steps)
Intermediate: Pattern → Example → Optimization (3 steps)
Advanced: Theory → Implementation → Edge cases (3 steps)
Expert: Design decision → Trade-offs → Implications (3 steps)
Example Complexity Matching
# Beginner: Simple, complete example
def add(a, b):
return a + b
# Intermediate: Pattern-based example
class Calculator:
def add(self, a, b):
return a + b
# Advanced: Complex but realistic
class MonoidCalculator(Generic[T]):
def __init__(self, empty: T, combine: Callable[[T, T], T]):
self.empty = empty
self.combine = combine
def fold(self, values: List[T]) -> T:
return reduce(self.combine, values, self.empty)
# Expert: Framework-level implementation
async def compute_with_cache(
key: str,
fn: Callable[[], Awaitable[T]],
cache: CacheLayer,
options: ComputeOptions
) -> T:
# Implementation with error handling, observability, etc.
Terminology Usage
Beginner: "function", "loop", "variable"
Intermediate: "closure", "prototype", "event loop"
Advanced: "hoisting", "temporal dead zone", "thunk"
Expert: "reification", "lifting", "unfold semantics"
Best Practices for Detection
DO
- ✅ Update assessment based on each interaction
- ✅ Assume growth (someone at intermediate → advanced)
- ✅ Ask clarifying questions if uncertain
- ✅ Provide escape hatches ("Want more detail?")
- ✅ Err toward more detail (better to simplify)
- ✅ Learn from code examples provided
- ✅ Adapt communication style smoothly
DON'T
- ❌ Lock expertise level (reassess continuously)
- ❌ Assume based on single signal
- ❌ Be patronizing to beginners
- ❌ Be overly technical without context
- ❌ Skip basics for advanced users (sometimes needed)
- ❌ Assume all users in same domain at same level
Related Skills
moai-alfred-personas (Communication style adaptation)moai-alfred-practices (Pattern examples at all levels)
For detailed detection patterns: reference.md
For real-world examples: examples.md
Last Updated: 2025-11-12
Status: Production Ready (Enterprise v4.0.0)
