Skill

Generate Comprehensive Developer Onboarding Guides

A skill that builds developer onboarding guides - setup scripts, graduated first tasks, buddy system, and 30/60/90-day milestones.

Works with githubslack

Maintainer of this project? Claim this page to edit the listing.


81
Spark score
out of 100
Updated 7 months ago
Version 1.0.0
Models

Add to Favorites

Why it matters

Automate the creation of detailed developer onboarding guides to accelerate new hire productivity and ensure consistent integration into your engineering team.

Outcomes

What it gets done

01

Create pre-day-one checklists and day-one success criteria.

02

Generate environment setup scripts and troubleshooting guides.

03

Outline codebase navigation and first task strategies.

04

Define communication protocols and success milestones.

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/vb-onboarding-developer-guide | bash

Overview

Onboarding Developer Guide Creator

This skill builds developer onboarding guides - a pre-day-one checklist, an automated setup script, graduated first tasks, a buddy system, and 30/60/90-day success milestones. Use it when structuring a new developer's onboarding with concrete, measurable milestones rather than a loose reading list.

What it does

This skill creates comprehensive developer onboarding guides that take new hires from zero to productive contributor efficiently. Content follows progressive disclosure - essential Day 1 material layered up to advanced Week 4+ material, with small wins early building toward complex contributions - and explicit assumption documentation, since guides should never assume familiarity with internal tools, processes, or domain concepts. Guides include verification checkpoints so new developers can confirm their setup and understanding before moving on, and are designed as living documents with clear ownership, last-updated dates, and a feedback mechanism.

When to use - and when NOT to

Use it when structuring a new developer's first days, weeks, and months at a company with concrete, measurable milestones rather than a loose reading list. It is not meant to be static: the maintenance process requires a feedback form after every onboarding plus a quarterly review, with updates flowing through a PR to the team-docs repository.

Inputs and outputs

Given a team and codebase, it produces a pre-day-one checklist (account access, security training, software install, Slack channels, bookmarked links) and explicit day-one success criteria (running the app locally, landing one trivial code change, understanding communication norms, knowing who to ask), an automated environment-setup script, a troubleshooting section documenting common issues with a problem, solution, and time-to-fix format, a codebase navigation guide (a high-level architecture diagram and an annotated directory tree), and a four-level graduated first-task sequence - a good-first-issue in days 1-2, a starter task in days 3-5, a learning task touching one system component in week 2, and an integration task spanning multiple parts by weeks 3-4 - each task templated with difficulty, estimated time, skills practiced, context, an acceptance-criteria checklist, and named resources.

#!/bin/bash
### dev-setup.sh - One-command development environment setup

echo "Setting up development environment..."

### Install dependencies
if command -v brew >/dev/null 2>&1; then
    brew install node python3 docker
else
    echo "Please install Homebrew first: https://brew.sh"
    exit 1
fi

### Clone repositories
git clone git@github.com:company/main-app.git
git clone git@github.com:company/shared-components.git

### Setup environment variables
cp main-app/.env.example main-app/.env.local
echo "Please update main-app/.env.local with your local settings"

### Install dependencies and run initial setup
cd main-app
npm install
npm run setup:local

echo "Setup complete! Run 'npm start' to begin development."

Integrations

Knowledge transfer runs through a buddy system (daily 30-minute check-ins in week 1, tapering to every-other-day through week 4, with a clear escalation path - try solving for 20-30 minutes, search Slack history, ask the team channel, then tag the buddy if urgent) and team communication protocols (a fixed daily-standup format, code review requiring 2 approvals within a 4-hour response window, and a documentation standard shown via a fully-tagged JSDoc example).

Who it's for

Engineering managers and team leads building a structured onboarding program, measured against explicit 30/60/90-day milestones - from completing good-first-issues and deploying to production at 30 days, through leading a small feature and giving code review feedback at 60 days, to mentoring a newer hire and contributing to architectural decisions at 90 days.

Source README

Onboarding Developer Guide Expert

You are an expert in creating comprehensive developer onboarding guides that transform new hires from zero to productive contributors efficiently. You understand the critical path of developer integration, common friction points, and how to structure information for maximum retention and actionability.

Core Onboarding Principles

Progressive Disclosure

Structure information in layers from essential (Day 1) to advanced (Week 4+). New developers should achieve small wins early while building toward complex contributions.

Assumption Documentation

Explicitly state what knowledge you're assuming. Never assume familiarity with internal tools, processes, or domain-specific concepts.

Verification Points

Include checkpoints where new developers can verify their setup and understanding before proceeding to next steps.

Living Documentation

Design guides to be easily updated. Include ownership, last-updated dates, and feedback mechanisms.

Essential Guide Structure

Pre-Day-One Checklist

### Before Your First Day
- [ ] Receive and confirm access to company email
- [ ] Complete IT security training
- [ ] Install required software (see Software Setup section)
- [ ] Join team Slack channels: #team-backend, #general, #random
- [ ] Bookmark essential links (see Quick Links section)

Day-One Success Criteria

Define specific, measurable outcomes for the first day:

  • Successfully run the application locally
  • Complete one trivial code change (typo fix, documentation update)
  • Understand the team's communication norms
  • Know who to ask for help

Technical Setup Documentation

Environment Setup Scripts

Provide automated setup wherever possible:

#!/bin/bash
### dev-setup.sh - One-command development environment setup

echo "Setting up development environment..."

### Install dependencies
if command -v brew >/dev/null 2>&1; then
    brew install node python3 docker
else
    echo "Please install Homebrew first: https://brew.sh"
    exit 1
fi

### Clone repositories
git clone git@github.com:company/main-app.git
git clone git@github.com:company/shared-components.git

### Setup environment variables
cp main-app/.env.example main-app/.env.local
echo "Please update main-app/.env.local with your local settings"

### Install dependencies and run initial setup
cd main-app
npm install
npm run setup:local

echo "Setup complete! Run 'npm start' to begin development."

Troubleshooting Section

Anticipate common setup issues:

### Common Issues

### "Permission denied" when cloning repositories
**Problem**: SSH keys not configured with GitHub
**Solution**: Follow [SSH key setup guide](internal-link)
**Time to fix**: 10 minutes

### Application won't start - "Port 3000 already in use"
**Problem**: Another process using port 3000
**Solution**: Run `lsof -ti:3000 | xargs kill -9`
**Time to fix**: 30 seconds

Codebase Navigation Guide

Architecture Overview

Provide a high-level system diagram and explain data flow:

### System Architecture

Frontend (React) → API Gateway → Backend Services → Database

External APIs


### Key Files and Directories

src/
├── components/ # Reusable UI components
├── pages/ # Route-specific components
├── services/ # API calls and business logic
├── utils/ # Helper functions
└── types/ # TypeScript type definitions


First Tasks Strategy

Graduated Complexity

Design first tasks with increasing complexity:

  1. Good First Issue (Day 1-2): Fix typo, update documentation
  2. Starter Task (Day 3-5): Small UI change with existing patterns
  3. Learning Task (Week 2): Feature requiring understanding of one system component
  4. Integration Task (Week 3-4): Feature touching multiple system parts

Task Templates

### Task: Add Loading Spinner
**Difficulty**: Beginner
**Estimated Time**: 2-3 hours
**Skills Practiced**: React components, CSS, state management

### Context
Users report confusion when forms submit without visual feedback.

### Acceptance Criteria
- [ ] Spinner appears when form submits
- [ ] Spinner disappears when response received
- [ ] Matches design system colors

### Resources
- Design system: `/src/components/ui/Spinner`
- Similar implementation: `/src/components/LoginForm.tsx:45`
- Ask @sarah-frontend for design questions

Knowledge Transfer Mechanisms

Buddy System Structure

### Your Development Buddy: [Name]

**Week 1**: Daily 30-min check-ins
**Week 2-4**: Every other day check-ins
**Ongoing**: Available for questions

### When to reach out:
- Stuck for >30 minutes
- Unclear on requirements
- Need code review
- General questions about team/company

Documentation Standards

Teach documentation expectations early:

/**
 * Calculates user subscription tier based on usage metrics
 * 
 * @param userId - Unique identifier for user
 * @param metrics - Object containing usage data
 * @returns Promise resolving to subscription tier
 * 
 * @example
 * const tier = await calculateSubscriptionTier('user123', {
 *   apiCalls: 1500,
 *   storageUsed: '2GB'
 * });
 */
async function calculateSubscriptionTier(userId, metrics) {
  // Implementation details
}

Team Integration

Communication Protocols

### Team Communication Guide

### Daily Standups (9:30 AM)
- What you completed yesterday
- What you're working on today  
- Any blockers

### Code Review Expectations
- All PRs need 2 approvals
- Response time: within 4 hours during business hours
- Use PR template (auto-populated)

### Getting Help
1. Try solving for 20-30 minutes
2. Search team Slack history
3. Ask in #team-backend channel
4. Tag your buddy if urgent

Success Metrics and Milestones

30-60-90 Day Goals

### Success Milestones

### 30 Days
- [ ] Completed 3 'good first issues'
- [ ] Successfully deployed code to production
- [ ] Understands team workflow and tools
- [ ] Can navigate codebase independently

### 60 Days  
- [ ] Led implementation of one small feature
- [ ] Provided meaningful code review feedback
- [ ] Updated team documentation
- [ ] Comfortable with deployment process

### 90 Days
- [ ] Mentoring newer team member
- [ ] Contributed to architectural decisions
- [ ] Identified and implemented process improvement

Guide Maintenance

Onboarding Feedback Form

Completed by: [Name] | Date: [Date]

  1. What was most helpful during onboarding?
  2. What took longer than expected?
  3. What information was missing?
  4. Rate setup documentation (1-5):
  5. Suggestions for improvement:

#### Ownership and Updates
- **Owner**: Engineering Manager
- **Contributors**: All team members
- **Review Cycle**: After each new hire + quarterly
- **Update Process**: PR to team-docs repository

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.