Claude Skills Guide

Claude Skills Onboarding for New Engineering Team Members

Joining a new engineering team means learning new tools, processes, and conventions Claude skills can accelerate this onboarding by automating documentation reviews, generating test scaffolds, and helping you understand codebase patterns faster. This guide covers the essential skills every new team member should configure during their first week.

Setting Up Your Claude Skills Environment

Before diving into team-specific workflows, ensure your Claude Code installation includes the core skills. The base installation provides document processing and code execution, but specialized skills unlock faster onboarding.

To see what skills you have available, list the files in your skills directory:

ls ~/.claude/skills/

Note: There is no /skills list command in Claude Code. Skills are plain Markdown files and are discovered by filename.

If you’re starting fresh, add these foundational skills first:

These five skills cover the majority of onboarding tasks, from reading architecture documents to validating your first pull requests.

Document Processing with the PDF Skill

New team members often receive architecture decision records, API specifications, and runbooks in PDF format. The pdf skill lets you extract and organize this information without switching between tools.

/pdf summarize the authentication flow from security-architecture-v2.pdf

/pdf extract all endpoint definitions from api-docs.pdf and output as markdown

/pdf find "rate limit" in the operations-manual.pdf and return surrounding context

This skill becomes particularly valuable when reviewing technical documentation during your first sprint. Instead of manually searching through long documents, you can ask specific questions and get targeted answers.

Test-Driven Development with the TDD Skill

Every team has different testing conventions — some prefer Jest, others use Pytest or RSpec. The tdd skill adapts to your team’s patterns when you provide context about your tech stack.

After cloning the repository, start by understanding the existing test structure:

/tdd analyze the test structure in ./tests/ and summarize the testing patterns used

When writing your first tests, provide the skill with examples from the codebase:

/tdd write unit tests for src/auth/token-validator.ts following the patterns in tests/unit/auth/

The skill generates tests that match your team’s naming conventions, fixture usage, and assertion styles. Review these generated tests to learn how your team structures test files.

Memory Management with the Supermemory Skill

Team knowledge lives in Slack threads, Google Docs, Notion pages, and engineering blog posts. The supermemory skill acts as your personal knowledge base, retrieving relevant context when you need it.

During your first two weeks, build your memory index:

/supermemory Remember: Our code review requires at least one approval from a senior engineer

/supermemory Remember: We use conventional commits with types: feat, fix, docs, refactor, test

/supermemory Remember: Deployments happen on Tuesdays and Thursdays after 2pm PT

Later, when you’re in a PR review or debugging session, retrieve this information instantly:

/supermemory What is the commit message format?

/supermemory What is the deployment process?

This skill reduces the number of Slack messages you need to send asking “how do we…” questions.

Frontend Workflows with Frontend-Design and Webapp-Testing

If your team works on web applications, the frontend-design and webapp-testing skills speed up UI development and validation.

The frontend-design skill helps you implement components correctly on the first attempt:

/frontend-design create a Button component matching our design system: primary variant, 40px height, 16px horizontal padding

/frontend-design verify that the LoginForm component follows accessibility guidelines for form inputs

The webapp-testing skill runs your application and validates behavior:

/webapp-testing run the login flow and verify that users see the dashboard after successful authentication

/webapp-testing take screenshots of the mobile navigation on viewport widths 375px and 768px

These skills validate your work against team standards without requiring manual browser testing for every change.

Practical Onboarding Workflow

Here’s a typical first-week workflow using these skills:

  1. Day 1-2: Read architecture docs using /pdf extract commands. Add key decisions to supermemory.

  2. Day 3: Run /tdd analyze on your team’s test suite. Write your first test following the patterns you discover.

  3. Day 4-5: Make your first code change. Use /frontend-design verify to check component implementation, then /webapp-testing run to validate the feature works.

  4. End of Week 1: Review your supermemory index and add any patterns you’ve learned about code style, PR requirements, or deployment processes.

This workflow ensures you learn by doing rather than passively reading documentation.

Skill Customization for Team Context

Once you’re comfortable with the base skills, customize them for your team’s specific needs. Many skills accept configuration options:

For the tdd skill, specify your test framework and patterns in your Claude settings:

{
  "tdd": {
    "framework": "jest",
    "assertionLibrary": "expect",
    "fixturePath": "./tests/fixtures/"
  }
}

For the webapp-testing skill, configure your local development URL:

{
  "webapp-testing": {
    "baseUrl": "http://localhost:3000",
    "viewport": {
      "width": 1280,
      "height": 720
    }
  }
}

These configurations make the skills feel like extensions of your team’s existing tools rather than generic utilities.

Creating a Team Onboarding CLAUDE.md

For team leads setting up the onboarding experience, a dedicated CLAUDE.md file transforms passive documentation into an interactive guide. Unlike architecture docs that explain what the code does, an onboarding CLAUDE.md explains how to work on the codebase effectively.

A well-structured onboarding CLAUDE.md addresses three core areas: project setup, coding conventions, and team workflow:

# Project Onboarding Guide

## Quick Start
1. Clone the repository
2. Run `npm install` in /frontend and /backend
3. Copy `.env.example` to `.env` and fill in values
4. Run `docker-compose up -d` to start local services
5. Execute `npm run dev` in both directories

## Important Paths
- `/backend/src/routes` - API endpoint definitions
- `/frontend/src/components` - React component library
- `/shared/types` - TypeScript definitions shared between services
- `/migrations` - Database migration files

## Coding Standards
- Use functional components with hooks in React
- Follow RESTful conventions for API routes
- Always include JSDoc comments for public functions
- Run `npm run lint` before committing

## Team Processes
- Create feature branches from `develop`, not `main`
- All PRs require one approval
- Use conventional commits: `feat:`, `fix:`, `docs:`
- Deployments happen on merge to `main`

## Using Skills During Onboarding

When working on new features, use these commands:

- `Load tdd skill` - Start with tests, then implementation
- `Load frontend-design skill` - Get component suggestions matching our design system
- `Load supermemory skill` - Build persistent context about our codebase

The key insight is treating CLAUDE.md as a specification layer rather than a static document. New developers can ask Claude Code to execute tasks described in the file, creating an interactive onboarding experience.

For larger teams, create role-specific loading instructions within the file:

## Role-Based Guides

Load these additional guides based on your role:
- For frontend work: load /docs/frontend-standards.md
- For backend work: load /docs/backend-standards.md
- For DevOps: load /docs/infrastructure-guide.md

## Common First Tasks for New Developers
1. Fix a "good first issue" labeled bug
2. Add a unit test for an existing feature
3. Update documentation for a component you modified

Version control your CLAUDE.md files alongside your code—this creates a historical record of how your team’s practices evolved. When conventions change, update the file and communicate the change to existing team members.

To measure onboarding effectiveness, track time-to-productivity metrics: can new hires make their first commit on day one? Complete a small feature by end of week one? If not, the CLAUDE.md likely needs improvement. The docx skill can generate onboarding progress reports, giving you structured feedback on which parts of onboarding create bottlenecks.

Building Your Personal Skill Stack

As you become more productive with Claude skills, you’ll naturally discover which ones fit your role best. Backend engineers might rely more heavily on pdf for reading protobuf definitions and API contracts. Frontend developers will find the frontend-design skill indispensable for matching pixel-perfect implementations.

The key insight is that these skills reduce friction during onboarding. Rather than spending hours searching for documentation or struggling with unfamiliar test patterns, you have intelligent assistance that understands your team’s conventions.

Start with the five skills listed above, build your supermemory index with team knowledge, and customize your configuration as you learn more about your team’s specific workflows.

Built by theluckystrike — More at zovo.one

Explore Our Developer Guides

© 2026 theluckystrike Developer Guides