enuno/claude-command-and-control/scribe-role-skill

Scribe Role Skill

Description

Create and maintain comprehensive, accurate, and user-friendly documentation for codebases, APIs, deployment processes, and end-user guides. This skill implements professional technical writing practices including documentation planning, structured content creation, and maintenance workflows.

When to Use This Skill

• Creating project documentation (README, guides, etc.)
• Documenting APIs and endpoints
• Writing deployment and build instructions
• Creating user manuals and usage guides
• Documenting system architecture (with architect)
• Developing onboarding materials for new developers
• Maintaining and updating existing documentation

When NOT to Use This Skill

• For system architecture design (use architect-role-skill)
• For code implementation (use builder-role-skill)
• For infrastructure deployment (use devops-role-skill)
• For testing procedures (use validator-role-skill)

Prerequisites

• Access to project source code for analysis
• Understanding of target audience (developers vs end-users)
• Existing documentation to review (if updating)
• Access to architectural and planning documents

Workflow

Phase 1: Comprehensive Project Documentation

Create complete documentation suite for a project.

Step 1.1: Codebase Analysis

# Understand project structure
tree -L 3 -I 'node_modules|.git|dist|build'
 
# Identify main entry points
find . -name "index.*" -o -name "main.*" -o -name "app.*" | grep -v node_modules
 
# Review package manifest
cat package.json || cat requirements.txt || cat pom.xml || cat Cargo.toml
 
# Check existing documentation
find . -name "*.md" -o -name "*.rst" | grep -v node_modules

Step 1.2: Documentation Planning

Create DOCUMENTATION_PLAN.md:

# Documentation Plan: [Project Name]
 
## Current State Assessment
-Existing docs: [List what exists]
-Documentation gaps: [What's missing]
-Outdated sections: [What needs updating]
 
## Documentation Structure

docs/ ├── README.md # Project overview ├── GETTING_STARTED.md # Quick start guide ├── BUILDING.md # Build instructions ├── DEPLOYMENT.md # Deployment guide ├── USAGE.md # User manual ├── API.md # API reference ├── ARCHITECTURE.md # System architecture ├── CONTRIBUTING.md # Contribution guidelines ├── TROUBLESHOOTING.md # Common issues └── CHANGELOG.md # Version history

 
## Priority
 
1. **Critical (Must Have)**:
   - README.md
   - BUILDING.md
   - DEPLOYMENT.md
 
2. **Important (Should Have)**:
   - API.md
   - USAGE.md
   - TROUBLESHOOTING.md
 
3. **Nice to Have**:
   - ARCHITECTURE.md (if not done by architect)
   - CONTRIBUTING.md
   - Advanced guides
 
## Timeline
- Phase 1 (Critical): Immediate
- Phase 2 (Important): Next sprint
- Phase 3 (Nice to Have): Following sprint

Step 1.3: Create Core Documentation

README.md Template

# [Project Name]
 
[One-sentence description of what this project does]
 
## Overview
 
[2-3 paragraph description covering:
-What problem does this solve?
-Who is it for?
-What are the key features?]
 
## Quick Start
 

Clone the repository

git clone [repository-url] cd [project-name]

Install dependencies

npm install # or pip install -r requirements.txt, etc.

Run the application

npm start # or python main.py, etc.

 
## Features
 
- **Feature 1**: Description
- **Feature 2**: Description
- **Feature 3**: Description
 
## Documentation
 
- [Getting Started Guide](docs/GETTING_STARTED.md)
- [Building Instructions](docs/BUILDING.md)
- [Deployment Guide](docs/DEPLOYMENT.md)
- [API Documentation](docs/API.md)
- [User Manual](docs/USAGE.md)
 
## Requirements
 
- [Runtime/Language]: version X.X+
- [Database]: version Y.Y+ (if applicable)
- [Other dependencies]
 
## Installation
 
See [GETTING_STARTED.md](docs/GETTING_STARTED.md) for detailed installation instructions.
 
## Usage
 
See [USAGE.md](docs/USAGE.md) for comprehensive usage documentation.
 
## Contributing
 
See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
 
## License
 
[License type and link]
 
## Support
 
- Issues: [GitHub issues link]
- Documentation: [Documentation link]
- Community: [Discord/Slack/Forum link]
 
## Credits
 
[Acknowledgments, authors, contributors]

BUILDING.md Template

# Building [Project Name]
 
This guide covers how to build the application from source.
 
## Prerequisites
 
### Required Tools
-[Tool 1]: version X.X+ ([installation link])
-[Tool 2]: version Y.Y+ ([installation link])
-[Tool 3]: version Z.Z+ ([installation link])
 
### Optional Tools
-[Tool]: For [purpose]
 
## Environment Setup
 
### macOS

Install dependencies

brew install [package1] [package2]

Set environment variables

export VAR_NAME=value

 
### Linux (Ubuntu/Debian)

Install dependencies

sudo apt-get update sudo apt-get install [package1] [package2]

Set environment variables

export VAR_NAME=value

 
### Windows

Install dependencies using chocolatey

choco install [package1] [package2]

Set environment variables

$env:VAR_NAME="value"

 
## Building the Application
 
### Development Build

Install dependencies

npm install # or equivalent

Build for development

npm run build:dev

Output location: ./dist/

 
### Production Build

Clean previous builds

npm run clean

Install production dependencies

npm ci --production

Build optimized version

npm run build:prod

Output location: ./dist/production/

 
### Build Configuration
 
Configuration files:
- `build.config.js`: Main build configuration
- `.env.build`: Build-time environment variables
- `webpack.config.js`: Bundler configuration (if applicable)
 
Key configuration options:

{ mode: 'production', // production | development optimization: true, // Enable optimizations minify: true, // Minify output sourceMaps: false // Generate source maps }

 
## Build Artifacts
 
After successful build, the following artifacts are generated:
 

dist/ ├── app.[hash].js # Main application bundle ├── vendor.[hash].js # Third-party dependencies ├── styles.[hash].css # Compiled styles ├── assets/ # Static assets │ ├── images/ │ └── fonts/ └── index.html # Entry point

 
## Build Troubleshooting
 
### Common Issues
 
**Issue**: Build fails with "out of memory" error

Solution: Increase Node memory limit

export NODE_OPTIONS="--max-old-space-size=4096" npm run build

 
**Issue**: Dependency resolution fails

Solution: Clear cache and reinstall

rm -rf node_modules package-lock.json npm cache clean --force npm install

 
**Issue**: Module not found errors

Solution: Verify all dependencies installed

npm list --depth=0 npm install [missing-package]

 
## Continuous Integration Builds
 
This project uses [CI system] for automated builds.
 
Build triggers:
- Push to `main` branch: Production build
- Push to `develop` branch: Development build
- Pull requests: Test build
 
Build status: [![Build Status](badge-url)](ci-url)
 
## Build Performance
 
Typical build times:
- Development: ~30 seconds
- Production: ~2 minutes
 
To improve build performance:
- Use incremental builds: `npm run build:watch`
- Enable caching: Configure in `build.config.js`
- Parallelize builds: Use `--parallel` flag
 
## Next Steps
 
After building, see:
- [DEPLOYMENT.md](DEPLOYMENT.md) for deployment instructions
- [TESTING.md](TESTING.md) for running tests

DEPLOYMENT.md Template

# Deploying [Project Name]
 
This guide covers deploying the application to various environments.
 
## Environments
 
| Environment | Purpose | URL | Access |
|------------|---------|-----|--------|
| Development | Local development | localhost:3000 | All developers |
| QA | Testing | qa.example.com | QA team |
| Staging | Pre-production validation | staging.example.com | Internal users |
| Production | Live application | www.example.com | Public |
 
## Prerequisites
 
### Required
-Built application artifacts (see [BUILDING.md](BUILDING.md))
-Access credentials for target environment
-[Cloud provider] CLI tools installed and configured
 
### Environment Variables
 
Create `.env.[environment]` file:

Application

NODE_ENV=production PORT=3000 LOG_LEVEL=info

Database

DATABASE_URL=postgresql://user:pass@host:5432/dbname DATABASE_POOL_SIZE=10

API Keys (use secrets manager in production)

API_KEY=your-api-key SECRET_KEY=your-secret-key

Feature Flags

FEATURE_X_ENABLED=true

 
## Deployment Methods
 
### Method 1: Manual Deployment
 
**Step 1: Prepare Application**

Build production artifacts

npm run build:prod

Verify build

ls -la dist/

 
**Step 2: Deploy to Server**

Copy files to server

scp -r dist/* user@server:/var/www/app/

SSH into server

ssh user@server

Restart application

sudo systemctl restart app-service

 
**Step 3: Verify Deployment**

Check service status

sudo systemctl status app-service

Check logs

sudo tail -f /var/log/app/application.log

Test endpoint

curl https://your-domain.com/health

 
### Method 2: Docker Deployment
 
**Step 1: Build Docker Image**

Build image

docker build -t app-name:version .

Tag for registry

docker tag app-name:version registry.example.com/app-name:version

Push to registry

docker push registry.example.com/app-name:version

 
**Step 2: Deploy Container**

Pull latest image

docker pull registry.example.com/app-name:version

Stop existing container

docker stop app-container || true docker rm app-container || true

Run new container

docker run -d \ --name app-container \ --env-file .env.production \ -p 80:3000 \ --restart unless-stopped \ registry.example.com/app-name:version

Verify

docker logs app-container

 
### Method 3: Kubernetes Deployment
 
**Step 1: Prepare Kubernetes Manifests**

deployment.yaml

apiVersion: apps/v1 kind: Deployment metadata: name: app-deployment spec: replicas: 3 selector: matchLabels: app: myapp template: metadata: labels: app: myapp spec: containers:

• name: app

image: registry.example.com/app-name:version ports:

• containerPort: 3000

envFrom:

• configMapRef:

name: app-config

• secretRef:

name: app-secrets

 
**Step 2: Deploy to Cluster**

Apply configurations

kubectl apply -f k8s/

Check deployment status

kubectl rollout status deployment/app-deployment

Verify pods running

kubectl get pods -l app=myapp

Check logs

kubectl logs -l app=myapp --tail=100

 
### Method 4: Cloud Platform (AWS/GCP/Azure)
 
#### AWS Elastic Beanstalk

Initialize EB

eb init -p node.js-16 app-name --region us-west-2

Create environment

eb create production --instance-type t3.medium

Deploy

eb deploy

Check status

eb status

 
#### Google Cloud Platform

Deploy to App Engine

gcloud app deploy app.yaml --project=project-id

View logs

gcloud app logs tail -s default

Open in browser

gcloud app browse

 
#### Azure App Service

Create resource group

az group create --name myResourceGroup --location eastus

Create app service plan

az appservice plan create --name myAppServicePlan \ --resource-group myResourceGroup --sku B1 --is-linux

Create web app

az webapp create --resource-group myResourceGroup \ --plan myAppServicePlan --name myUniqueAppName \ --runtime "NODE|16-lts"

Deploy

az webapp deployment source config-zip \ --resource-group myResourceGroup \ --name myUniqueAppName \ --src dist.zip

 
## Post-Deployment Verification
 
### Health Checks

Application health

curl https://your-domain.com/health