| name | engineer-skill-creator |
| description | Transform extracted engineer expertise into an actionable skill with progressive disclosure, allowing agents to find and apply relevant patterns for specific tasks. |
Engineer Skill Creator
Transform extracted engineer profiles into ready-to-use skills with progressive disclosure, enabling AI agents to efficiently find and apply the right expertise for any coding task.
What This Skill Does
Takes the output from engineer-expertise-extractor and creates a structured, queryable skill that:
- Organizes expertise by task type - Find relevant patterns quickly
- Uses progressive disclosure - Show only what's needed for current task
- Provides contextual examples - Real code samples for specific scenarios
- Guides agents intelligently - Help find the right expertise at the right time
- Enables task-specific queries - "How would they handle authentication?"
The Two-Step Process
Step 1: Extract (engineer-expertise-extractor)
./extract_engineer.sh senior_dev
Step 2: Create Skill (THIS SKILL)
./create_expert_skill.sh senior_dev
Result: A ready-to-use skill that agents can query for specific guidance.
Why Progressive Disclosure Matters
Without progressive disclosure:
- Agent gets all expertise at once (overwhelming)
- Hard to find relevant information
- Context limits reached quickly
- Inefficient and slow
With progressive disclosure:
- Agent asks specific question
- Gets only relevant expertise
- Focused, actionable guidance
- Efficient use of context
- Faster, better results
Output Structure
When you create a skill from an engineer profile, you get:
expert-skills/
└── [engineer-name]-mentor/
├── SKILL.md (skill documentation)
├── query_expertise.sh (interactive query tool)
├── expertise/
│ ├── by_task/
│ │ ├── authentication.md
│ │ ├── api_design.md
│ │ ├── database_design.md
│ │ ├── error_handling.md
│ │ └── testing.md
│ ├── by_language/
│ │ ├── typescript.md
│ │ ├── python.md
│ │ └── go.md
│ ├── by_pattern/
│ │ ├── dependency_injection.md
│ │ ├── repository_pattern.md
│ │ └── factory_pattern.md
│ └── quick_reference/
│ ├── coding_style.md
│ ├── naming_conventions.md
│ └── best_practices.md
└── examples/
├── authentication_service.ts
├── api_controller.ts
└── test_example.spec.ts
Progressive Disclosure System
Query by Task
Agent asks: "How would they implement user authentication?"
Skill provides:
- Relevant patterns from
by_task/authentication.md
- Code examples from their auth PRs
- Their testing approach for auth
- Security considerations they use
- Related best practices
NOT provided (yet):
- Unrelated patterns
- Database design details
- Payment processing approach
- Everything else
Query by Language
Agent asks: "Show me their TypeScript coding style"
Skill provides:
- TypeScript-specific conventions
- Type usage patterns
- Interface design approach
- Error handling in TS
- Real TS examples
Query by Pattern
Agent asks: "How do they implement dependency injection?"
Skill provides:
- DI pattern from their code
- Constructor injection examples
- IoC container setup
- Testing with DI
- When they use it vs when they don't
Skill Usage by Agents
Basic Query
"Using the skill expert-skills/senior-dev-mentor/, show me how to
implement authentication"
Skill responds with:
- Authentication patterns they use
- Real code examples
- Testing approach
- Security practices
- Step-by-step guidance
Language-Specific Query
"Using expert-skills/senior-dev-mentor/, write a TypeScript service
following their style"
Skill provides:
- TypeScript coding conventions
- Class structure patterns
- Type definitions approach
- Import organization
- Testing patterns for services
Pattern-Specific Query
"Using expert-skills/senior-dev-mentor/, implement the repository
pattern as they would"
Skill provides:
- Their repository pattern implementation
- Interface definitions
- Concrete implementation example
- Testing approach
- When to use this pattern
Created Skill Features
1. Task-Based Navigation
Expertise organized by common development tasks:
- Authentication & Authorization
- API Design
- Database Design
- Error Handling
- Testing Strategies
- Performance Optimization
- Security Practices
- Code Review Guidelines
2. Language-Specific Guidance
Separate docs for each language they use:
- Naming conventions per language
- Language-specific patterns
- Idiomatic code examples
- Framework preferences
3. Pattern Library
Design patterns they commonly use:
- When to apply each pattern
- Implementation examples
- Testing approach
- Common pitfalls to avoid
4. Quick Reference
Fast access to essentials:
- Coding style at a glance
- Naming conventions cheat sheet
- Common commands/snippets
- Review checklist
5. Interactive Query Tool
Script that helps find expertise:
./query_expertise.sh
What are you working on?
1) Authentication
2) API Design
3) Database
4) Testing
5) Custom query
Select: 1
=== Authentication Expertise ===
[Shows relevant patterns, examples, best practices]
How Skills Are Created
Input
Engineer profile from extractor:
engineer_profiles/senior_dev/
├── coding_style/
├── patterns/
├── best_practices/
├── architecture/
├── code_review/
└── examples/
Process
- Analyze profile structure
- Categorize by task - Group related expertise
- Extract examples - Pull relevant code samples
- Create navigation - Build progressive disclosure system
- Generate queries - Create query tool
- Package skill - Ready-to-use skill structure
Output
Skill with progressive disclosure:
expert-skills/senior-dev-mentor/
├── SKILL.md
├── query_expertise.sh
├── expertise/
│ ├── by_task/
│ ├── by_language/
│ ├── by_pattern/
│ └── quick_reference/
└── examples/
Example Created Skill
Authentication Task Doc
File: expertise/by_task/authentication.md
# Authentication - Senior Dev's Approach
## Overview
How senior_dev implements authentication based on 15 PRs analyzed.
## Preferred Approach
- JWT-based authentication
- Refresh token rotation
- HttpOnly cookies for web
- Token in headers for mobile/API
## Implementation Pattern
### Service Structure
[Code example from their PR #1234]
### Token Generation
[Code example from their PR #5678]
### Token Validation
[Code example from their PR #9012]
## Testing Approach
- Unit tests for token generation
- Integration tests for auth flow
- Security tests for token validation
[Test examples from their code]
## Security Considerations
From their code reviews:
- Always validate token signature
- Check expiration
- Implement rate limiting
- Use secure random for secrets
## Common Pitfalls They Avoid
- Storing tokens in localStorage (XSS risk)
- Not rotating refresh tokens
- Weak secret keys
- Missing token expiration
## Related Patterns
- Error handling for auth failures
- Middleware pattern for auth checks
- Repository pattern for user lookup
## Examples
See: examples/authentication_service.ts
Use Cases
1. Consistent Code Generation
Problem: AI generates code that doesn't match team style
Solution:
"Using expert-skills/senior-dev-mentor/, write a user service"
Result: Code matching senior dev's exact style and patterns
2. Task-Specific Guidance
Problem: How would senior dev approach this specific problem?
Solution:
"Using expert-skills/tech-lead-mentor/, how do I handle rate limiting?"
Result: Their specific approach, examples, and reasoning
3. Code Review Training
Problem: Learn what experienced engineer looks for
Solution:
"Using expert-skills/architect-mentor/, review this code"
Result: Review following their standards and priorities
4. Onboarding
Problem: New engineer needs to learn team conventions
Solution: Give them access to expert-skills
Result: Learn from real examples, specific to their tasks
Skill Query Examples
Example 1: Authentication
./query_expertise.sh
> Working on: Authentication
> Language: TypeScript
Output:
=== Authentication in TypeScript ===
Preferred approach: JWT with refresh tokens
[Shows specific auth pattern]
[Provides TS code example]
[Testing strategy]
[Security checklist]
Related: error_handling.md, api_design.md
Example 2: Database Design
./query_expertise.sh
> Working on: Database design
> Database: PostgreSQL
Output:
=== Database Design - PostgreSQL ===
Schema design approach:
- Normalized tables
- Foreign keys enforced
- Indexes on lookups
- Migrations for changes
[Shows migration example]
[Query optimization patterns]
[Testing approach]
Example 3: Error Handling
./query_expertise.sh
> Working on: Error handling
> Language: Python
Output:
=== Error Handling in Python ===
Pattern: Custom exception classes + global handler
[Shows exception hierarchy]
[Handler implementation]
[Logging approach]
[User-facing messages]
Creating a Skill
Basic Usage
cd engineer-skill-creator
./scripts/create_expert_skill.sh [engineer-username]
Advanced Usage
./scripts/create_expert_skill.sh [engineer-username] --focus api,testing
Limits skill to specific focus areas.
What Gets Generated
Automatic categorization:
- Groups related patterns
- Organizes by common tasks
- Separates by language
- Highlights best practices
Query system:
- Interactive CLI tool
- Smart search
- Related content linking
- Example suggestions
Documentation:
- Task-specific guides
- Language references
- Pattern library
- Quick reference cards
Integration with Development Workflow
In Claude Code
"Load the expert-skills/senior-dev-mentor/ skill and help me
implement this feature following their approach"
In Code Review
"Using expert-skills/tech-lead-mentor/, review this PR for:
- Code style compliance
- Pattern usage
- Best practices
- Security considerations"
In Architecture Decisions
"Using expert-skills/architect-mentor/, how would they design
this microservice?"
Skill Maintenance
Updating Skills
When engineer profile is updated:
./scripts/update_expert_skill.sh senior-dev
Re-generates skill with new expertise.
Version Control
Each skill generation includes:
- Source profile version
- Generation date
- Expertise count
- Last PR analyzed
Best Practices
When Creating Skills
DO:
- ✅ Create skills for different expertise areas
- ✅ Update skills regularly (quarterly)
- ✅ Test queries before deploying
- ✅ Document what the skill covers
DON'T:
- ❌ Create skills from insufficient data (< 20 PRs)
- ❌ Mix multiple engineers in one skill
- ❌ Ignore profile updates
- ❌ Over-categorize (keep it simple)
When Using Skills
DO:
- ✅ Ask specific questions
- ✅ Provide context (language, task)
- ✅ Reference examples
- ✅ Combine with your judgment
DON'T:
- ❌ Blindly copy patterns
- ❌ Skip understanding reasoning
- ❌ Ignore project context
- ❌ Treat as inflexible rules
Limitations
What Skills Can Do:
- ✅ Provide proven patterns
- ✅ Show real examples
- ✅ Guide implementation
- ✅ Explain reasoning
- ✅ Surface best practices
What Skills Cannot Do:
- ❌ Make decisions for you
- ❌ Understand your specific context
- ❌ Replace senior engineer judgment
- ❌ Guarantee correctness
- ❌ Adapt to new technologies automatically
Summary
The Engineer Skill Creator transforms extracted expertise into actionable, queryable skills:
Input: Engineer profile (from extractor)
Process: Categorize, organize, create query system
Output: Progressive disclosure skill
Benefits:
- Find expertise fast
- Get task-specific guidance
- Learn from real examples
- Maintain consistency
- Scale knowledge
Use with agents:
"Using expert-skills/[engineer]-mentor/, [task description]"
The complete workflow:
- Extract expertise:
extract_engineer.sh username
- Create skill:
create_expert_skill.sh username
- Use with agents: Reference skill in prompts
- Get consistent, expert-level results
"Progressive disclosure: Show only what's needed, when it's needed."
