Skip to main content
skill CX Codex

engineer-expertise-extractor — Claude Code skill: analyze coding style

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.

MIT 144 installs ★ 236 updated 2026-01-14

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

What engineer-expertise-extractor does

The skill parses pull requests, code changes, and comments from a GitHub user via the GitHub CLI (gh), then organizes findings into a folder hierarchy: coding style, recurring patterns, quality standards, architectural decisions, testing approaches, and code review feedback. Each category includes markdown documentation and real code examples grouped by language or pattern type.

Helpful when onboarding new engineers, capturing senior expertise before turnover, or aligning team standards on a proven approach. The skill runs locally—you just need gh in your PATH and access to the target repositories.

What it helps with

  • Document an expert engineer's coding approach and decisions before they leave
  • Speed up onboarding with real examples of coding style and architectural thinking
  • Align team standards by extracting and sharing proven practices from a lead developer
  • Build reusable reference material from pull request history and feedback patterns

Example prompts for the agent

  • Extract coding style from Linus Torvalds' repositories across all languages
  • Build an expertise profile for developer octocat focused on TypeScript and Python patterns
  • Generate architecture decision documentation from Guido van Rossum's pull requests

How to install engineer-expertise-extractor

1Skills CLI (Vercel)

npx skills add jamesrochabrun/skills --skill engineer-expertise-extractor -a claude-code

2Manually: put the files in place

~/.claude/skills/engineer-expertise-extractor/SKILL.md

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

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

Questions about engineer-expertise-extractor

How do I install engineer-expertise-extractor in Claude Code?

Run npx skills add jamesrochabrun/skills --skill engineer-expertise-extractor -a claude-code, then open ~/.claude/skills/engineer-expertise-extractor/SKILL.md for the skill instructions.

What does engineer-expertise-extractor do?

The skill analyzes a GitHub user's repositories, extracts their coding patterns, style conventions, best practices, and architectural decisions, then organizes everything into documented folders with real code examples so your team can replicate their approach.

What do I need to run this skill?

GitHub CLI (gh) installed and authenticated on your system, plus access to the target engineer's repositories—the skill handles fetching and analyzing the rest.

Source text

SKILL.md · MIT
---
name: engineer-expertise-extractor
description: Research and extract an engineer's coding style, patterns, and best practices from their GitHub contributions. Creates structured knowledge base for replicating their expertise.
---

# Engineer Expertise Extractor

Extract and document an engineer's coding expertise by analyzing their GitHub contributions, creating a structured knowledge base that captures their coding style, patterns, best practices, and architectural decisions.

## What This Skill Does

Researches an engineer's work to create a "digital mentor" by:
- **Analyzing Pull Requests** - Extract code patterns, review style, decisions
- **Extracting Coding Style** - Document their preferences and conventions
- **Identifying Patterns** - Common solutions and approaches they use
- **Capturing Best Practices** - Their quality standards and guidelines
- **Organizing Examples** - Real code samples from their work
- **Documenting Decisions** - Architectural choices and reasoning

## Why This Matters

**Knowledge Preservation:**
- Capture expert knowledge before they leave
- Document tribal knowledge
- Create mentorship materials
- Onboard new engineers faster

**Consistency:**
- Align team coding standards
- Replicate expert approaches
- Maintain code quality
- Scale expertise across team

**Learning:**
- Learn from senior engineers
- Understand decision-making
- See real-world patterns
- Improve code quality

## How It Works

### 1. Research Phase
Using GitHub CLI (`gh`), the skill:
- Fetches engineer's pull requests
- Analyzes code changes
- Reviews their comments and feedback
- Extracts patterns and conventions
- Identifies their expertise areas

### 2. Analysis Phase
Categorizes findings into:
- **Coding Style** - Formatting, naming, structure
- **Patterns** - Common solutions and approaches
- **Best Practices** - Quality guidelines
- **Architecture** - Design decisions
- **Testing** - Testing approaches
- **Code Review** - Feedback patterns
- **Documentation** - Doc style and practices

### 3. Organization Phase
Creates structured folders:
```
engineer_profiles/
└── [engineer_name]/
    ├── README.md (overview)
    ├── coding_style/
    │   ├── languages/
    │   ├── naming_conventions.md
    │   ├── code_structure.md
    │   └── formatting_preferences.md
    ├── patterns/
    │   ├── common_solutions.md
    │   ├── design_patterns.md
    │   └── code_examples/
    ├── best_practices/
    │   ├── code_quality.md
    │   ├── testing_approach.md
    │   ├── performance.md
    │   └── security.md
    ├── architecture/
    │   ├── design_decisions.md
    │   ├── tech_choices.md
    │   └── trade_offs.md
    ├── code_review/
    │   ├── feedback_style.md
    │   ├── common_suggestions.md
    │   └── review_examples.md
    └── examples/
        ├── by_language/
        ├── by_pattern/
        └── notable_prs/
```

## Output Structure

### Engineer Profile README

**Contains:**
- Engineer overview
- Areas of expertise
- Languages and technologies
- Key contributions
- Coding philosophy
- How to use this profile

### Coding Style Documentation

**Captures:**
- Naming conventions (variables, functions, classes)
- Code structure preferences
- File organization
- Comment style
- Formatting preferences
- Language-specific idioms

**Example:**
```markdown
# Coding Style: [Engineer Name]

## Naming Conventions

### Variables
- Use descriptive names: `userAuthentication` not `ua`
- Boolean variables: `isActive`, `hasPermission`, `canEdit`
- Collections: plural names `users`, `items`, `transactions`

### Functions
- Verb-first: `getUserById`, `validateInput`, `calculateTotal`
- Pure functions preferred
- Single responsibility

### Classes
- PascalCase: `UserService`, `PaymentProcessor`
- Interface prefix: `IUserRepository`
- Concrete implementations: `MongoUserRepository`

## Code Structure

### File Organization
- One class per file
- Related functions grouped together
- Tests alongside implementation
- Clear separation of concerns

### Function Length
- Max 20-30 lines preferred
- Extract helper functions
- Single level of abstraction
```

### Patterns Documentation

**Captures:**
- Recurring solutions
- Design patterns used
- Architectural patterns
- Problem-solving approaches

**Example:**
```markdown
# Common Patterns: [Engineer Name]

## Dependency Injection

Used consistently across services:

\`\`\`typescript
// Pattern: Constructor injection
class UserService {
  constructor(
    private readonly userRepo: IUserRepository,
    private readonly logger: ILogger
  ) {}
}
\`\`\`

**Why:** Testability, loose coupling, clear dependencies

## Error Handling

Consistent error handling approach:

\`\`\`typescript
// Pattern: Custom error types + global handler
class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'ValidationError';
  }
}

// Usage
if (!isValid(input)) {
  throw new ValidationError('Invalid input format');
}
\`\`\`

**Why:** Type-safe errors, centralized handling, clear debugging
```

### Best Practices Documentation

**Captures:**
- Quality standards
- Testing approaches
- Performance guidelines
- Security practices
- Documentation standards

**Example:**
```markdown
# Best Practices: [Engineer Name]

## Testing

### Unit Test Structure
- AAA pattern (Arrange, Act, Assert)
- One assertion per test preferred
- Test names describe behavior
- Mock external dependencies

\`\`\`typescript
describe('UserService', () => {
  describe('createUser', () => {
    it('should create user with valid data', async () => {
      // Arrange
      const userData = { email: '[email protected]', name: 'Test' };
      const mockRepo = createMockRepository();

      // Act
      const result = await userService.createUser(userData);

      // Assert
      expect(result.id).toBeDefined();
      expect(result.email).toBe(userData.email);
    });
  });
});
\`\`\`

### Test Coverage
- Aim for 80%+ coverage
- 100% coverage for critical paths
- Integration tests for APIs
- E2E tests for user flows

## Code Review Standards

### What to Check
- [ ] Tests included and passing
- [ ] No console.logs remaining
- [ ] Error handling present
- [ ] Comments explain "why" not "what"
- [ ] No hardcoded values
- [ ] Security considerations addressed
```

### Architecture Documentation

**Captures:**
- Design decisions
- Technology choices
- Trade-offs made
- System design approaches

**Example:**
```markdown
# Architectural Decisions: [Engineer Name]

## Decision: Microservices vs Monolith

**Context:** Scaling user service
**Decision:** Start monolith, extract services when needed
**Reasoning:**
- Team size: 5 engineers
- Product stage: MVP
- Premature optimization risk
- Easier debugging and deployment

**Trade-offs:**
- Monolith pros: Simpler, faster development
- Monolith cons: Harder to scale later
- Decision: Optimize for current needs, refactor when hitting limits

## Decision: REST vs GraphQL

**Context:** API design for mobile app
**Decision:** REST with versioning
**Reasoning:**
- Team familiar with REST
- Simple use cases
- Caching easier
- Over-fetching not a problem yet

**When to reconsider:** If frontend needs complex queries
```

### Code Review Documentation

**Captures:**
- Feedback patterns
- Review approach
- Common suggestions
- Communication style

**Example:**
```markdown
# Code Review Style: [Engineer Name]

## Review Approach

### Priority Order
1. Security vulnerabilities
2. Logic errors
3. Test coverage
4. Code structure
5. Naming and style

### Feedback Style
- Specific and constructive
- Explains "why" behind suggestions
- Provides examples
- Asks questions to understand reasoning

### Common Suggestions

**Security:**
- "Consider input validation here"
- "This query is vulnerable to SQL injection"
- "Should we rate-limit this endpoint?"

**Performance:**
- "This N+1 query could be optimized with a join"
- "Consider caching this expensive operation"
- "Memoize this pure function"

**Testing:**
- "Can we add a test for the error case?"
- "What happens if the API returns null?"
- "Let's test the boundary conditions"

**Code Quality:**
- "Can we extract this into a helper function?"
- "This function is doing too many things"
- "Consider a more descriptive variable name"
```

## Using This Skill

### Extract Engineer Profile

```bash
./scripts/extract_engineer.sh [github-username]
```

**Interactive workflow:**
1. Enter GitHub username
2. Select repository scope (all/specific org)
3. Choose analysis depth (last N PRs)
4. Specify focus areas (languages, topics)
5. Extract and organize findings

**Output:** Structured profile in `engineer_profiles/[username]/`

### Analyze Specific Repository

```bash
./scripts/analyze_repo.sh [repo-url] [engineer-username]
```

Focuses analysis on specific repository contributions.

### Update Existing Profile

```bash
./scripts/update_profile.sh [engineer-username]
```

Adds new PRs and updates existing profile.

## Research Sources

### GitHub CLI Queries

**Pull Requests:**
```bash
gh pr list --author [username] --limit 100 --state all
gh pr view [pr-number] --json title,body,files,reviews,comments
```

**Code Changes:**
```bash
gh pr diff [pr-number]
gh api repos/{owner}/{repo}/pulls/{pr}/files
```

**Reviews:**
```bash
gh pr view [pr-number] --comments
gh api repos/{owner}/{repo}/pulls/{pr}/reviews
```

**Commits:**
```bash
gh api search/commits --author [username]
```

### Analysis Techniques

**Pattern Recognition:**
- Identify recurring code structures
- Extract common solutions
- Detect naming patterns
- Find architectural choices

**Style Extraction:**
- Analyze formatting consistency
- Extract naming conventions
- Identify comment patterns
- Detect structural preferences

**Best Practice Identification:**
- Look for testing patterns
- Find error handling approaches
- Identify security practices
- Extract performance optimizations

## Use Cases

### 1. Onboarding New Engineers

**Problem:** New engineer needs to learn team standards
**Solution:** Provide senior engineer's profile as reference

**Benefits:**
- Real examples from codebase
- Understand team conventions
- See decision-making process
- Learn best practices

### 2. Code Review Training

**Problem:** Teaching good code review skills
**Solution:** Study experienced reviewer's feedback patterns

**Benefits:**
- Learn what to look for
- Understand feedback style
- See common issues
- Improve review quality

### 3. Knowledge Transfer

**Problem:** Senior engineer leaving, knowledge lost
**Solution:** Extract their expertise before departure

**Benefits:**
- Preserve tribal knowledge
- Document decisions
- Maintain code quality
- Reduce bus factor

### 4. Establishing Team Standards

**Problem:** Inconsistent coding styles across team
**Solution:** Extract patterns from best engineers, create standards

**Benefits:**
- Evidence-based standards
- Real-world examples
- Buy-in from team
- Consistent codebase

### 5. AI Agent Training

**Problem:** Agent needs to code like specific engineer
**Solution:** Provide extracted profile to agent

**Benefits:**
- Match expert's style
- Follow their patterns
- Apply their best practices
- Maintain consistency

## Profile Usage by Agents

When an agent has access to an engineer profile, it can:

**Code Generation:**
- Follow extracted naming conventions
- Use identified patterns
- Apply documented best practices
- Match architectural style

**Code Review:**
- Provide feedback in engineer's style
- Check for common issues they'd catch
- Apply their quality standards
- Match their priorities

**Problem Solving:**
- Use their common solutions
- Follow their architectural approach
- Apply their design patterns
- Consider their trade-offs

**Example Agent Prompt:**
```
"Using the profile at engineer_profiles/senior_dev/, write a user service
following their coding style, patterns, and best practices. Pay special
attention to their error handling approach and testing standards."
```

## Best Practices

### Research Ethics

**DO:**
- ✅ Get permission before extracting
- ✅ Focus on public contributions
- ✅ Respect privacy
- ✅ Use for learning and improvement

**DON'T:**
- ❌ Extract without permission
- ❌ Share profiles externally
- ❌ Include sensitive information
- ❌ Use for performance reviews

### Profile Maintenance

**Regular Updates:**
- Refresh every quarter
- Add new significant PRs
- Update with latest patterns
- Archive outdated practices

**Quality Control:**
- Verify extracted patterns
- Review examples for relevance
- Update documentation
- Remove deprecated practices

### Effective Usage

**For Learning:**
- Study patterns with context
- Understand reasoning behind choices
- Practice applying techniques
- Ask questions when unclear

**For Replication:**
- Start with style guide
- Reference patterns for similar problems
- Adapt to current context
- Don't blindly copy

## Limitations

**What This Extracts:**
- ✅ Coding style and conventions
- ✅ Common patterns and approaches
- ✅ Best practices and guidelines
- ✅ Architectural decisions
- ✅ Review feedback patterns

**What This Doesn't Capture:**
- ❌ Real-time problem-solving process
- ❌ Verbal communication style
- ❌ Meeting discussions
- ❌ Design phase thinking
- ❌ Interpersonal mentoring

## Future Enhancements

**Potential additions:**
- Slack message analysis (communication style)
- Design doc extraction (design thinking)
- Meeting notes analysis (decision process)
- Video analysis (pair programming sessions)
- Code metrics tracking (evolution over time)

## Example Output

```
engineer_profiles/
└── senior_dev/
    ├── README.md
    │   # Senior Dev - Staff Engineer
    │   Expertise: TypeScript, Node.js, System Design
    │   Focus: API design, performance optimization
    │
    ├── coding_style/
    │   ├── typescript_style.md
    │   ├── naming_conventions.md
    │   └── code_structure.md
    │
    ├── patterns/
    │   ├── dependency_injection.md
    │   ├── error_handling.md
    │   └── examples/
    │       ├── service_pattern.ts
    │       └── repository_pattern.ts
    │
    ├── best_practices/
    │   ├── testing_strategy.md
    │   ├── code_quality.md
    │   └── performance.md
    │
    ├── architecture/
    │   ├── api_design.md
    │   ├── database_design.md
    │   └── scaling_approach.md
    │
    ├── code_review/
    │   ├── feedback_examples.md
    │   └── review_checklist.md
    │
    └── examples/
        └── notable_prs/
            ├── pr_1234_auth_refactor.md
            └── pr_5678_performance_fix.md
```

## Summary

This skill transforms an engineer's GitHub contributions into a structured, reusable knowledge base. It captures their expertise in a format that:

- **Humans can learn from** - Clear documentation with examples
- **Agents can replicate** - Structured patterns and guidelines
- **Teams can adopt** - Evidence-based best practices
- **Organizations can preserve** - Knowledge that survives turnover

**The goal:** Make expertise scalable, learnable, and replicable.

---

**"The best way to learn is from those who have already mastered it."**

© jamesrochabrun · MIT · jamesrochabrun/skills

Similar skills

All skills for Code review and refactoring →
Git Repository Analysis and Knowledge Base Construction oasiszeng Git Repository Analysis and Knowledge Base Construction is a prompt that analyzes GitHub commit history and code structure to create onboarding documentation. GP ChatGPT ★ 178,201repo stars expertise-candidate-author ShuaiMXu expertise-candidate-author is a Claude Code skill that drafts general guidelines from recurring human decisions. It keeps context links and edge cases visible. CX Codex +1 ★ 529repo stars github-research lingzhi227 github-research finds open-source repositories matching research topics, inspects their codebases, and produces an integration blueprint. Useful when tracking down implementations of algorithms. CX Codex +1 1,800installs translation-expertise shino369 translation-expertise gives the agent a translation method for English, Japanese and Traditional Chinese: idioms, cultural nuance, one consistent style across a document. CX Codex +1 675installs source-driven-development addyosmani source-driven-development grounds agent coding decisions in official documentation. It helps verify framework APIs against detected versions and avoids outdated patterns from model training data. CX Codex +1 74,200installs spec-miner https://github.com/Jeffallan spec-miner — a skill for Claude Code, Codex, Cursor and other agents that reads undocumented code and produces a written specification. Runs on inherited or legacy projects where there is no documentation to start from. CX Codex +1 4,900installs

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 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 engineer-skill-creator 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. 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