ajbcoding/claude-skill-eval/moai-alfred-expertise-detection

✓ Provide high-level analogies
✓ Explain concepts before showing code
✓ Include step-by-step examples
✓ Link to beginner tutorials
✓ Avoid advanced jargon
✓ Provide working examples

✓ Provide architectural guidance
✓ Explain trade-offs and decisions
✓ Show best practices and patterns
✓ Include edge cases
✓ Use technical terminology correctly
✓ Suggest optimizations

✓ Focus on nuanced details
✓ Discuss implementation trade-offs
✓ Reference RFC documents
✓ Show performance implications
✓ Discuss advanced patterns
✓ Link to source code

✓ Assume deep knowledge
✓ Focus on bleeding-edge details
✓ Link to implementation source
✓ Discuss language design decisions
✓ No hand-holding required

"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)

# Beginner: Simple, linear logic
def greet(name):
    return f"Hello, {name}!"
# Intermediate: Using patterns
class UserService:
    def __init__(self, repo):
        self.repo = repo
    
    def get_user(self, user_id):
        return self.repo.find(user_id)
# Advanced: Complex architecture
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
# Expert: Framework internals
async def get_user_with_prefetch(user_id, cache, repo, query_planner):
    # Uses query optimization, connection pooling, prefetch logic
    plan = query_planner.optimize(f"SELECT * FROM users WHERE id={user_id}")
    # Custom execution with monitoring and fallback strategies

"How do I...?"           → Beginner
"What's the best way to...?" → Intermediate
"Why does X work like Y?" → Advanced
"How does the implementation..." → Expert

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

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)

# 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.

Beginner:   "function", "loop", "variable"
Intermediate: "closure", "prototype", "event loop"
Advanced:   "hoisting", "temporal dead zone", "thunk"
Expert:     "reification", "lifting", "unfold semantics"