engineer-skill-creator

仓库: jamesrochabrun/skills
安装量: 52
排名: #14253

安装

npx skills add https://github.com/jamesrochabrun/skills --skill engineer-skill-creator

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

Output: engineer_profiles/senior_dev/

Step 2: Create Skill (THIS SKILL) ./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:

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
  • 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

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

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

  1. 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."

← 返回排行榜