myaidev-method/USER_GUIDE.md

Comprehensive development framework with SPARC methodology for AI-assisted software development, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment

# MyAIDev Method - User Guide

> **🎯 Complete guide to customizing and using your AI CLI agents**

This guide covers everything you need to know about using, customizing, and extending the MyAIDev Method package after installation.

## 📋 Table of Contents

- [Quick Start](#quick-start)
- [Understanding the Structure](#understanding-the-structure)
- [SPARC Development Workflow](#sparc-development-workflow)
- [Git & CI/CD Workflows](#git--cicd-workflows)
- [Multi-Platform Support](#multi-platform-support)
- [Customizing Agents](#customizing-agents)
- [Managing Commands](#managing-commands)
- [WordPress Integration](#wordpress-integration)
- [SSH Configuration](#ssh-configuration)
- [Agent Management](#agent-management)
- [Troubleshooting](#troubleshooting)
- [Advanced Usage](#advanced-usage)
- [Best Practices](#best-practices)

## 🚀 Quick Start

After installing with `npx myaidev-method@latest init --claude`, you'll see the MyAIDev Method banner and SPARC methodology breakdown:

```
███╗   ███╗██╗   ██╗ █████╗ ██╗██████╗ ███████╗██╗   ██╗
████╗ ████║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔════╝██║   ██║
██╔████╔██║ ╚████╔╝ ███████║██║██║  ██║█████╗  ██║   ██║
██║╚██╔╝██║  ╚██╔╝  ██╔══██║██║██║  ██║██╔══╝  ╚██╗ ██╔╝
██║ ╚═╝ ██║   ██║   ██║  ██║██║██████╔╝███████╗ ╚████╔╝ 
╚═╝     ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝  ╚═══╝  

           ███╗   ███╗███████╗████████╗██╗  ██╗ ██████╗ ██████╗ 
           ████╗ ████║██╔════╝╚══██╔══╝██║  ██║██╔═══██╗██╔══██╗
           ██╔████╔██║█████╗     ██║   ███████║██║   ██║██║  ██║
           ██║╚██╔╝██║██╔══╝     ██║   ██╔══██║██║   ██║██║  ██║
           ██║ ╚═╝ ██║███████╗   ██║   ██║  ██║╚██████╔╝██████╔╝
           ╚═╝     ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ 

╔══════════════════════════════════════════════════════════════════════════╗
║  SPARC Methodology - Systematic Software Development Framework           ║
╚══════════════════════════════════════════════════════════════════════════╝

  S │ 📋 Specification
      Define requirements and system boundaries
      → Clear goals, constraints, and success criteria

  P │ 🔄 Pseudocode
      Plan implementation approach
      → Algorithm design and logic flow

  A │ 🏗️ Architecture
      Design system structure and components
      → APIs, data models, and service layers

  R │ ⚡ Refinement
      Implement with SOLID principles and testing
      → Clean code, security, and performance

  C │ 🎯 Completion
      Documentation and deployment preparation
      → User guides, API docs, and CI/CD setup
```

You'll have a `.claude` folder in your project:

```
.claude/
├── commands/           # Slash commands (22 total)
├── agents/            # AI agent definitions (7 total)
├── mcp/              # MCP integrations
└── CLAUDE.md         # Project configuration
```

### Immediate Usage

```bash
# SPARC Development Workflow
/myai-sparc-workflow "Build user authentication system"

# Create professional content
/myai-content-writer "10 Best Remote Work Tips"

# Git & CI/CD
/myai-git-pr "Add authentication feature"
/myai-deploy-staging

# WordPress administration
/myai-wordpress-admin health-check

# Manage agents and settings
/myai-configure agents --list
```

## 🏗️ Understanding the Structure

### Commands Directory (`.claude/commands/`)

Contains 22 slash commands that appear in your Claude Code interface:

**SPARC Development:**
- `myai-sparc-workflow.md` - Complete 5-phase SPARC workflow
- `myai-dev-architect.md` - Architecture design phase
- `myai-dev-code.md` - Implementation phase
- `myai-dev-test.md` - Testing phase
- `myai-dev-review.md` - Code review phase
- `myai-dev-docs.md` - Documentation phase

**Git & CI/CD:**
- `myai-git-pr.md` - Create and manage Pull Requests
- `myai-git-release.md` - Semantic versioning and releases
- `myai-git-sync.md` - Branch synchronization
- `myai-git-hotfix.md` - Emergency hotfix procedures
- `myai-deploy-dev.md` - Development environment deployment
- `myai-deploy-staging.md` - Staging environment deployment
- `myai-deploy-prod.md` - Production deployment (blue-green, canary, rolling)

**Content & Publishing:**
- `myai-content-writer.md` - Content creation
- `myai-wordpress-publish.md` - WordPress publishing
- `myai-wordpress-admin.md` - WordPress administration
- `myai-payloadcms-publish.md` - PayloadCMS publishing
- `myai-docusaurus-publish.md` - Docusaurus documentation
- `myai-mintlify-publish.md` - Mintlify documentation
- `myai-astro-publish.md` - Astro site publishing

**Infrastructure:**
- `myai-coolify-deploy.md` - Coolify deployment automation
- `myai-configure.md` - Configuration management

### Agents Directory (`.claude/agents/`)

Contains 7 AI agent definitions with specialized prompts:

**Development Agents:**
- `architect.md` - System architecture and design specialist
- `coder.md` - Implementation and coding expert
- `tester.md` - Testing and quality assurance specialist
- `reviewer.md` - Code review and quality analysis
- `documenter.md` - Technical documentation specialist

**Content Agents:**
- `content-writer.md` - Professional content creator
- `wordpress-admin.md` - WordPress administrator

### File Format

All commands and agents use Markdown with YAML frontmatter:

```markdown
---
name: agent-name
description: Brief description
tools: Read, Write, Edit, WebSearch, WebFetch, Task
---

# Agent prompt content goes here...
```

## 🏗️ SPARC Development Workflow

The SPARC methodology provides a systematic approach to software development with 5 phases:

**S**pecification → **P**seudocode → **A**rchitecture → **R**efinement → **C**ompletion

### Complete SPARC Workflow

Run the entire 5-phase workflow:

```bash
/myai-sparc-workflow "Build user authentication with JWT and OAuth"
```

This executes all phases sequentially:
1. **Specification** - Requirements analysis and system boundaries
2. **Pseudocode** - Algorithm design and logic planning
3. **Architecture** - System structure, APIs, and data models
4. **Refinement** - Implementation with SOLID principles and testing
5. **Completion** - Documentation and deployment preparation

### Individual Phase Commands

For more control, run phases individually:

```bash
# Phase 1: Architecture Design
/myai-dev-architect "Design microservices architecture for e-commerce platform"

# Phase 2: Implementation
/myai-dev-code "Implement user authentication service"

# Phase 3: Testing
/myai-dev-test "Create comprehensive test suite with 80%+ coverage"

# Phase 4: Code Review
/myai-dev-review "Review authentication implementation for security"

# Phase 5: Documentation
/myai-dev-docs "Generate API documentation and user guides"
```

### SPARC Quality Standards

All phases adhere to these standards:

- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
- **Clean Code**: DRY (Don't Repeat Yourself), KISS (Keep It Simple), YAGNI (You Aren't Gonna Need It)
- **Security**: OWASP Top 10 compliance
- **Testing**: 80%+ critical path coverage, 60%+ overall coverage
- **Performance**: <200ms API responses, <50ms database queries

### SPARC Output Structure

All phases output to `.myaidev-method/sparc/` directory:

```
.myaidev-method/sparc/
├── architecture.md          # Phase 1: System design
├── pseudocode/             # Phase 2: Algorithm plans
├── code-output/            # Phase 4: Implementation
├── test-results/           # Phase 3: Test suites
├── review-report.md        # Phase 4: Quality analysis
└── documentation/          # Phase 5: API docs & guides
```

## 🔄 Git & CI/CD Workflows

Complete Git operations and deployment automation commands:

### Pull Request Workflow

Create professional pull requests with GitHub CLI integration:

```bash
# Create PR from current branch
/myai-git-pr "Add user authentication feature"

# The command will:
# - Analyze all commits since branch diverged
# - Generate comprehensive PR description
# - Create PR with gh CLI
# - Include testing checklist and deployment notes
```

**PR Description Template includes:**
- Summary of changes
- Type of change (feature/fix/breaking)
- Testing checklist
- Code review checklist
- Related issues
- Screenshots (if applicable)
- Deployment notes

### Branch Synchronization

Keep your branches in sync across the development workflow:

```bash
# Sync all branches
/myai-git-sync

# Features:
# - Status overview of all branches
# - Sync dev → staging → production
# - Conflict resolution helper
# - Branch cleanup (merged branches)
```

### Release Management

Automated semantic versioning and changelog generation:

```bash
# Create new release
/myai-git-release

# Automatically:
# - Determines version bump (major/minor/patch)
# - Generates changelog from conventional commits
# - Creates GitHub release
# - Uploads assets with checksums
# - Publishes to npm (if configured)
```

**Version Bump Detection:**
- `BREAKING CHANGE` → major version (1.0.0 → 2.0.0)
- `feat:` commits → minor version (1.0.0 → 1.1.0)
- `fix:` commits → patch version (1.0.0 → 1.0.1)

### Emergency Hotfix Procedures

Fast-track critical bug fixes to production:

```bash
# Emergency hotfix workflow
/myai-git-hotfix

# Includes:
# - Emergency assessment & incident tracking
# - Multiple fix application methods
# - Fast-track testing
# - Emergency approval gate
# - Post-mortem report generation
```

### Deployment Commands

Deploy to different environments with appropriate safety levels:

```bash
# Development deployment (fast iteration)
/myai-deploy-dev

# Staging deployment (pre-production testing)
/myai-deploy-staging

# Production deployment (multiple strategies)
/myai-deploy-prod
```

**Development Deployment:**
- Fast deployment with hot-reload support
- Docker, Docker Compose, or rsync methods
- Auto-deploy via GitHub Actions

**Staging Deployment:**
- Pre-flight checks and tests
- Coolify or Docker deployment
- Health checks and smoke tests
- Rollback procedures

**Production Deployment:**
- Strict approval gates and backup points
- Multiple strategies:
  - **Blue-Green**: Zero-downtime deployment
  - **Canary**: Gradual rollout (10% → 50% → 100%)
  - **Rolling**: Sequential instance updates
- Comprehensive monitoring and rollback

### Deployment Methods

All deployment commands support:

**Coolify API:**
```bash
# Configure Coolify credentials
COOLIFY_URL=https://coolify.your-server.com
COOLIFY_API_TOKEN=your_api_token
COOLIFY_STAGING_APP_ID=your_app_id
```

**Docker:**
```bash
# Docker deployment
DOCKER_REGISTRY=registry.your-domain.com
STAGING_IMAGE_TAG=staging
```

**Docker Compose:**
```bash
# Deploy with compose
ssh staging-server 'cd /opt/app && docker-compose up -d'
```

### CI/CD Notifications

Deployment commands support notifications:

```bash
# Slack notifications
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK

# Discord notifications
DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/YOUR/WEBHOOK
```

## 🌐 Multi-Platform Support

MyAIDev Method supports three AI CLI platforms with feature parity:

### Claude Code (Default)

Uses `.claude/` directory structure:

```bash
# Initialize for Claude Code
npx myaidev-method@latest init --claude

# Structure
.claude/
├── commands/           # Markdown with YAML frontmatter
│   └── myai-*.md      # Uses $ARGUMENTS placeholder
├── agents/
├── mcp/
└── CLAUDE.md
```

### Gemini CLI

Uses `.gemini/` directory with TOML format:

```bash
# Initialize for Gemini CLI
npx myaidev-method@latest init --gemini

# Structure
.gemini/
├── commands/           # TOML format
│   └── myai-*.toml    # Uses {{args}} placeholder
└── README.md
```

**Gemini Command Format:**
```toml
prompt = """
You are a specialist in...

Task: {{args}}

## Workflow
...
"""
```

### OpenCode (Codex)

Uses `.opencode/` directory with simple Markdown:

```bash
# Initialize for OpenCode
npx myaidev-method@latest init --opencode

# Structure
.opencode/
├── commands/           # Simple Markdown (no frontmatter)
│   └── myai-*.md      # Uses $ARGUMENTS placeholder
└── README.md
```

**OpenCode Command Format:**
```markdown
# Command Description

You are a specialist in...

Task: $ARGUMENTS

## Workflow
...
```

### Platform Feature Parity

All 22 commands are available on all platforms:
- ✅ Claude Code: 22 commands + 7 agents
- ✅ Gemini CLI: 22 commands (TOML format)
- ✅ OpenCode: 22 commands (simple Markdown)

### Switching Platforms

You can initialize for multiple platforms in the same project:

```bash
# Initialize all platforms
npx myaidev-method@latest init --claude
npx myaidev-method@latest init --gemini
npx myaidev-method@latest init --opencode

# Result: All three directories exist
.claude/
.gemini/
.opencode/
```

## 🎨 Customizing Agents

### Method 1: Direct File Editing

**For immediate customization in your current project:**

```bash
# Edit the content writer agent
nano .claude/agents/content-writer.md
# or
code .claude/agents/content-writer.md

# Restart Claude Code to load changes
```

### Method 2: Replace with Custom File

**If you have a complete custom prompt file:**

```bash
# Always backup first
cp .claude/agents/content-writer.md .claude/agents/content-writer.md.backup

# Replace with your custom file
cp your-custom-prompt.md .claude/agents/content-writer.md

# Restart Claude Code
```

### Method 3: Using Configuration Commands

**Safe editing with built-in tools:**

```bash
# Create backup before editing
/myai-configure agents --backup content-writer

# Edit the agent
/myai-configure agents --edit content-writer

# Validate changes
/myai-configure agents --validate content-writer
```

### Method 4: Update Source for All Future Installations

**To modify the default prompt for new installations:**

1. **Update the source template**:
   ```bash
   # Edit the template file
   nano src/templates/claude/agents/content-writer.md
   ```

2. **Publish update**:
   ```bash
   # Bump version
   npm version patch  # 0.0.1 → 0.0.2
   
   # Publish
   npm publish
   ```

## ✏️ Agent Customization Examples

### Example 1: Technical Documentation Writer

```markdown
---
name: content-writer
description: Technical documentation specialist for developer content
tools: Read, Write, Edit, WebSearch, WebFetch, Task, Grep, Glob
---

You are a technical documentation writer specializing in developer-focused content.

## Writing Style
- Use clear, concise technical language
- Include code examples where appropriate
- Structure content for easy scanning by developers
- Focus on practical implementation details

## Custom Requirements
- Always include code snippets when relevant
- Add "Prerequisites" section for technical tutorials
- Include "Troubleshooting" sections
- Reference official documentation sources

## Output Format
Create content with:
- Step-by-step instructions
- Code examples with syntax highlighting
- API reference links
- Common pitfalls and solutions
```

### Example 2: Marketing Content Writer

```markdown
---
name: content-writer
description: Marketing content specialist focused on conversion
tools: Read, Write, Edit, WebSearch, WebFetch, Task
---

You are a marketing content writer specializing in conversion-focused copy.

## Brand Voice
- Conversational and approachable
- Benefits-focused messaging
- Strong calls-to-action
- Customer pain point awareness

## Content Types
- Landing page copy
- Email marketing content
- Social media posts
- Product descriptions

## SEO Focus
- High-converting keywords
- Local SEO optimization
- Featured snippet targeting
- User intent matching
```

### Example 3: Industry-Specific Writer

```markdown
---
name: content-writer
description: Healthcare content writer with medical expertise
tools: Read, Write, Edit, WebSearch, WebFetch, Task
---

You are a healthcare content writer with deep medical knowledge.

## Compliance Requirements
- HIPAA compliance awareness
- Medical accuracy verification
- Proper medical terminology
- Citation of peer-reviewed sources

## Content Guidelines
- Patient-friendly language
- Evidence-based information
- Professional medical tone
- Accessibility considerations
```

## ⚙️ Managing Commands

### Viewing Available Commands

```bash
# List all commands
/myai-configure agents --list

# Show command details
ls -la .claude/commands/

# View specific command
cat .claude/commands/myai-content-writer.md
```

### Customizing Commands

Edit command files to modify behavior:

```bash
# Edit content writer command
nano .claude/commands/myai-content-writer.md
```

**Example command customization:**

```markdown
---
name: myai-content-writer
description: Create technical blog posts with code examples
tools: Read, Write, Edit, WebSearch, WebFetch, Task, Grep, Glob
---

Create technical blog posts based on the topic: $ARGUMENTS

## Requirements
- Include practical code examples
- Add "Prerequisites" section
- Provide GitHub repository links
- Include troubleshooting section

## Output Format
Save as markdown with:
- Technical accuracy
- Step-by-step tutorials
- Copy-paste ready code
- Real-world applications
```

### Creating New Commands

1. **Create new command file**:
   ```bash
   nano .claude/commands/myai-code-reviewer.md
   ```

2. **Add command definition**:
   ```markdown
   ---
   name: myai-code-reviewer
   description: Professional code review and analysis
   tools: Read, Write, Edit, Grep, Glob, Task
   ---
   
   Review the code specified in $ARGUMENTS and provide:
   - Security analysis
   - Performance recommendations
   - Best practice suggestions
   - Refactoring opportunities
   ```

3. **Restart Claude Code** to load the new command

## 🔌 WordPress Integration

### Initial Setup

Use the interactive configuration command to set up WordPress:

```bash
/myai-configure wordpress
```

This will guide you through:
- WordPress site URL
- Username  
- Application Password creation

**Alternative manual setup**:
1. Create `.env` file in your project root
2. Add your WordPress credentials:
   ```bash
   WORDPRESS_URL=https://your-site.com
   WORDPRESS_USERNAME=your-username
   WORDPRESS_APP_PASSWORD=your-app-password
   ```

### Creating Application Password

1. Go to WordPress Admin → Users → Your Profile
2. Find "Application Passwords" section
3. Enter name (e.g., "MyAIDev CLI") and click "Add New"
4. Copy the generated password
   - Copy the generated password

### WordPress Commands

```bash
# Test connection
/myai-wordpress-admin health-check

# Security operations
/myai-wordpress-admin security-scan
/myai-wordpress-admin malware-check
/myai-wordpress-admin user-audit

# Performance optimization
/myai-wordpress-admin speed-test --detailed
/myai-wordpress-admin database-optimize
/myai-wordpress-admin cache-setup

# Content management
/myai-wordpress-publish "article.md" --status draft
/myai-content-writer "Blog Post Title" --publish_to_wordpress true
```

### Publishing Workflow

**Important**: WordPress publishing works through Claude Code slash commands, not terminal commands.

#### To Publish Content:

1. **Inside Claude Code** (not terminal):
   ```bash
   /myai-wordpress-publish "your-article.md" --status draft
   ```

2. **The command will**:
   - Read your markdown file
   - Extract frontmatter (title, meta_description, tags, etc.)
   - Connect to WordPress REST API
   - Create/update the post
   - Return post ID and URLs

#### Common Publishing Options:

```bash
# Publish as draft (default)
/myai-wordpress-publish "article.md"

# Publish immediately
/myai-wordpress-publish "article.md" --status publish

# Schedule for review
/myai-wordpress-publish "article.md" --status pending
```

#### Content Format Expected:

Your markdown files should have frontmatter:

```markdown
---
title: "Your Article Title"
meta_description: "SEO description for the post"
slug: "your-article-slug"
tags: ["tag1", "tag2"]
category: "Blog"
---

# Your Article Content

Content goes here...
```

### WordPress Configuration Options

```bash
# Configure WordPress settings
/myai-configure wordpress

# Set default publishing options
/myai-configure defaults
```

## 💻 SSH Configuration

### Setup Options

#### Option 1: Use Existing SSH Keys (Recommended)

If you already have SSH configured:

```bash
# Test existing SSH
ssh user@your-server

# Use in WordPress admin (automatic)
/myai-wordpress-admin security-scan
```

#### Option 2: Specify SSH Details

```bash
# Add to .env file
SSH_HOST=your-server-ip
SSH_USERNAME=your-ssh-username
SSH_KEY_PATH=/path/to/private/key
WORDPRESS_PATH=/var/www/html
```

#### Option 3: SSH Config File

Configure in `~/.ssh/config`:

```
Host wordpress-server
    HostName your-server-ip
    User your-username
    IdentityFile ~/.ssh/your-key
    Port 22
```

Then set: `SSH_HOST=wordpress-server`

### SSH-Enabled Operations

When SSH is available:

```bash
# Server-level security
/myai-wordpress-admin file-permissions
/myai-wordpress-admin malware-check

# Performance monitoring
/myai-wordpress-admin resource-monitor
/myai-wordpress-admin error-analysis

# Backup operations
/myai-wordpress-admin backup-create
/myai-wordpress-admin backup-verify
```

## 🛠️ Agent Management

### Using Configuration Commands

```bash
# List all agents
/myai-configure agents --list

# Check agent status
/myai-configure agents --status

# Validate specific agent
/myai-configure agents --validate content-writer

# Create backup
/myai-configure agents --backup wordpress-admin

# Edit agent safely
/myai-configure agents --edit content-writer

# Restore from backup
/myai-configure agents --restore content-writer

# Show agent tools
/myai-configure agents --tools wordpress-admin
```

### Manual Agent Management

```bash
# View agent details
cat .claude/agents/content-writer.md

# List all agents
ls -la .claude/agents/

# Check modification dates
ls -lt .claude/agents/

# Create manual backup
cp .claude/agents/content-writer.md backups/content-writer-$(date +%Y%m%d).md
```

### Agent Validation

Before using modified agents:

1. **Check YAML syntax**:
   ```bash
   head -10 .claude/agents/content-writer.md
   ```

2. **Validate required fields**:
   - `name`: Agent identifier
   - `description`: Brief description
   - `tools`: Available tools list

3. **Test functionality**:
   ```bash
   /myai-configure agents --validate content-writer
   ```

## 🔍 Troubleshooting

### Common Issues

#### Commands Not Appearing

**Problem**: Custom commands don't show in `/` menu.

**Solutions**:
```bash
# Check file location
ls .claude/commands/

# Verify YAML syntax
head -5 .claude/commands/myai-content-writer.md

# Check file permissions
chmod 644 .claude/commands/*.md

# Restart Claude Code
```

#### WordPress Connection Issues

**Problem**: Cannot connect to WordPress.

**Solutions**:
```bash
# Test WordPress API manually
curl -u "username:app-password" "https://your-site.com/wp-json/wp/v2/users/me"

# Check environment variables
cat .env

# Verify WordPress settings
/myai-configure wordpress
```

#### SSH Authentication Problems

**Problem**: SSH operations fail.

**Solutions**:
```bash
# Test SSH manually
ssh user@your-server

# Check SSH configuration
cat ~/.ssh/config

# Verify key permissions
chmod 600 ~/.ssh/id_rsa
```

#### Agent Not Working

**Problem**: Agent behavior doesn't match expectations.

**Solutions**:
```bash
# Check agent file
cat .claude/agents/content-writer.md

# Validate YAML frontmatter
/myai-configure agents --validate content-writer

# Restart Claude Code
```

### Debug Mode

Enable detailed logging:

```bash
# Add to .env file
DEBUG=true
VERBOSE_LOGGING=true
```

### Log Files

Check logs for errors:

```bash
# View recent errors
tail -f ~/.claude/logs/errors.log

# Check command execution
tail -f ~/.claude/logs/commands.log
```

## 🚀 Advanced Usage

### Creating Custom Agent Workflows

**Multi-step content creation:**

```bash
# 1. Research and outline
/myai-content-writer "Topic Research" --research_only true

# 2. Create content
/myai-content-writer "Full Article" --outline_from research.md

# 3. WordPress optimization
/myai-wordpress-admin seo-analyze --content article.md

# 4. Publish
/myai-wordpress-publish article.md --status publish
```

### 📝 Complete Content Creation Pipeline Examples

#### Example 1: Technical Blog Post Pipeline

**Full workflow from research to multi-platform publishing:**

```bash
# Step 1: Research and planning
/myai-content-writer "Complete Guide to Docker Containerization" --research_phase true
# Output: research-docker-guide.md with sources, outline, and key points

# Step 2: Create comprehensive content
/myai-content-writer "Docker Containerization Guide" --technical_depth advanced --include_code_examples true
# Output: docker-guide.md with full article, code snippets, and examples

# Step 3: Platform-specific optimization
/myai-content-writer "Optimize for platforms" --source docker-guide.md --platforms "wordpress,docusaurus,medium"
# Output: 
# - docker-guide-wordpress.md (SEO optimized, WP formatting)
# - docker-guide-docusaurus.md (technical docs format)
# - docker-guide-medium.md (Medium-friendly formatting)

# Step 4: Multi-platform publishing
/myai-wordpress-publish "docker-guide-wordpress.md" --status publish --category "Tutorials"
/myai-docusaurus-publish "docker-guide-docusaurus.md" --section "guides" --sidebar_position 3
/myai-medium-publish "docker-guide-medium.md" --tags "docker,devops,containers"
```

#### Example 2: Product Launch Content Campaign

**Coordinated content across multiple channels:**

```bash
# Step 1: Campaign planning
/myai-content-writer "Product Launch Campaign: AI Code Assistant" --campaign_planning true
# Output: campaign-plan.md with content calendar and platform strategy

# Step 2: Create core content pieces
/myai-content-writer "AI Code Assistant Features" --content_type "feature_overview" --target_audience "developers"
/myai-content-writer "Getting Started Guide" --content_type "tutorial" --difficulty "beginner"
/myai-content-writer "Advanced Use Cases" --content_type "case_studies" --include_examples true

# Step 3: Platform-specific adaptations
# Landing page content
/myai-content-writer "Landing Page Copy" --source "feature-overview.md" --conversion_focused true --cta "Start Free Trial"

# Documentation site
/myai-docusaurus-publish "getting-started.md" --section "quickstart" --add_navigation true
/myai-docusaurus-publish "advanced-use-cases.md" --section "examples" --add_code_samples true

# Blog posts
/myai-wordpress-publish "feature-overview.md" --status publish --category "Product Updates"
/myai-astro-publish "getting-started.md" --collection "tutorials" --featured true

# Social media content
/myai-content-writer "Social Media Posts" --source "feature-overview.md" --platforms "twitter,linkedin" --post_count 5
```

#### Example 3: Educational Content Series

**Multi-part series across documentation platforms:**

```bash
# Step 1: Series planning
/myai-content-writer "Web Development Fundamentals Series" --series_planning true --parts 10
# Output: series-plan.md with episode breakdown and learning objectives

# Step 2: Create individual parts
for i in {1..10}; do
  /myai-content-writer "Web Dev Part $i" --series "fundamentals" --part_number $i --previous_context "series-plan.md"
done

# Step 3: Multi-platform publishing
# Documentation sites
/myai-docusaurus-publish "web-dev-part-*.md" --collection "tutorial-series" --auto_navigation true
/myai-mintlify-publish "web-dev-part-*.md" --group "fundamentals" --sequential_order true

# Blog platforms
for file in web-dev-part-*.md; do
  /myai-wordpress-publish "$file" --status publish --series "Web Dev Fundamentals"
  /myai-astro-publish "$file" --collection "education" --tags "webdev,tutorial"
done

# Create series index
/myai-content-writer "Series Index Page" --series_summary "fundamentals" --include_progress_tracker true
/myai-docusaurus-publish "series-index.md" --as_landing_page true
```

#### Example 4: API Documentation Pipeline

**Technical documentation with code examples:**

```bash
# Step 1: API analysis and planning
/myai-dev-docs "Analyze REST API" --source "api-spec.yaml" --generate_examples true
# Output: api-analysis.md with endpoints, parameters, and usage patterns

# Step 2: Create comprehensive documentation
/myai-content-writer "REST API Documentation" --technical_writing true --include_curl_examples true --source "api-analysis.md"
# Output: api-docs.md with detailed endpoint documentation

# Step 3: Platform-specific formatting
/myai-content-writer "Format for platforms" --source "api-docs.md" --platforms "mintlify,docusaurus,postman"
# Output:
# - api-docs-mintlify.md (Mintlify-optimized with interactive examples)
# - api-docs-docusaurus.md (Docusaurus format with sidebar navigation)
# - api-collection.json (Postman collection for testing)

# Step 4: Multi-platform publishing
/myai-mintlify-publish "api-docs-mintlify.md" --section "api-reference" --interactive_examples true
/myai-docusaurus-publish "api-docs-docusaurus.md" --section "api" --add_try_it_buttons true

# Step 5: Generate SDK documentation
/myai-dev-docs "Generate SDK Examples" --languages "javascript,python,curl" --source "api-docs.md"
/myai-docusaurus-publish "sdk-examples.md" --section "sdks" --code_tabs true
```

#### Example 5: Content Localization Pipeline

**Multi-language content creation and publishing:**

```bash
# Step 1: Create master content
/myai-content-writer "Product Features Guide" --master_content true --localization_ready true
# Output: features-guide-en.md (English master version)

# Step 2: Localize content
/myai-content-writer "Localize content" --source "features-guide-en.md" --target_languages "es,fr,de,ja"
# Output: features-guide-es.md, features-guide-fr.md, etc.

# Step 3: Platform-specific publishing by language
# WordPress multisite
/myai-wordpress-publish "features-guide-en.md" --site "main" --language "en"
/myai-wordpress-publish "features-guide-es.md" --site "es" --language "es"
/myai-wordpress-publish "features-guide-fr.md" --site "fr" --language "fr"

# Docusaurus i18n
/myai-docusaurus-publish "features-guide-en.md" --locale "en" --section "guides"
/myai-docusaurus-publish "features-guide-es.md" --locale "es" --section "guides"
/myai-docusaurus-publish "features-guide-fr.md" --locale "fr" --section "guides"

# Create language switcher
/myai-content-writer "Language Navigation" --available_languages "en,es,fr,de,ja" --current_page "features-guide"
```

### 🔄 Content Workflow Automation

#### Automated Content Calendar

```bash
# Weekly content automation
/myai-content-writer "Weekly Tech News Roundup" --auto_schedule "every monday" --sources "hackernews,techcrunch"
/myai-wordpress-publish "weekly-roundup.md" --schedule "monday 9am" --category "News"

# Monthly feature highlights
/myai-content-writer "Monthly Product Updates" --template "product-updates.md" --auto_generate "monthly"
/myai-docusaurus-publish "product-updates.md" --section "changelog" --auto_date true
```

#### Content Repurposing Pipeline

```bash
# Transform long-form content into multiple formats
/myai-content-writer "Repurpose Content" --source "comprehensive-guide.md" --formats "summary,social,newsletter,slides"
# Output:
# - guide-summary.md (executive summary)
# - guide-social.md (social media posts)
# - guide-newsletter.md (email newsletter format)
# - guide-slides.md (presentation outline)

# Publish across platforms
/myai-wordpress-publish "guide-summary.md" --category "Summaries"
/myai-astro-publish "guide-newsletter.md" --collection "newsletter"
/myai-content-writer "Create Slide Deck" --source "guide-slides.md" --export_format "reveal.js"
```

### 📊 Content Performance Tracking

#### Analytics Integration

```bash
# Content performance analysis
/myai-wordpress-admin analytics-report --content "docker-guide" --metrics "views,engagement,conversions"
/myai-content-writer "Performance Report" --source "analytics-data.json" --recommendations true

# A/B testing setup
/myai-content-writer "Create Variants" --source "landing-page.md" --variants 3 --test_elements "headline,cta"
/myai-wordpress-publish "landing-page-variant-a.md" --ab_test "group_a"
/myai-wordpress-publish "landing-page-variant-b.md" --ab_test "group_b"
```

### 🎯 Platform-Specific Best Practices

#### WordPress Optimization

```bash
# SEO-optimized WordPress content
/myai-content-writer "SEO Article" --target_keyword "docker tutorial" --seo_optimized true
/myai-wordpress-admin seo-analyze --content "seo-article.md" --suggestions true
/myai-wordpress-publish "seo-article.md" --yoast_optimization true --featured_image "auto"
```

#### Technical Documentation (Docusaurus/Mintlify)

```bash
# Interactive documentation
/myai-content-writer "Interactive Guide" --platform "docusaurus" --interactive_elements true
/myai-docusaurus-publish "interactive-guide.md" --add_live_editor true --code_playground true

# API reference with examples
/myai-content-writer "API Reference" --platform "mintlify" --openapi_spec "api.yaml"
/myai-mintlify-publish "api-reference.md" --interactive_examples true --try_it_buttons true
```

#### Static Site Publishing (Astro)

```bash
# Performance-optimized content
/myai-content-writer "Performance Guide" --platform "astro" --image_optimization true
/myai-astro-publish "performance-guide.md" --optimize_images true --generate_sitemap true --rss_feed true
```

### Batch Operations

**Process multiple files:**

```bash
# Create multiple articles
for topic in "Topic 1" "Topic 2" "Topic 3"; do
  /myai-content-writer "$topic" --auto_save true
done

# Batch WordPress health checks
/myai-wordpress-admin health-check --comprehensive --schedule daily
```

### Integration with CI/CD

**Automated content workflows:**

```bash
# In your CI/CD pipeline
npx myaidev-method@latest init --claude
/myai-content-writer "Weekly Newsletter" --template newsletter.md
/myai-wordpress-publish newsletter.md --schedule "next monday"
```

### Custom Environment Configurations

**Development vs Production:**

```bash
# .env.development
WORDPRESS_URL=https://staging.yoursite.com
DEBUG=true

# .env.production  
WORDPRESS_URL=https://yoursite.com
DEBUG=false
```

## ✨ Best Practices

### Agent Customization

1. **Always backup before editing**:
   ```bash
   /myai-configure agents --backup content-writer
   ```

2. **Test in development first**:
   ```bash
   # Test with sample content
   /myai-content-writer "Test Article" --draft_mode true
   ```

3. **Version control your customizations**:
   ```bash
   git add .claude/
   git commit -m "Customize content writer for technical docs"
   ```

4. **Document your changes**:
   ```bash
   # Add comments to your agent files
   echo "# Custom modifications for technical content" >> .claude/agents/content-writer.md
   ```

### Security

1. **Secure your .env file**:
   ```bash
   chmod 600 .env
   echo ".env" >> .gitignore
   ```

2. **Use strong WordPress Application Passwords**

3. **Limit SSH access**:
   ```bash
   # Use specific SSH keys
   SSH_KEY_PATH=/path/to/dedicated/key
   ```

4. **Regular security audits**:
   ```bash
   /myai-wordpress-admin security-scan --comprehensive
   ```

### Performance

1. **Monitor resource usage**:
   ```bash
   /myai-wordpress-admin resource-monitor
   ```

2. **Regular maintenance**:
   ```bash
   /myai-wordpress-admin database-optimize --weekly
   ```

3. **Cache optimization**:
   ```bash
   /myai-wordpress-admin cache-setup --type redis
   ```

### Content Quality

1. **Consistent style guides**:
   - Define brand voice in agent prompts
   - Include specific formatting requirements
   - Add industry-specific terminology

2. **Quality checks**:
   ```bash
   # Validate content before publishing
   /myai-configure agents --validate content-writer
   ```

3. **A/B testing**:
   - Create multiple agent variants
   - Test different approaches
   - Measure engagement metrics

### Collaboration

1. **Team configurations**:
   ```bash
   # Share agent configurations
   git add .claude/agents/
   git commit -m "Team content writer configuration"
   ```

2. **Documentation**:
   ```bash
   # Document custom workflows
   echo "## Team Workflow" >> .claude/CLAUDE.md
   ```

3. **Code reviews for agent changes**:
   - Review prompt modifications
   - Test agent behavior
   - Validate output quality

## 📚 Additional Resources

### Learning More

- **Claude Code Documentation**: Official Claude Code docs
- **WordPress REST API**: https://developer.wordpress.org/rest-api/
- **Markdown Guide**: https://www.markdownguide.org/
- **YAML Syntax**: https://yaml.org/spec/

### Community

- **GitHub Issues**: Report bugs and request features
- **Discussions**: Share configurations and tips
- **Examples**: Browse community agent configurations

### Support

If you encounter issues:

1. **Check this guide** for troubleshooting steps
2. **Review error logs** for specific issues
3. **Test components individually** (WordPress, SSH, agents)
4. **Create GitHub issues** for bugs or feature requests

---

**Happy customizing!** 🚀

Remember: The power of MyAIDev Method lies in its customizability. Don't hesitate to experiment with different agent configurations to find what works best for your workflow.