# Knowledge Sharing

> |---------|---------|

- Skill: `majiayu000/knowledge-sharing-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add majiayu000/knowledge-sharing-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/knowledge-sharing-2/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/majiayu000/knowledge-sharing-2

---


# Knowledge Sharing

## Why Knowledge Sharing Matters

| Benefit | Impact |
|---------|---------|
| **Reduce Silos** | Knowledge distributed across team |
| **Onboard Faster** | New hires learn quickly |
| **Team Resilience** | No single point of failure |
| **Innovation** | Cross-pollination of ideas |
| **Quality** | Better decisions through collaboration |

## Types of Knowledge

### Domain Knowledge

```markdown
# Domain Knowledge

## Business Domain
- E-commerce
- SaaS
- Marketplace

## Technical Domain
- Frontend (React, Vue, Angular)
- Backend (Node.js, Python, Go)
- Database (PostgreSQL, MongoDB)
```

### Technical Knowledge

```markdown
# Technical Knowledge

## Programming Languages
- JavaScript
- Python
- Go

## Frameworks
- React
- Express
- Django

## Tools
- Docker
- Kubernetes
- AWS
```

### Process Knowledge

```markdown
# Process Knowledge

## Development Process
- Git workflow
- Code review process
- Deployment process

## Testing Process
- Unit testing
- Integration testing
- E2E testing
```

### Tribal Knowledge

```markdown
# Tribal Knowledge

## Unwritten Rules
- How to handle edge cases
- Which tools to use when
- Who to ask for what

## Historical Context
- Why certain decisions were made
- What failed before
- What succeeded before
```

## Documentation

### READMEs

```markdown
# README

## Project Overview
This is a web application for e-commerce.

## Getting Started
```bash
npm install
npm start
```

## Development
```bash
npm run dev
```

## Testing
```bash
npm test
```

## Deployment
```bash
npm run deploy
```
```

### Wikis

```markdown
# Wiki

## Architecture
- System architecture
- Database schema
- API documentation

## Development
- Coding standards
- Git workflow
- Code review process

## Operations
- Deployment process
- Monitoring
- Incident response
```

### ADRs (Architecture Decision Records)

```markdown
# ADR-001: Use PostgreSQL as Database

## Status
Accepted

## Context
We need a database for our application.

## Decision
Use PostgreSQL as our primary database.

## Consequences
- Benefits:
  - ACID compliance
  - JSON support
  - Strong community
- Drawbacks:
  - Vertical scaling
  - More complex than NoSQL
```

## Tech Talks

### Internal Presentations

```markdown
# Tech Talk: Introduction to Kubernetes

## Overview
- What is Kubernetes?
- Why use Kubernetes?
- How to get started

## Agenda
1. Introduction to containers
2. Kubernetes architecture
3. Deploying applications
4. Scaling applications
5. Best practices

## Resources
- Official documentation
- Tutorials
- Examples
```

### Presentation Format

```markdown
# Presentation Template

## Title
[Title of talk]

## Speaker
[Speaker name]

## Duration
[Time]

## Agenda
1. [Topic 1]
2. [Topic 2]
3. [Topic 3]

## Content
[Detailed content]

## Q&A
[Time for questions]

## Resources
[Links to resources]
```

## Lunch and Learns

### Informal Sessions

```markdown
# Lunch and Learn: React Hooks

## Overview
- What are React Hooks?
- Why use Hooks?
- Common Hooks

## Agenda
1. Introduction to Hooks
2. useState Hook
3. useEffect Hook
4. Custom Hooks
5. Q&A

## Format
- 30-minute presentation
- 15-minute Q&A
- Bring your lunch!
```

### Session Ideas

| Topic | Duration | Audience |
|-------|----------|----------|
| **New Technology** | 30 min | All developers |
| **Best Practices** | 30 min | Specific team |
| **Case Study** | 45 min | All developers |
| **Tool Demo** | 30 min | Specific team |

## Pair Programming

### Learn by Doing

```javascript
// Pair programming
// Two developers, one workstation
// Driver: Types code
// Navigator: Reviews and guides

function calculateTotal(items) {
    // Driver types
    return items.reduce((sum, item) => sum + item.price, 0);

    // Navigator reviews
    // "Should we handle empty array?"
}
```

### Pair Programming Guidelines

```markdown
# Pair Programming Guidelines

## Roles
- Driver: Types code
- Navigator: Reviews and guides

## Switching
- Switch roles every 30 minutes
- Or after completing a feature

## Communication
- Talk through decisions
- Explain your thinking
- Ask questions
```

## Mob Programming

### Group Coding

```javascript
// Mob programming
// Entire team works together
// One driver, rest navigators
// Rotate driver every 15 minutes

function calculateTotal(items) {
    // Driver types
    // Navigators review and guide

    return items.reduce((sum, item) => sum + item.price, 0);
}
```

### Mob Programming Guidelines

```markdown
# Mob Programming Guidelines

## Roles
- Driver: Types code
- Navigators: Review and guide

## Rotation
- Rotate driver every 15 minutes
- Everyone gets to drive

## Communication
- Talk through decisions
- Explain your thinking
- Ask questions
```

## Show and Tell

### Demo Recent Work

```markdown
# Show and Tell: New Dashboard

## Overview
- What was built
- How it works
- Challenges faced

## Demo
- Live demo of dashboard
- Walk through features
- Show code

## Q&A
- Questions from team
- Discussion
```

### Show and Tell Format

```markdown
# Show and Tell Template

## Title
[Title of work]

## Speaker
[Speaker name]

## Duration
[Time]

## Overview
[What was built]

## Demo
[Live demo]

## Challenges
[Challenges faced]

## Lessons Learned
[What was learned]

## Q&A
[Time for questions]
```

## Office Hours

### Expert Availability

```markdown
# Office Hours: Frontend Development

## When
Every Tuesday, 2-3 PM

## Where
Zoom meeting

## What
- Ask questions
- Get help with code
- Discuss best practices

## Expert
[Expert name]
```

### Office Hours Topics

| Topic | Expert | Schedule |
|--------|---------|----------|
| **Frontend** | John Doe | Tuesdays 2-3 PM |
| **Backend** | Jane Smith | Wednesdays 2-3 PM |
| **DevOps** | Bob Johnson | Thursdays 2-3 PM |
| **Database** | Alice Brown | Fridays 2-3 PM |

## Mentorship Programs

### One-on-One Mentorship

```markdown
# Mentorship Program

## Mentor
[Experienced developer]

## Mentee
[New developer]

## Goals
- Learn codebase
- Improve skills
- Grow professionally

## Meetings
- Weekly 1-on-1
- Code review sessions
- Pair programming

## Resources
- Documentation
- Training materials
- Conferences
```

### Mentorship Guidelines

```markdown
# Mentorship Guidelines

## Responsibilities
- Mentor: Guide, teach, support
- Mentee: Learn, ask, practice

## Goals
- Set clear goals
- Track progress
- Celebrate achievements

## Communication
- Regular meetings
- Open communication
- Feedback loop
```

## Code Review as Learning

### Learn from Reviews

```javascript
// Code review feedback
// Learn from reviewer's comments

// Before:
function calculateTotal(items) {
    return items.reduce((sum, item) => sum + item.price, 0);
}

// Reviewer feedback:
// "Consider handling empty array"

// After:
function calculateTotal(items) {
    if (!items || items.length === 0) return 0;
    return items.reduce((sum, item) => sum + item.price, 0);
}
```

### Learning from Code Reviews

```markdown
# Learning from Code Reviews

## What to Learn
- Coding best practices
- Code style
- Design patterns
- Testing approaches

## How to Learn
- Read all review comments
- Ask questions
- Apply feedback
- Share learnings
```

## Post-Mortems

### Learn from Incidents

```markdown
# Post-Mortem: Database Outage

## Summary
- Date: 2024-01-15
- Duration: 30 minutes
- Impact: 50% of users affected

## Timeline
- 14:00: Database connection lost
- 14:05: Alert fired
- 14:10: Investigation started
- 14:20: Root cause identified
- 14:25: Fix deployed
- 14:30: System restored

## Root Cause
- Connection pool exhausted
- No monitoring on pool size

## Actions Taken
- Increased pool size
- Added monitoring
- Added alerts

## Lessons Learned
- Monitor connection pool size
- Set up alerts for pool exhaustion
```

## Architecture Decision Records

### Document Decisions

```markdown
# ADR-002: Use React for Frontend

## Status
Accepted

## Context
We need to choose a frontend framework.

## Decision
Use React as our primary frontend framework.

## Consequences
- Benefits:
  - Large community
  - Many libraries
  - Strong ecosystem
- Drawbacks:
  - Learning curve
  - Frequent updates
```

### ADR Template

```markdown
# ADR-[Number]: [Title]

## Status
[Proposed/Accepted/Rejected/Deprecated]

## Context
[What is the situation?]

## Decision
[What was decided?]

## Consequences
- Benefits:
  - [Benefit 1]
  - [Benefit 2]
- Drawbacks:
  - [Drawback 1]
  - [Drawback 2]
```

## Knowledge Base

### Confluence

```markdown
# Knowledge Base

## Architecture
- System architecture
- Database schema
- API documentation

## Development
- Coding standards
- Git workflow
- Code review process

## Operations
- Deployment process
- Monitoring
- Incident response
```

### Notion

```markdown
# Knowledge Base

## Getting Started
- Onboarding guide
- Development setup
- First commit

## Development
- Coding standards
- Git workflow
- Code review process

## Operations
- Deployment process
- Monitoring
- Incident response
```

## Recording Sessions

### For Async Viewing

```markdown
# Recording Sessions

## Tech Talks
- Record all tech talks
- Upload to shared drive
- Add to knowledge base

## Lunch and Learns
- Record sessions
- Share with team
- Archive for future reference

## Show and Tell
- Record demos
- Share with team
- Archive for future reference
```

### Recording Guidelines

```markdown
# Recording Guidelines

## Equipment
- Good microphone
- Clear audio
- Good lighting

## Content
- Clear presentation
- Good pacing
- Engaging

## Post-Production
- Edit if needed
- Add captions
- Upload to shared drive
```

## Onboarding Documentation

### Setup Guide

```markdown
# Onboarding Guide

## Day 1
- Setup development environment
- Clone repository
- Install dependencies
- Make first commit

## Week 1
- Complete first task
- Attend code review
- Join team meetings

## First Month
- Complete feature
- Attend tech talks
- Pair programming sessions
```

### Documentation Checklist

```markdown
# Documentation Checklist

## Getting Started
- [ ] Onboarding guide
- [ ] Development setup
- [ ] First commit guide

## Development
- [ ] Coding standards
- [ ] Git workflow
- [ ] Code review process

## Operations
- [ ] Deployment process
- [ ] Monitoring
- [ ] Incident response
```

## Measuring Knowledge Sharing

### Participation

```javascript
// Track participation
const participation = {
    techTalks: 10,
    lunchAndLearns: 5,
    showAndTell: 3,
    officeHours: 8,
    mentorshipSessions: 12
};
```

### Satisfaction

```javascript
// Track satisfaction
const satisfaction = {
    techTalks: 4.5,
    lunchAndLearns: 4.2,
    showAndTell: 4.8,
    officeHours: 4.6,
    mentorshipSessions: 4.9
};
```

## Building a Learning Culture

### Encourage Sharing

```markdown
# Encourage Sharing

## Recognition
- Recognize knowledge sharing
- Celebrate contributions
- Share success stories

## Incentives
- Time allocated for learning
- Budget for training
- Conference attendance

## Environment
- Safe to ask questions
- No stupid questions
- Collaborative atmosphere
```

### Learning Culture Checklist

```markdown
# Learning Culture Checklist

## Environment
- [ ] Safe to ask questions
- [ ] Collaborative atmosphere
- [ ] Recognition for sharing

## Resources
- [ ] Time allocated for learning
- [ ] Budget for training
- [ ] Access to resources

## Activities
- [ ] Regular tech talks
- [ ] Lunch and learns
- [ ] Show and tells
- [ ] Office hours
- [ ] Mentorship program
```

## Real Examples

### Knowledge Sharing Formats

```markdown
# Knowledge Sharing Formats

## Tech Talks
- Monthly tech talks
- 30-45 minutes
- Recorded for async viewing

## Lunch and Learns
- Weekly lunch and learns
- 30 minutes
- Informal setting

## Show and Tell
- Bi-weekly show and tells
- 15-20 minutes
- Demo recent work

## Office Hours
- Weekly office hours
- 1 hour
- Q&A format

## Mentorship
- Ongoing mentorship
- Weekly meetings
- One-on-one
```

## Summary Checklist

### Planning

- [ ] Knowledge sharing strategy defined
- [ ] Formats selected
- [ ] Schedule established
- [ ] Resources allocated
- [ ] Goals set

### Implementation

- [ ] Documentation created
- [ ] Tech talks scheduled
- [ ] Lunch and learns organized
- [ ] Show and tells planned
- [ ] Office hours set up

### Measurement

- [ ] Participation tracked
- [ ] Satisfaction measured
- [ ] Goals reviewed
- [ ] Adjustments made
- [ ] Success celebrated