Skip to main content
skill CX Codex

engineer-skill-creator — Claude Code skill: what it does

engineer-skill-creator builds a structured skill from an engineer profile, with focused lookups for tasks, languages, and patterns. Use it when an agent needs a developer’s specific coding approach.

MIT 137 installs ★ 236 updated 2026-01-14

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jamesrochabrun/skills --skill engineer-skill-creator -a claude-code
Open on GitHub

What engineer-skill-creator does

This skill takes a profile produced by engineer-expertise-extractor and turns it into a queryable knowledge structure. Expertise is grouped by task, programming language, design pattern, and quick-reference topic, so an agent can retrieve guidance for authentication, TypeScript, dependency injection, or another focused request.

The generated package includes SKILL.md, query_expertise.sh, Markdown files under expertise/by_task/, expertise/by_language/, expertise/by_pattern/, and expertise/quick_reference/, plus code examples. The create_expert_skill.sh script builds this package from the engineer profile.

A profile from engineer-expertise-extractor is required first; without a directory such as engineer_profiles/senior_dev/, there is no source profile to convert. Agents can query the resulting skill directly or use ./query_expertise.sh to browse its focused sections.

What it helps with

  • turn an engineer profile into a usable skill
  • organize coding expertise by task
  • retrieve a developer’s style for one language
  • find a pattern with an implementation example
  • limit agent context to the requested topic

Example prompts for the agent

  • Create a skill from engineer_profiles/senior_dev/ by running ./create_expert_skill.sh senior_dev.
  • Using expert-skills/senior-dev-mentor/, show how this engineer would implement authentication.
  • Run ./query_expertise.sh and find the engineer’s approach to dependency injection.

How to install engineer-skill-creator

1Skills CLI (Vercel)

npx skills add jamesrochabrun/skills --skill engineer-skill-creator -a claude-code

2Manually: put the files in place

~/.claude/skills/engineer-skill-creator/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/engineer-skill-creator/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about engineer-skill-creator

How do I install engineer-skill-creator in Claude Code?

Run npx skills add jamesrochabrun/skills --skill engineer-skill-creator -a claude-code, then open ~/.claude/skills/engineer-skill-creator/SKILL.md.

What does engineer-skill-creator do?

It converts an engineer profile into a structured skill that agents can query by task, language, or pattern. The results include related guidance, examples, and development practices.

What input does the skill creator need?

It needs a profile produced by engineer-expertise-extractor, such as engineer_profiles/senior_dev/. The result is a package like expert-skills/senior-dev-mentor/ with documentation, query support, and examples.

Source text

SKILL.md · MIT
---
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)
```bash
./extract_engineer.sh senior_dev
# Output: engineer_profiles/senior_dev/
```

### Step 2: Create Skill (THIS SKILL)
```bash
./create_expert_skill.sh senior_dev
# Output: expert-skills/senior-dev-mentor/
```

**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:**
1. Relevant patterns from `by_task/authentication.md`
2. Code examples from their auth PRs
3. Their testing approach for auth
4. Security considerations they use
5. 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:**
1. TypeScript-specific conventions
2. Type usage patterns
3. Interface design approach
4. Error handling in TS
5. Real TS examples

### Query by Pattern

**Agent asks:** "How do they implement dependency injection?"

**Skill provides:**
1. DI pattern from their code
2. Constructor injection examples
3. IoC container setup
4. Testing with DI
5. 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:
```bash
./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
1. **Analyze profile structure**
2. **Categorize by task** - Group related expertise
3. **Extract examples** - Pull relevant code samples
4. **Create navigation** - Build progressive disclosure system
5. **Generate queries** - Create query tool
6. **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`

```markdown
# 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
```bash
./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
```bash
./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
```bash
./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
```bash
cd engineer-skill-creator
./scripts/create_expert_skill.sh [engineer-username]
```

### Advanced Usage
```bash
./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:
```bash
./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:**
1. Extract expertise: `extract_engineer.sh username`
2. Create skill: `create_expert_skill.sh username`
3. Use with agents: Reference skill in prompts
4. Get consistent, expert-level results

---

**"Progressive disclosure: Show only what's needed, when it's needed."**

© jamesrochabrun · MIT · jamesrochabrun/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set23

The whole set →
releasing-macos-apps The releasing-macos-apps skill guides macOS app releases from version changes and code signing through DMG creation, Apple notarization, and Sparkle updates. CX Codex +1 210installs content-brief-generator The content-brief-generator skill builds structured briefs for articles, docs, landing pages, and other formats. Use it when a writer needs a clear audience, goal, outline, and SEO direction. CX Codex +1 207installs design-brief-generator design-brief-generator is a Claude Code skill that builds structured design briefs. It activates for requests about project requirements, goals, and design planning. CX Codex +1 181installs swift-concurrency A skill for building, reviewing, and refactoring Swift concurrency code. Use it for async/await, actors, isolation, and Swift 6+ migrations. CX Codex +1 151installs llm-router llm-router routes requests to OpenAI, Grok, Groq, DeepSeek or OpenRouter via SwiftOpenAI-CLI. Runs in agent mode, supports model selection and MCP tools. CX Codex +1 149installs engineer-expertise-extractor engineer-expertise-extractor — a skill that extracts an engineer's coding style, patterns, and best practices from GitHub contributions, building a structured knowledge base to replicate their expertise across a team. CX Codex +1 144installs technical-launch-planner technical-launch-planner is a Claude Code skill that plans technical product launches by assessing scope, building a work plan, and checking team and materials readiness. CX Codex +1 137installs git-worktrees git-worktrees is a Claude Code skill for running parallel sessions on separate branches without conflicts. It provides scripts to create, manage, and clean up isolated worktrees. CX Codex +1 135installs

Project sponsors

Companies that keep this analytics open