
Growth Development
- 24 installs
- 3 repo stars
- Updated January 7, 2026
- pluginagentmarketplace/custom-plugin-engineering-manager
growth-development is a Claude Code skill for ai & agent building.
About
growth-development is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.
- growth-development
- AI & Agent Building
- AI-coding skill
Growth Development by the numbers
- 24 all-time installs (skills.sh)
- Ranked #9,876 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/pluginagentmarketplace/custom-plugin-engineering-manager --skill growth-developmentAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 24 |
|---|---|
| repo stars | ★ 3 |
| Last updated | January 7, 2026 |
| Repository | pluginagentmarketplace/custom-plugin-engineering-manager ↗ |
How do I helps with ai & agent building tasks.?
Helps with ai & agent building tasks.
Who is it for?
Best when you're working on ai & agent building and need structured help with growth development.
Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.
When should I use this skill?
When you need to helps with ai & agent building tasks., or when growth-development is a claude code skill for ai & agent building.
What you get
Structured output aligned to growth-development: growth-development, AI & Agent Building.
Files
Growth & Development Skill
Purpose
Provide engineering managers with comprehensive frameworks for career development, engineering ladders, individual development plans, succession planning, and building mentoring programs.
Primary Bond
Agent: growth-development-agent Relationship: This skill provides career ladder templates, IDP frameworks, and development tools that the agent uses.
---
Templates
Engineering Career Ladder
engineering_ladder:
individual_contributor_track:
L1_junior_engineer:
scope: "Task"
experience: "0-2 years"
expectations:
- "Completes well-defined tasks with guidance"
- "Learning codebase and practices"
- "Asks good questions"
- "Responds well to feedback"
technical_skills:
- "Fundamentals of primary language/framework"
- "Basic debugging and testing"
- "Version control basics"
behaviors:
- "Eager to learn"
- "Communicates blockers"
- "Follows team practices"
L2_engineer:
scope: "Feature"
experience: "2-4 years"
expectations:
- "Owns features end-to-end"
- "Writes production-quality code"
- "Participates in code reviews"
- "Mentors juniors informally"
technical_skills:
- "Proficient in primary stack"
- "Understands system architecture"
- "Writes comprehensive tests"
behaviors:
- "Self-directed"
- "Proactive communication"
- "Contributes to team discussions"
L3_senior_engineer:
scope: "System"
experience: "4-7 years"
expectations:
- "Designs and delivers complex systems"
- "Influences technical direction"
- "Mentors multiple engineers"
- "Improves team practices"
technical_skills:
- "Expert in primary domain"
- "Cross-functional knowledge"
- "Performance and scaling"
behaviors:
- "Technical leadership"
- "Drives consensus"
- "Identifies and mitigates risks"
L4_staff_engineer:
scope: "Multi-team"
experience: "7-10 years"
expectations:
- "Leads cross-team technical initiatives"
- "Sets technical strategy"
- "Builds organizational capability"
- "Influences beyond immediate team"
technical_skills:
- "Architectural expertise"
- "Technology evaluation"
- "Technical debt strategy"
behaviors:
- "Organizational influence"
- "Strategic thinking"
- "Develops other senior engineers"
L5_principal_engineer:
scope: "Organization"
experience: "10+ years"
expectations:
- "Shapes company-wide technical direction"
- "Solves ambiguous, high-impact problems"
- "Represents company externally"
- "Creates lasting organizational impact"
technical_skills:
- "Industry-recognized expertise"
- "Innovation leadership"
- "Technical vision"
behaviors:
- "Executive partnership"
- "Industry influence"
- "Develops staff engineers"
management_track:
M1_engineering_manager:
scope: "Team (5-8 engineers)"
experience: "5+ years engineering + management interest"
expectations:
- "Hires, develops, retains engineers"
- "Delivers team commitments"
- "Creates healthy team culture"
- "Runs effective processes"
people_skills:
- "1-on-1s and feedback"
- "Performance management"
- "Hiring and interviewing"
technical_involvement:
- "Technical context, not coding"
- "Architectural input"
- "Code review occasionally"
M2_senior_engineering_manager:
scope: "Large team (8-12) or 2 teams"
experience: "2+ years as EM"
expectations:
- "Manages managers or large team"
- "Drives significant initiatives"
- "Develops other managers"
- "Partners with product leadership"
people_skills:
- "Coaching managers"
- "Organizational design"
- "Conflict resolution"
M3_director:
scope: "Department (20-50 engineers)"
experience: "4+ years management"
expectations:
- "Sets department strategy"
- "Manages multiple teams"
- "Executive partnership"
- "Org-wide influence"
leadership_skills:
- "Strategic planning"
- "Budget management"
- "Cross-functional leadership"Individual Development Plan (IDP)
individual_development_plan:
metadata:
employee: "{Name}"
current_level: "{Level}"
target_level: "{Level}"
manager: "{Manager name}"
created: "{Date}"
review_date: "{Date}"
career_vision:
long_term: "Where do you want to be in 5 years?"
medium_term: "What's your 2-year goal?"
short_term: "What's your focus this year?"
current_assessment:
strengths:
- skill: "{Technical or soft skill}"
evidence: "{How this shows up in work}"
leverage_plan: "{How to use this more}"
growth_areas:
- skill: "{Skill to develop}"
current_state: "{Where you are now}"
target_state: "{Where you need to be}"
gap: "{What's missing}"
development_goals:
goal_1:
description: "{Specific, measurable goal}"
category: "{technical | leadership | communication | domain}"
success_criteria: "{How we'll know it's achieved}"
timeline: "{By when}"
actions:
- action: "{Specific step}"
deadline: "{Date}"
resources: "{Training, mentor, project}"
status: "{not_started | in_progress | completed}"
goal_2:
description: ""
category: ""
success_criteria: ""
timeline: ""
actions: []
goal_3:
description: ""
category: ""
success_criteria: ""
timeline: ""
actions: []
development_methods:
learning_mix:
experience: "70% - stretch assignments, projects"
exposure: "20% - mentoring, shadowing, networking"
education: "10% - courses, reading, conferences"
specific_opportunities:
stretch_assignments: []
mentors_sponsors: []
training_courses: []
conferences_events: []
support_needed:
from_manager:
- "{Specific support}"
from_organization:
- "{Resources, training, opportunities}"
from_mentors:
- "{Guidance areas}"
check_in_schedule:
frequency: "Monthly"
next_review: "{Date}"
progress_notes: []Succession Planning Framework
succession_planning:
critical_roles:
- role: "{Role title}"
current_holder: "{Name}"
risk_level: "{low | medium | high | critical}"
risk_factors:
- "{Single point of knowledge}"
- "{Flight risk}"
- "{Upcoming retirement}"
succession_candidates:
ready_now:
- name: "{Name}"
strengths: []
gaps: []
development_plan: ""
ready_1_2_years:
- name: "{Name}"
strengths: []
gaps: []
development_plan: ""
ready_3_5_years:
- name: "{Name}"
strengths: []
gaps: []
development_plan: ""
knowledge_transfer:
documented: []
in_progress: []
needed: []
talent_matrix:
dimensions:
performance: "Current job performance (1-5)"
potential: "Future growth potential (1-5)"
quadrants:
stars:
criteria: "High performance + High potential"
actions:
- "Accelerated development"
- "Visible stretch assignments"
- "Executive exposure"
- "Retention focus"
solid_performers:
criteria: "High performance + Lower potential"
actions:
- "Recognize and reward"
- "Deepen expertise"
- "Consider lateral moves"
- "Knowledge sharing role"
high_potentials:
criteria: "Developing performance + High potential"
actions:
- "Intensive coaching"
- "Skill development"
- "Patience with mistakes"
- "Clear expectations"
core_contributors:
criteria: "Developing performance + Lower potential"
actions:
- "Clear expectations"
- "Training if gaps"
- "Right role fit?"
- "Support or transition"
review_cadence:
full_review: "Annually"
talent_discussions: "Quarterly"
development_check_ins: "Monthly"Skill Gap Analysis
skill_gap_analysis:
team_assessment:
team: "{Team name}"
assessment_date: "{Date}"
assessor: "{Name}"
skill_inventory:
technical_skills:
- skill: "{Programming language}"
required_level: "{1-5}"
team_coverage:
- member: "{Name}"
level: "{1-5}"
gap_score: null
criticality: "{low | medium | high}"
- skill: "{Framework/Tool}"
required_level: ""
team_coverage: []
gap_score: null
criticality: ""
domain_skills:
- skill: "{Domain knowledge}"
required_level: ""
team_coverage: []
gap_score: null
criticality: ""
soft_skills:
- skill: "{Communication, leadership, etc.}"
required_level: ""
team_coverage: []
gap_score: null
criticality: ""
gap_analysis:
critical_gaps:
- skill: ""
current_state: ""
required_state: ""
impact: ""
mitigation:
short_term: "{Hire, contract, partner}"
long_term: "{Train, develop}"
moderate_gaps:
- skill: ""
development_plan: ""
nice_to_have:
- skill: ""
opportunistic_development: ""
action_plan:
hiring_needs: []
training_investments: []
mentoring_pairs: []
knowledge_sharing: []Mentoring Program Framework
mentoring_program:
program_structure:
name: "{Program name}"
duration: "{6 months recommended}"
cadence: "Bi-weekly 30-60 min sessions"
matching_criteria:
mentor_requirements:
- "2+ levels above mentee"
- "Different reporting chain preferred"
- "Relevant experience to goals"
- "Commitment to development"
mentee_requirements:
- "Clear development goals"
- "Commitment to process"
- "Open to feedback"
- "Willingness to be vulnerable"
program_phases:
kickoff:
duration: "Session 1"
activities:
- "Get to know each other"
- "Share backgrounds and goals"
- "Set expectations"
- "Agree on logistics"
outputs:
- "Mentoring agreement signed"
- "Goals documented"
- "Schedule set"
development:
duration: "Sessions 2-10"
activities:
- "Work on development goals"
- "Share experiences and advice"
- "Provide feedback"
- "Connect to opportunities"
typical_topics:
- "Career navigation"
- "Technical challenges"
- "Leadership development"
- "Organizational dynamics"
wrap_up:
duration: "Sessions 11-12"
activities:
- "Review progress on goals"
- "Celebrate achievements"
- "Plan for continued growth"
- "Provide program feedback"
success_metrics:
mentee_outcomes:
- "Goal achievement rate"
- "Promotion rate"
- "Engagement scores"
- "Retention rate"
program_health:
- "Match completion rate"
- "NPS from participants"
- "Session attendance"
- "Repeat participation"---
Decision Trees
Promotion Readiness Assessment
Promotion consideration
|
+-- Consistently meeting current level expectations?
| +-- No -> Not ready, focus on current level
| +-- Yes -> Continue
|
+-- Demonstrating next-level behaviors?
| +-- Rarely -> Not ready, create IDP
| +-- Sometimes -> Almost ready, targeted development
| +-- Consistently -> Continue
|
+-- Scope and impact at next level?
| +-- No opportunities yet -> Create stretch assignments
| +-- Has delivered at scope -> Continue
|
+-- Peer and stakeholder feedback positive?
| +-- Concerns -> Address feedback, reassess
| +-- Strong support -> Ready to promoteIC vs Management Track Decision
Career direction question
|
+-- What energizes them?
| +-- Solving hard technical problems -> IC track
| +-- Helping others succeed -> Consider management
| +-- Both -> Explore tech lead role first
|
+-- What's their impact style?
| +-- Individual mastery -> IC track
| +-- Multiplier through others -> Management track
|
+-- How do they handle ambiguity?
| +-- Prefer well-defined problems -> IC track
| +-- Comfortable with people complexity -> Management track
|
+-- Are they willing to let go of coding?
| +-- No -> IC track (even at Staff+)
| +-- Yes -> Management viable---
Anti-Patterns
anti_patterns:
promotion_as_retention:
symptom: "Promoting to prevent someone from leaving"
remedy:
- "Separate promotion from retention discussions"
- "Promote when ready, not when threatening"
- "Find other retention levers if not ready"
peter_principle:
symptom: "Promoting until incompetent"
remedy:
- "Assess readiness for next level, not current performance"
- "Trial periods for new responsibilities"
- "Safe path back if not working"
neglecting_solid_performers:
symptom: "All attention on high potentials"
remedy:
- "Recognize and value steady contributors"
- "Create growth within level"
- "Don't force everyone to climb"
one_size_fits_all:
symptom: "Same IDP template for everyone"
remedy:
- "Personalize to individual goals"
- "Multiple paths to senior levels"
- "Accommodate different learning styles"
mentoring_without_structure:
symptom: "Assigned mentors but no framework"
remedy:
- "Provide training for mentors"
- "Set clear expectations"
- "Regular check-ins on progress"---
Quick Reference Cards
Development Conversation Starters
conversation_starters:
aspirations:
- "Where do you see yourself in 2-3 years?"
- "What kind of work gives you energy?"
- "What would your ideal role look like?"
strengths:
- "What are you most proud of this year?"
- "What do others come to you for?"
- "When do you feel most confident?"
growth:
- "What skills would make you more effective?"
- "What's holding you back from the next level?"
- "What feedback have you received that stuck with you?"
support:
- "What do you need from me to grow?"
- "What opportunities would help your development?"
- "Who else should you be learning from?"Level Transition Indicators
| From | To | Key Indicators |
|---|---|---|
| Junior | Mid | Independent on features, consistent quality |
| Mid | Senior | System-level thinking, mentoring others |
| Senior | Staff | Cross-team influence, strategic thinking |
| IC | Manager | People focus, letting go of individual work |
70-20-10 Development Mix
70% - Experience (On-the-job)
- Stretch assignments
- New projects
- Cross-functional work
- Leading initiatives
20% - Exposure (Learning from others)
- Mentoring relationships
- Shadowing senior folks
- Networking
- Feedback conversations
10% - Education (Formal learning)
- Courses and certifications
- Books and articles
- Conferences
- Internal training---
Troubleshooting
| Problem | Root Cause | Solution |
|---|---|---|
| Unclear promotion criteria | Vague level expectations | Define observable behaviors per level |
| Stagnant careers | No development focus | Regular IDP discussions, stretch assignments |
| Poor mentor matches | Random pairing | Structured matching based on goals |
| High attrition of high potentials | Not developing fast enough | Accelerated development programs |
| Skill gaps not addressed | No systematic assessment | Annual skill gap analysis |
---
Validation Rules
input_validation:
development_goal:
type: string
min_length: 10
required: true
current_level:
type: enum
values: [junior, mid, senior, staff, principal, manager, senior_manager, director]
required: false
target_level:
type: enum
values: [junior, mid, senior, staff, principal, manager, senior_manager, director]
required: false
timeline:
type: enum
values: [6_months, 1_year, 2_years, 3_years, 5_years]
required: false---
Resources
Books:
- The Manager's Path - Camille Fournier
- An Elegant Puzzle - Will Larson
- Staff Engineer - Will Larson
- The Making of a Manager - Julie Zhuo
Frameworks:
- Engineering Ladders (various companies)
- 70-20-10 Learning Model
- 9-Box Talent Matrix
- Mentoring Best Practices (ATD)
Research:
- Center for Creative Leadership research
- Deloitte High-Impact Learning Culture
- Gallup strengths-based development
# growth-development Configuration
# Category: general
# Generated: 2025-12-30
skill:
name: growth-development
version: "1.0.0"
category: general
settings:
# Default settings for growth-development
enabled: true
log_level: info
# Category-specific defaults
validation:
strict_mode: false
auto_fix: false
output:
format: markdown
include_examples: true
# Environment-specific overrides
environments:
development:
log_level: debug
validation:
strict_mode: false
production:
log_level: warn
validation:
strict_mode: true
# Integration settings
integrations:
# Enable/disable integrations
git: true
linter: true
formatter: true
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "growth-development Configuration Schema",
"type": "object",
"properties": {
"skill": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"version": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+$"
},
"category": {
"type": "string",
"enum": [
"api",
"testing",
"devops",
"security",
"database",
"frontend",
"algorithms",
"machine-learning",
"cloud",
"containers",
"general"
]
}
},
"required": [
"name",
"version"
]
},
"settings": {
"type": "object",
"properties": {
"enabled": {
"type": "boolean",
"default": true
},
"log_level": {
"type": "string",
"enum": [
"debug",
"info",
"warn",
"error"
]
}
}
}
},
"required": [
"skill"
]
}Growth Development Guide
Overview
This guide provides comprehensive documentation for the growth-development skill in the custom-plugin-engineering-manager plugin.
Category: General
Quick Start
Prerequisites
- Familiarity with general concepts
- Development environment set up
- Plugin installed and configured
Basic Usage
# Invoke the skill
claude "growth-development - [your task description]"
# Example
claude "growth-development - analyze the current implementation"Core Concepts
Key Principles
1. Consistency - Follow established patterns 2. Clarity - Write readable, maintainable code 3. Quality - Validate before deployment
Best Practices
- Always validate input data
- Handle edge cases explicitly
- Document your decisions
- Write tests for critical paths
Common Tasks
Task 1: Basic Implementation
# Example implementation pattern
def implement_growth_development(input_data):
"""
Implement growth-development functionality.
Args:
input_data: Input to process
Returns:
Processed result
"""
# Validate input
if not input_data:
raise ValueError("Input required")
# Process
result = process(input_data)
# Return
return resultTask 2: Advanced Usage
For advanced scenarios, consider:
- Configuration customization via
assets/config.yaml - Validation using
scripts/validate.py - Integration with other skills
Troubleshooting
Common Issues
| Issue | Cause | Solution |
|---|---|---|
| Skill not found | Not installed | Run plugin sync |
| Validation fails | Invalid config | Check config.yaml |
| Unexpected output | Missing context | Provide more details |
Related Resources
- SKILL.md - Skill specification
- config.yaml - Configuration options
- validate.py - Validation script
---
Last updated: 2025-12-30
Growth Development Patterns
Design Patterns
Pattern 1: Input Validation
Always validate input before processing:
def validate_input(data):
if data is None:
raise ValueError("Data cannot be None")
if not isinstance(data, dict):
raise TypeError("Data must be a dictionary")
return TruePattern 2: Error Handling
Use consistent error handling:
try:
result = risky_operation()
except SpecificError as e:
logger.error(f"Operation failed: {e}")
handle_error(e)
except Exception as e:
logger.exception("Unexpected error")
raisePattern 3: Configuration Loading
Load and validate configuration:
import yaml
def load_config(config_path):
with open(config_path) as f:
config = yaml.safe_load(f)
validate_config(config)
return configAnti-Patterns to Avoid
❌ Don't: Swallow Exceptions
# BAD
try:
do_something()
except:
pass✅ Do: Handle Explicitly
# GOOD
try:
do_something()
except SpecificError as e:
logger.warning(f"Expected error: {e}")
return default_valueCategory-Specific Patterns: General
Recommended Approach
1. Start with the simplest implementation 2. Add complexity only when needed 3. Test each addition 4. Document decisions
Common Integration Points
- Configuration:
assets/config.yaml - Validation:
scripts/validate.py - Documentation:
references/GUIDE.md
---
Pattern library for growth-development skill
#!/usr/bin/env python3
"""
Validation script for growth-development skill.
Category: general
"""
import os
import sys
import yaml
import json
from pathlib import Path
def validate_config(config_path: str) -> dict:
"""
Validate skill configuration file.
Args:
config_path: Path to config.yaml
Returns:
dict: Validation result with 'valid' and 'errors' keys
"""
errors = []
if not os.path.exists(config_path):
return {"valid": False, "errors": ["Config file not found"]}
try:
with open(config_path, 'r') as f:
config = yaml.safe_load(f)
except yaml.YAMLError as e:
return {"valid": False, "errors": [f"YAML parse error: {e}"]}
# Validate required fields
if 'skill' not in config:
errors.append("Missing 'skill' section")
else:
if 'name' not in config['skill']:
errors.append("Missing skill.name")
if 'version' not in config['skill']:
errors.append("Missing skill.version")
# Validate settings
if 'settings' in config:
settings = config['settings']
if 'log_level' in settings:
valid_levels = ['debug', 'info', 'warn', 'error']
if settings['log_level'] not in valid_levels:
errors.append(f"Invalid log_level: {settings['log_level']}")
return {
"valid": len(errors) == 0,
"errors": errors,
"config": config if not errors else None
}
def validate_skill_structure(skill_path: str) -> dict:
"""
Validate skill directory structure.
Args:
skill_path: Path to skill directory
Returns:
dict: Structure validation result
"""
required_dirs = ['assets', 'scripts', 'references']
required_files = ['SKILL.md']
errors = []
# Check required files
for file in required_files:
if not os.path.exists(os.path.join(skill_path, file)):
errors.append(f"Missing required file: {file}")
# Check required directories
for dir in required_dirs:
dir_path = os.path.join(skill_path, dir)
if not os.path.isdir(dir_path):
errors.append(f"Missing required directory: {dir}/")
else:
# Check for real content (not just .gitkeep)
files = [f for f in os.listdir(dir_path) if f != '.gitkeep']
if not files:
errors.append(f"Directory {dir}/ has no real content")
return {
"valid": len(errors) == 0,
"errors": errors,
"skill_name": os.path.basename(skill_path)
}
def main():
"""Main validation entry point."""
skill_path = Path(__file__).parent.parent
print(f"Validating growth-development skill...")
print(f"Path: {skill_path}")
# Validate structure
structure_result = validate_skill_structure(str(skill_path))
print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}")
if structure_result['errors']:
for error in structure_result['errors']:
print(f" - {error}")
# Validate config
config_path = skill_path / 'assets' / 'config.yaml'
if config_path.exists():
config_result = validate_config(str(config_path))
print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}")
if config_result['errors']:
for error in config_result['errors']:
print(f" - {error}")
else:
print("\nConfig validation: SKIPPED (no config.yaml)")
# Summary
all_valid = structure_result['valid']
print(f"\n==================================================")
print(f"Overall: {'VALID' if all_valid else 'INVALID'}")
return 0 if all_valid else 1
if __name__ == "__main__":
sys.exit(main())
Related skills
FAQ
What does growth-development do?
growth-development is a Claude Code skill for ai & agent building.
When should I use growth-development?
When you need to helps with ai & agent building tasks., or when growth-development is a claude code skill for ai & agent building.
What are the main capabilities?
growth-development; AI & Agent Building; AI-coding skill.