JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 18
  • Score
    100M100P100Q85135F
  • License MIT

Comprehensive development framework with SPARC methodology for AI-assisted software development, AI visual content generation (Gemini, Imagen, DALL-E, Veo, FLUX), multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment

Package Exports

  • myaidev-method
  • myaidev-method/src/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (myaidev-method) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

MyAIDev Method

🚀 A comprehensive development framework for AI-assisted software development with systematic workflows and multi-platform publishing!

The MyAIDev Method is a complete development framework for AI CLI tools (Claude Code, Gemini CLI, Codex CLI) featuring the SPARC methodology for systematic software development, inspired by GitHub Spec-Kit patterns for agentic software development.

🌟 What makes this special:

Comprehensive Development Framework:

  • SPARC Methodology: 5-phase systematic development workflow (Specification → Pseudocode → Architecture → Refinement → Completion)
  • Development Agents: Architect, Coder, Tester, Reviewer, Documenter - complete coverage from design to deployment
  • Quality-First: Built-in security (OWASP Top 10), testing (80%+ coverage), and code review standards
  • Spec-Kit Inspired: Proven patterns for agentic software development based on GitHub's Spec-Kit framework

Multi-Platform Publishing & Deployment:

  • CMS Publishing: WordPress, PayloadCMS with full content management
  • Static Site Generators: Docusaurus, Mintlify, Astro with git-based workflows
  • Deployment: Coolify self-hosted PaaS orchestration
  • Infrastructure: RamNode.com optimized deployment patterns

Professional Tooling:

  • Instant setup: One npx command and you're ready
  • Claude Code native: Follows official standards for maximum compatibility
  • Zero dependencies: Core features work standalone, optional MCP integrations available
  • Production-ready: SOLID principles, Clean Code, comprehensive testing built-in

📋 Table of Contents

✨ Features

🏗️ Development Framework (SPARC Methodology)

  • Systematic Workflow: 5-phase SPARC methodology (Specification → Pseudocode → Architecture → Refinement → Completion)
  • Development Agents: Complete suite of specialized agents for the full development lifecycle
    • 🏗️ Architect: System design, API specifications, data modeling, technology selection
    • 💻 Coder: Feature implementation, refactoring, SOLID principles, Clean Code
    • 🧪 Tester: Unit/integration testing, 80%+ coverage, quality gates
    • 👁️ Reviewer: Code quality, security (OWASP Top 10), performance analysis
    • 📚 Documenter: API docs, user guides, architecture documentation
  • Spec-Kit Patterns: Proven agentic development patterns inspired by GitHub Spec-Kit
  • Quality Standards: Built-in security, testing, code review, and documentation standards
  • File-Based Workflow: Sequential agent coordination with .myaidev-method/sparc/ outputs

📝 Content & Publishing

  • Content Writer Agent: Professional SEO-optimized content creation with optional AI-generated visuals
  • Multi-Platform Publishing: WordPress, PayloadCMS, Docusaurus, Mintlify, Astro
  • Git-Based Workflows: Automated publishing for static site generators
  • WordPress Admin Agent: Security, performance, health monitoring, and administration

🎨 Visual Content Generation (New in v0.2.14!)

  • AI-Powered Image Generation: Google Gemini 2.5 Flash, Imagen 3, OpenAI DALL-E 3
  • AI-Powered Video Generation: Google Veo 2 (up to 8 seconds, 720p)
  • Multi-Platform Support: Works with Claude Code, Gemini CLI, and Codex CLI
  • Budget Management: Daily/monthly limits, cost tracking, and warnings
  • Smart Service Selection: Automatic service selection based on content type
  • Content Integration: Generate images during content creation with --with-images flag
  • Cost-Effective: Starting at $0.02/image (Gemini Flash)
  • Organized Storage: Automatic file organization by date in content-assets/

🚀 Deployment & Infrastructure

  • Coolify Integration: Self-hosted PaaS deployment and orchestration
  • RamNode Optimized: Deployment patterns optimized for RamNode.com infrastructure
  • SSH Integration: Server-level operations for advanced administration
  • MCP Server Integration: Optional advanced features with SPARC Orchestrator, Chrome DevTools, and WordPress MCP servers

🛠️ Development Tools

  • Slash Commands: Easy-to-use Markdown-based commands for Claude Code
  • Custom Subagents: Pre-configured AI agents following Claude Code 2.0 standards
  • Standards Compliant: Full compatibility with Claude Code, Gemini CLI, Codex CLI
  • Zero Dependencies: Core features work standalone, optional MCP integrations

🚀 Installation

npm version npm downloads

⚡ One-Command Installation

No setup required! Install and configure in your project directory with a single command:

# For Claude Code (most popular)
npx myaidev-method@latest init --claude

# For Gemini CLI
npx myaidev-method@latest init --gemini

# For Codex CLI
npx myaidev-method@latest init --codex

# Interactive setup (prompts for CLI choice)
npx myaidev-method@latest init

That's it! No complex setup.

Requirements

  • Node.js >= 20.0.0
  • Claude Code >= 1.0.0 (for Claude features)
  • WordPress site with REST API enabled (optional, for WordPress features)
  • SSH access to server (optional, for advanced WordPress admin features)

Note: WordPress and SSH are completely optional. You can use the content writer agent without any external dependencies!

🏃‍♂️ Quick Start

  1. Install and configure (one command):

    npx myaidev-method@latest init --claude

  2. Start using immediately:

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

# Configure settings (optional)
/myai-configure agents

  3. Add WordPress integration (optional):

    cp .env.example .env
# Edit .env with your WordPress credentials
/myai-wordpress-admin health-check

🔄 Updating

Keep your MyAIDev Method installation up to date with the latest features and bug fixes:

# Interactive update (recommended) - prompts for conflicts
npx myaidev-method@latest update --claude

# Force update - overwrites all files
npx myaidev-method@latest update --claude --force

# Preview changes without updating
npx myaidev-method@latest update --claude --dry-run

The update command:

  • ✅ Detects your current version
  • ✅ Updates commands, agents, scripts, and documentation
  • ✅ Preserves your customizations (interactive conflict resolution)
  • ✅ Creates automatic backups before updating
  • ✅ Installs updated dependencies

See USER_GUIDE.md - Updating Section for detailed update instructions and best practices.

💡 Developer Use Cases

New! See real-world scenarios demonstrating how MyAIDev Method supercharges development workflows:

📖 DEVELOPER_USE_CASES.md - Comprehensive guide featuring:

  • Full-Stack SaaS Development: Build production-ready apps in days instead of weeks
  • Microservices Refactoring: Zero-downtime migrations with systematic strategies
  • Technical Content Pipeline: 4x content output with multi-platform publishing
  • Database Migrations: Safe migrations with rollback capabilities
  • Team Collaboration: Automated code reviews and knowledge bases
  • ROI Analysis: Real productivity metrics and time savings

Examples with Time Savings:

  • Full-stack feature: 120 hours → 24 hours (80% faster)
  • Technical blog post: 12 hours → 2-3 hours (75% faster)
  • Code review: 45 minutes → 10 minutes (78% faster)
  • Developer onboarding: 2 weeks → 2 days (90% faster)

Each use case includes:

  • Traditional vs MyAIDev approach comparison
  • Complete code examples and commands
  • Quantified time savings and quality improvements
  • Integration patterns and best practices

📝 Content Creation for Marketers

New! Discover how marketers and content creators can leverage MyAIDev Method for efficient, high-quality content production:

📖 CONTENT_CREATION_GUIDE.md - Complete marketing workflow guide featuring:

  • 4-Phase Content Pipeline: Ideation → Generation → Publishing → Optimization
  • AI Content Generation: Professional blog posts, tutorials, case studies, and technical content
  • Multi-Platform Publishing: WordPress, PayloadCMS, LinkedIn, email newsletters in one workflow
  • Hub-and-Spoke Distribution: Single content piece adapted for multiple channels
  • SEO Optimization: Keyword research, LSI integration, meta descriptions
  • Where AI Excels vs Human Input: Clear guidance on AI capabilities and limitations
  • 8 Common Pitfalls: Detailed explanations and solutions to avoid content marketing mistakes

Examples with Time Savings:

  • Blog post (2,500 words): 12 hours → 2-3 hours (75% faster)
  • Technical tutorial series: 40 hours → 8 hours (80% faster)
  • Multi-platform distribution: 6 hours → 30 minutes (92% faster)
  • SEO research and optimization: 4 hours → 45 minutes (81% faster)

Content Templates Included:

  • Long-form educational blog posts
  • Technical tutorials with code examples
  • Product announcements and release notes
  • Case studies with metrics and results
  • LinkedIn thought leadership articles
  • Email newsletters

🏗️ SPARC Development Workflow

The MyAIDev Method implements the SPARC methodology - a systematic 5-phase approach to software development inspired by GitHub Spec-Kit patterns for agentic software development.

What is SPARC?

SPARC stands for:

  • Specification - Define requirements and system boundaries
  • Pseudocode - Plan implementation approach
  • Architecture - Design system structure, APIs, and data models
  • Refinement - Implement, test, and review code quality
  • Completion - Document and deliver production-ready software

The 5 Phases

┌─────────────────────────────────────────────────────────────────┐
│  SPARC Workflow: Systematic Software Development                 │
└─────────────────────────────────────────────────────────────────┘

Phase 1: 🏗️ ARCHITECTURE
├─ Agent: dev-architect
├─ Output: .myaidev-method/sparc/architecture.md
├─ Deliverables:
│  ├─ System design with Mermaid diagrams
│  ├─ API specifications (REST/GraphQL/gRPC)
│  ├─ Data models and schemas
│  ├─ Technology stack recommendations
│  └─ Security and scalability planning
└─ Command: /myai-dev-architect "Design authentication system"

Phase 2: 💻 IMPLEMENTATION
├─ Agent: dev-coder
├─ Output: .myaidev-method/sparc/code-output/
├─ Standards: SOLID, Clean Code, DRY/KISS/YAGNI
├─ Features:
│  ├─ Production-ready code implementation
│  ├─ Security best practices (OWASP Top 10)
│  ├─ Error handling and input validation
│  └─ Inline documentation (JSDoc, etc.)
└─ Command: /myai-dev-code "Implement JWT authentication"

Phase 3: 🧪 TESTING
├─ Agent: dev-tester
├─ Output: .myaidev-method/sparc/test-results/
├─ Coverage: 80%+ critical paths, 60%+ overall
├─ Deliverables:
│  ├─ Unit test suites
│  ├─ Integration tests
│  ├─ Coverage reports
│  └─ Quality gate validation
└─ Command: /myai-dev-test "Test authentication module"

Phase 4: 👁️ REVIEW
├─ Agent: dev-reviewer
├─ Output: .myaidev-method/sparc/review-report.md
├─ Analysis:
│  ├─ Code quality and complexity
│  ├─ Security audit (OWASP Top 10)
│  ├─ Performance optimization
│  ├─ Best practices compliance
│  └─ Technical debt assessment
└─ Command: /myai-dev-review "Review authentication implementation"

Phase 5: 📚 DOCUMENTATION
├─ Agent: dev-documenter
├─ Output: .myaidev-method/sparc/documentation/
├─ Deliverables:
│  ├─ API reference (OpenAPI/Swagger)
│  ├─ User guides and tutorials
│  ├─ Architecture documentation
│  └─ Code examples and snippets
└─ Command: /myai-dev-docs "Document authentication API"

Complete Workflow Execution

Run the entire SPARC workflow with a single command:

# Slash command (in Claude Code)
/myai-sparc-workflow "Build user authentication system with JWT"

# CLI command
npx myaidev-method sparc "Build user authentication system with JWT"

# With technology preferences
npx myaidev-method sparc "Build e-commerce checkout" --tech-stack "react,node,stripe,postgres"

Workflow Output Structure

.myaidev-method/
├── sparc/
│   ├── architecture.md              # Phase 1: System design
│   ├── code-output/                 # Phase 2: Implementation
│   │   ├── src/
│   │   ├── tests/
│   │   └── ...
│   ├── test-results/                # Phase 3: Testing
│   │   ├── unit/
│   │   ├── integration/
│   │   └── coverage-report.md
│   ├── review-report.md             # Phase 4: Code review
│   └── documentation/               # Phase 5: Documentation
│       ├── api/
│       ├── user-guide/
│       └── architecture/
├── tasks/                           # Task tracking
└── workflows/                       # Workflow execution logs

Quality Standards

Every SPARC workflow enforces:

  • Code Quality: SOLID principles, Clean Code, maintainability metrics
  • Security: OWASP Top 10 compliance, vulnerability scanning
  • Testing: 80%+ critical path coverage, integration tests
  • Performance: Algorithm complexity analysis, optimization recommendations
  • Documentation: Complete API docs, user guides, architecture specs

GitHub Spec-Kit Inspiration

This framework is inspired by GitHub's Spec-Kit patterns for agentic software development:

  • Systematic Approach: Structured phases with clear deliverables
  • Quality Gates: Validation at each phase transition
  • Agent Specialization: Dedicated agents with specific expertise
  • File-Based Coordination: Agents communicate through well-defined outputs
  • Reproducible Workflows: Consistent results across projects

Individual Phase Commands

You can also run individual phases:

# Slash commands (in Claude Code)
/myai-dev-architect "Design real-time chat app"
/myai-dev-code "Implement WebSocket server"
/myai-dev-test "Test chat functionality" --integration
/myai-dev-review "Review chat implementation" --security
/myai-dev-docs "Document chat API"

# CLI commands
npx myaidev-method dev:architect "Design microservices architecture"
npx myaidev-method dev:code "Implement user service" --test-driven
npx myaidev-method dev:test "Test user service" --coverage
npx myaidev-method dev:review "Security audit for user service"
npx myaidev-method dev:docs "Document user service API"

🤖 Development Agents

Complete Development Lifecycle Coverage

The MyAIDev Method provides specialized agents for every phase of the development lifecycle:

🏗️ Architecture Agent

File: .claude/agents/dev-architect.md Phase: Architecture (SPARC Phase 1)

System architect specializing in scalable design, API specifications, and technology selection.

Capabilities:

  • High-level system architecture with Mermaid diagrams
  • API contract definitions (REST, GraphQL, gRPC)
  • Data modeling and schema design
  • Technology stack recommendations
  • Security architecture planning
  • Scalability and performance planning

Output: .myaidev-method/sparc/architecture.md

💻 Implementation Agent (Coder)

File: .claude/agents/dev-coder.md Phase: Implementation (SPARC Phase 2)

Production code implementer following SOLID principles and Clean Code practices.

Capabilities:

  • Feature implementation from architecture specs
  • Code refactoring and optimization
  • SOLID principles application
  • Security best practices (OWASP Top 10)
  • Error handling and input validation
  • Inline documentation (JSDoc, Sphinx, etc.)

Output: .myaidev-method/sparc/code-output/

Quality Standards:

  • 80%+ test coverage target
  • SOLID, DRY, KISS, YAGNI principles
  • Security-first implementation
  • Comprehensive error handling

🧪 Testing Agent

File: .claude/agents/dev-tester.md Phase: Testing (SPARC Phase 3)

Comprehensive testing specialist with TDD workflow support.

Capabilities:

  • Unit test creation (AAA pattern)
  • Integration test development
  • Coverage analysis and reporting
  • Quality gate validation
  • Test-Driven Development (TDD) workflow
  • Multiple framework support (Jest, Mocha, Pytest, etc.)

Output: .myaidev-method/sparc/test-results/

Coverage Standards:

  • 80%+ for critical paths
  • 60%+ overall coverage
  • Pre-commit, pre-merge, pre-deployment gates

👁️ Code Review Agent

File: .claude/agents/dev-reviewer.md Phase: Review (SPARC Phase 4)

Code quality and security analyst with comprehensive review capabilities.

Capabilities:

  • Code quality metrics and complexity analysis
  • Security audit (OWASP Top 10 compliance)
  • Performance review and optimization
  • Best practices validation (SOLID, framework standards)
  • Technical debt assessment with priority scoring
  • Code smell and anti-pattern detection

Output: .myaidev-method/sparc/review-report.md

Review Standards:

  • Code quality: Complexity, readability, maintainability
  • Security: OWASP Top 10, vulnerability patterns
  • Performance: Algorithm complexity, resource management
  • Best practices: Framework standards, design patterns

📚 Documentation Agent

File: .claude/agents/dev-documenter.md Phase: Documentation (SPARC Phase 5)

Technical documentation specialist for APIs, user guides, and architecture docs.

Capabilities:

  • API reference generation (OpenAPI/Swagger)
  • User guide and tutorial creation
  • Architecture documentation
  • Code example generation and testing
  • Multiple format support (Markdown, HTML, reStructuredText)
  • Inline code documentation (JSDoc, Sphinx, etc.)

Output: .myaidev-method/sparc/documentation/

Documentation Standards:

  • Clarity: Simple language, clear examples, visual aids
  • Completeness: All public APIs documented
  • Accuracy: Tested code examples, synchronized with code
  • Accessibility: Multiple formats, searchable, well-organized

📝 Content & Publishing Agents

Content Writer Agent

File: .claude/agents/content-writer.md

Professional content writer specializing in creating high-quality, engaging, and SEO-optimized content.

Capabilities:

  • SEO-optimized article creation
  • Research and fact-checking
  • Markdown formatting with frontmatter
  • WordPress-ready content structure
  • Multiple tone and audience support
  • Keyword optimization

WordPress Admin Agent

File: .claude/agents/wordpress-admin.md

WordPress administrator for comprehensive site management, security, performance, and health analysis.

Capabilities:

  • Security: Vulnerability scanning, malware detection, user auditing
  • Performance: Speed optimization, database cleanup, caching setup
  • Health: Site monitoring, error analysis, backup verification
  • Administration: User/plugin/theme management, content cleanup

PayloadCMS Publishing Agent

File: .claude/agents/payloadcms-publish.md

Publish markdown content to PayloadCMS headless CMS with Lexical rich text conversion.

Capabilities:

  • Markdown to Lexical conversion
  • JWT authentication
  • Draft and published workflows
  • Custom collections support
  • Document updates

Docusaurus Publishing Agent

File: .claude/agents/docusaurus-publish.md

Git-based publishing for Docusaurus documentation sites.

Capabilities:

  • Docs, blog, and pages support
  • Automatic frontmatter transformation
  • Sidebar configuration
  • Git commit and push automation

Mintlify Publishing Agent

File: .claude/agents/mintlify-publish.md

Git-based publishing for Mintlify documentation with automatic navigation.

Capabilities:

  • MDX transformation
  • mint.json navigation updates
  • Icon and metadata support
  • Git workflow automation

Astro Publishing Agent

File: .claude/agents/astro-publish.md

Git-based publishing for Astro sites with content collections support.

Capabilities:

  • Content collections publishing
  • Schema-validated frontmatter
  • pubDate transformation
  • Draft/published workflow

Deployment Agent

Coolify Deployment Agent

File: .claude/agents/coolify-deploy.md

Self-hosted PaaS deployment for applications.

Capabilities:

  • Application deployment
  • Health monitoring
  • Resource management
  • Multi-environment support

🎨 Visual Content Generation

New in v0.2.14! Generate AI-powered images and videos for your content using Google AI (Gemini, Imagen, Veo) and OpenAI (DALL-E) services.

Features

  • Image Generation: Google Gemini 2.5 Flash ($0.02), Imagen 3 ($0.03), DALL-E 3 ($0.04-0.12)
  • Video Generation: Google Veo 2 ($0.10 for up to 8 seconds, 720p)
  • Multi-Platform: Works with Claude Code, Gemini CLI, and Codex CLI
  • Budget Management: Daily/monthly limits, cost tracking, and warnings
  • Smart Organization: Automatic file storage by date in content-assets/
  • Content Integration: Generate images during content creation with --with-images flag

Setup

  1. Configure Visual APIs (one-time setup):

    # Claude Code
/myai-configure visual

# Gemini CLI / Codex CLI
npm run configure:visual

  2. Follow the interactive wizard to set up:

    • Google AI API key (for Gemini, Imagen, Veo)
    • OpenAI API key (for DALL-E)
    • Default service preference
    • Daily and monthly budget limits

Usage

Claude Code

# Generate a hero image
/myai-generate-visual "Modern developer workspace with dual monitors"

# Generate with specific service
/myai-generate-visual "AI concept illustration" --service dalle --type illustration

# Generate diagram
/myai-generate-visual "Microservices architecture" --type diagram --service gemini

# Create content with images
/myai-content-writer "Best Practices for Remote Work" --with-images

Gemini CLI / Codex CLI

# Generate a hero image
npm run generate-visual "Modern developer workspace"

# Generate with options
npm run generate-visual "System architecture" -- --type=diagram --service=gemini

# Configure visual APIs
npm run configure:visual

Service Comparison

Service Speed Cost Quality Best For
Gemini 2.5 Flash ⚡⚡⚡ $0.02 Good Quick hero images, diagrams, high volume
Imagen 3 ⚡⚡ $0.03 Excellent Premium hero images, high-quality visuals
DALL-E 3 ⚡⚡ $0.04-0.12 Excellent Creative illustrations, detailed designs
Veo 2 ⚡ $0.10 Good Product demos, short videos

Image Types

  • hero - Article header images (recommended: 1792x1024)
  • illustration - Abstract concepts and metaphors
  • diagram - Technical workflows and architecture
  • screenshot - UI mockups and interface designs
  • video - Product demos and tutorials (Veo 2 only)

Budget Management

The system automatically tracks costs and enforces budget limits:

  • Daily Budget: Configurable limit (default: $5.00)
  • Monthly Budget: Configurable limit (default: $50.00)
  • Warning Threshold: Alert at 80% usage
  • Usage Tracking: Stored in .visual-usage-stats.json

File Organization

Generated files are automatically organized by date:

content-assets/
├── images/
│   └── 2025-11-19/
│       ├── hero-workspace-123456.png
│       └── diagram-architecture-234567.png
└── videos/
    └── 2025-11-19/
        └── video-demo-345678.mp4

Documentation

For comprehensive documentation, see:

  • VISUAL_CONTENT_GENERATION_GUIDE.md - Complete user guide
  • VISUAL_GENERATION_FILE_ORGANIZATION.md - File structure details
  • CONTENT_CREATION_GUIDE.md - Content workflow integration

🎯 Slash Commands

/myai-content-writer

Create professional, SEO-optimized content with optional AI-generated visuals.

# Basic usage
/myai-content-writer "Best Practices for Remote Work"

# With AI-generated images (new!)
/myai-content-writer "Best Practices for Remote Work" --with-images

# With parameters
/myai-content-writer "AI in Healthcare" --word_count 1500 --tone technical --audience "healthcare professionals"

# With images and specific service
/myai-content-writer "Microservices Guide" --with-images --service gemini

# With WordPress publishing
/myai-content-writer "Summer Garden Tips" --publish_to_wordpress true

Parameters:

  • topic (required): Content topic or title
  • word_count: Target word count (default: 800)
  • tone: professional, casual, technical, conversational, academic
  • audience: Target reader demographic
  • seo_keywords: Array of keywords for optimization
  • publish_to_wordpress: Auto-publish as draft (true/false)
  • --with-images: Generate AI-powered images (new!)
  • --service: Preferred image service (gemini, imagen, dalle)

/myai-generate-visual

Generate AI-powered images and videos for content.

# Generate a hero image (auto-selects best service)
/myai-generate-visual "Modern developer workspace with dual monitors"

# Generate with specific service
/myai-generate-visual "AI concept illustration" --service dalle --type illustration

# Generate diagram
/myai-generate-visual "Microservices architecture" --type diagram --service gemini

# Generate HD image
/myai-generate-visual "Product mockup" --quality hd --size 1792x1024

# Generate video (Veo 2)
/myai-generate-visual "Product demo walkthrough" --type video --service veo

Parameters:

  • prompt (required): Description of the image/video to generate
  • --type: Image type (hero, illustration, diagram, screenshot, video)
  • --service: Preferred service (gemini, imagen, dalle, veo)
  • --quality: Quality level (standard, hd)
  • --size: Image dimensions (1024x1024, 1792x1024, 1024x1792)

Prerequisites: Run /myai-configure visual first to set up API keys and budgets.

/myai-wordpress-admin

Comprehensive WordPress site administration.

# Security operations
/myai-wordpress-admin security-scan
/myai-wordpress-admin malware-check
/myai-wordpress-admin user-audit --role administrator
/myai-wordpress-admin ssl-check
/myai-wordpress-admin file-permissions

# Performance operations
/myai-wordpress-admin speed-test --detailed
/myai-wordpress-admin database-optimize --cleanup-revisions
/myai-wordpress-admin cache-setup --type redis
/myai-wordpress-admin image-optimize
/myai-wordpress-admin resource-monitor

# Health operations
/myai-wordpress-admin health-check --comprehensive
/myai-wordpress-admin error-analysis --last-24h
/myai-wordpress-admin uptime-check --setup-monitoring
/myai-wordpress-admin backup-verify
/myai-wordpress-admin update-check

# Administrative operations
/myai-wordpress-admin user-manage --list-admins
/myai-wordpress-admin plugin-manage --update-all --check-security
/myai-wordpress-admin content-cleanup --remove-spam --optimize-db
/myai-wordpress-admin settings-optimize --performance-focus
/myai-wordpress-admin staging-deploy

Publishing Commands

/myai-wordpress-publish

Publish markdown content to WordPress.

/myai-wordpress-publish "article.md" --status draft
/myai-wordpress-publish "article.md" --status published

/myai-payloadcms-publish

Publish markdown content to PayloadCMS.

/myai-payloadcms-publish "article.md" --collection posts
/myai-payloadcms-publish "article.md" --status published --id 12345

/myai-docusaurus-publish

Publish markdown content to Docusaurus.

/myai-docusaurus-publish "guide.md"
/myai-docusaurus-publish "post.md" --type blog

/myai-mintlify-publish

Publish markdown content to Mintlify.

/myai-mintlify-publish "guide.mdx"
/myai-mintlify-publish "api-ref.md" --nav-section "API Reference"

/myai-astro-publish

Publish markdown content to Astro.

/myai-astro-publish "article.md" --collection blog
/myai-astro-publish "page.md" --pages

Deployment Commands

/myai-coolify-deploy

Deploy applications to Coolify.

/myai-coolify-deploy

Configuration

/myai-configure

Configure MyAI Method settings.

/myai-configure

Comprehensive Guide

For detailed publishing workflows and platform-specific guides, see PUBLISHING_GUIDE.md

🔧 MCP Server Integration

MyAIDev Method includes three optional MCP (Model Context Protocol) servers for advanced orchestration, testing, and WordPress integration.

Available MCP Servers

1. SPARC Orchestrator - Workflow automation for the 5-phase SPARC methodology

  • sparc_orchestrate - Orchestrate complete 5-phase workflows
  • sparc_status - Get workflow execution status
  • sparc_phase_execute - Execute single SPARC phases
  • sparc_workflow_history - View workflow history
  • sparc_task_results - Get detailed workflow results

2. Chrome DevTools MCP - Browser automation and testing (chrome-devtools-mcp)

  • cdp_connect - Connect to Chrome DevTools Protocol
  • cdp_navigate - Browser navigation
  • cdp_screenshot - Visual testing with screenshots
  • cdp_evaluate - Execute JavaScript in browser
  • cdp_network_monitor - Monitor network requests
  • cdp_console_logs - Capture console logs

3. WordPress MCP - Enhanced WordPress operations with session management

  • Session management and memory persistence
  • Health monitoring and site statistics
  • Batch publishing operations
  • Enhanced WordPress REST API integration

Setup MCP Servers

Add to Claude Code MCP settings:

# SPARC Orchestrator
claude mcp add myaidev-sparc npx myaidev-sparc-orchestrator

# Chrome DevTools (requires separate installation)
npm install -g chrome-devtools-mcp
claude mcp add chrome-devtools npx chrome-devtools-mcp

# WordPress MCP
claude mcp add myaidev-wordpress npx myaidev-mcp-server

Usage Example

// Orchestrate complete SPARC workflow
mcp__myaidev_sparc__sparc_orchestrate({
  task: "Build user authentication system",
  strategy: "sequential",
  phases: ["architecture", "implementation", "testing", "review", "documentation"],
  options: {
    techStack: "nextjs,payloadcms,mongodb",
    testFramework: "jest",
    focusSecurity: true
  }
})

For detailed MCP setup and usage, see MCP_INTEGRATION.md

⚙️ Configuration

After installation for Claude Code, the package creates a .claude directory following official standards:

.claude/
├── commands/           # Custom slash commands
├── agents/            # Agent definitions  
├── mcp/              # MCP server configurations
└── CLAUDE.md         # Project configuration file

🔌 WordPress Integration

Setup WordPress Connection

  1. Create Application Password in WordPress:

    • Go to WordPress Admin → Users → Your Profile
    • Find "Application Passwords" section
    • Enter a name for the application and click "Add New"
    • Copy the generated password

  2. Configure environment variables:

    WORDPRESS_URL=https://your-wordpress-site.com
WORDPRESS_USERNAME=your-username
WORDPRESS_APP_PASSWORD=generated-password

  3. Test the connection:

    /myai-wordpress-admin health-check

WordPress MCP Features

  • Content Publishing: Direct post creation and updates
  • Media Management: Upload and organize media files
  • User Administration: Manage users and roles
  • Plugin/Theme Management: Install, update, activate/deactivate
  • Database Operations: Optimization and cleanup
  • Security Scanning: Vulnerability and malware detection

💻 SSH Integration

SSH integration enables advanced server-level WordPress administration. Claude Code can seamlessly use your existing SSH configuration.

SSH Setup Options

If you already have SSH keys configured:

# Claude Code will automatically use your SSH configuration
ssh user@your-server  # If this works, you're ready!

# Use in commands
/myai-wordpress-admin security-scan  # Will use SSH when available

Option 2: Specify SSH Details

For specific configurations, set environment variables:

SSH_HOST=your-server-ip
SSH_USERNAME=your-ssh-username
SSH_KEY_PATH=/home/user/.ssh/id_rsa  # Optional: specific key path
WORDPRESS_PATH=/var/www/html         # Optional: WordPress installation path

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 use: SSH_HOST=wordpress-server

SSH-Enabled Operations

When SSH access is available, the WordPress admin agent can perform:

  • File System Analysis: Permission audits, malware scanning
  • Server Monitoring: Resource usage, log analysis
  • Database Direct Access: Advanced optimization operations
  • Backup Operations: Full site and database backups
  • Security Hardening: File permission fixes, configuration updates
  • Performance Tuning: Web server configuration, caching setup

Security Considerations

  • Use SSH keys instead of passwords when possible
  • Limit SSH access to trusted IP addresses
  • Regular audit of SSH access logs
  • Use dedicated SSH users with minimal required permissions
  • Keep SSH keys secure and rotated regularly

🎨 Customizing Agents

You can customize agent behavior by editing their Markdown files after installation.

Content Writer Custom Rules (Recommended)

The content-writer agent supports custom content generation rules via a content-rules.md file. This is the recommended approach for customizing content creation without modifying the agent itself.

Quick Start:

# Copy the example template
cp content-rules.example.md content-rules.md

# Edit with your preferences
nano content-rules.md

What you can customize:

  • Brand voice and tone
  • Writing style preferences
  • Formatting guidelines
  • SEO requirements
  • Required/optional content elements
  • Topics to avoid
  • Company-specific terminology

Example content-rules.md:

# Content Generation Rules

## Brand Voice
- Use conversational, friendly tone
- Avoid jargon unless explaining technical concepts

## Formatting Preferences
- Keep paragraphs under 3 sentences
- Use numbered lists for sequential steps

## SEO Guidelines
- Target keyword density: 1-2%
- Include FAQ section for articles over 1000 words

## Required Elements
- Author bio at the end
- Call-to-action in conclusion

Benefits:

  • ✅ No agent modification required
  • ✅ Preserves agent updates when upgrading
  • ✅ Easy to version control
  • ✅ Project-specific customization
  • ✅ Agent continues working if file doesn't exist

Editing Agent Prompts

For deeper customization, you can edit agent files directly:

  1. Locate the agent file:

    # Content writer agent
.claude/agents/content-writer.md

# WordPress admin agent
.claude/agents/wordpress-admin.md

  2. Edit the agent configuration: ```markdown

    name: content-writer description: Your custom description tools: Read, Write, Edit, WebSearch, WebFetch, Task

    Your custom agent prompt goes here...

    Custom Instructions

    • Add your specific requirements
    • Modify the writing style
    • Add industry-specific knowledge

  3. Restart Claude Code to load the changes

Customization Examples

Modify Content Writer for Technical Documentation

---
name: content-writer
description: Technical documentation writer specializing in 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

Customize WordPress Admin for Specific Hosting

---
name: wordpress-admin
description: WordPress administrator specialized for managed hosting environments
tools: Read, Write, Edit, Bash, WebSearch, WebFetch, Task
---

You are a WordPress administrator with expertise in managed hosting environments.

## Hosting-Specific Considerations
- Work within managed hosting limitations
- Use hosting-specific performance tools
- Account for caching layer configurations
- Follow hosting provider security guidelines

## Custom Security Protocols
- Always check with hosting provider before server changes
- Use hosting control panel APIs when available
- Implement hosting-recommended security measures

Agent Prompt Structure

Each agent file should follow this structure:

---
# YAML frontmatter with agent configuration
name: agent-name
description: Brief description of agent capabilities
tools: List, of, available, tools
---

# Agent prompt content in Markdown

## Role Definition
Clear description of the agent's role and expertise.

## Core Capabilities
List of main capabilities and areas of expertise.

## Process Workflow
Step-by-step process the agent should follow.

## Output Format
Specification of expected output format.

## Guidelines and Constraints
Important guidelines, safety measures, and constraints.

Best Practices for Agent Customization

  1. Preserve YAML frontmatter: Always keep the header configuration intact
  2. Test thoroughly: Test customizations in a development environment first
  3. Version control: Keep track of your customizations using git
  4. Document changes: Add comments explaining your customizations
  5. Backup originals: Keep copies of original agent files before modification
  6. Validate tools: Ensure all tools listed in frontmatter are actually needed

Sharing Custom Agents

You can share your custom agents by:

  1. Creating a fork of the repository with your customizations
  2. Exporting agent files and sharing them with your team
  3. Contributing back useful customizations to the main project

📁 Project Structure

.claude/
├── commands/                    # Slash commands (Markdown files)
│   ├── myai-content-writer.md       # Content creation command
│   ├── myai-wordpress-admin.md      # WordPress admin command  
│   ├── myai-wordpress-publish.md    # WordPress publishing command
│   └── myai-configure.md           # Configuration command
├── agents/                     # Agent definitions (Markdown with YAML)
│   ├── content-writer.md           # Content writer agent
│   └── wordpress-admin.md          # WordPress admin agent
├── mcp/                        # MCP integrations
│   └── wordpress-server.js         # WordPress MCP server
└── CLAUDE.md                   # Project configuration

# Additional files created
.env.example                    # Environment variables template
.env                           # Your environment configuration (not in git)

This structure follows Claude Code's official standards for maximum compatibility.

🔧 Environment Variables

Required for WordPress Features

# WordPress Connection (Required)
WORDPRESS_URL=https://your-wordpress-site.com
WORDPRESS_USERNAME=your-admin-username  
WORDPRESS_APP_PASSWORD=your-application-password

Optional SSH Configuration

# SSH Access (Optional - use existing SSH config if not specified)
SSH_HOST=your-server-ip-or-hostname
SSH_USERNAME=your-ssh-username
SSH_KEY_PATH=/path/to/private/key
SSH_PORT=22

# WordPress Server Configuration (Optional)
WORDPRESS_PATH=/var/www/html

Optional Content Defaults

# Content Writer Defaults (Optional)
DEFAULT_WORD_COUNT=800
DEFAULT_POST_STATUS=draft
DEFAULT_TONE=professional
DEFAULT_AUDIENCE=general

Environment File Setup

  1. Copy the example file:

    cp .env.example .env

  2. Edit with your values:

    nano .env  # or your preferred editor

  3. Secure the file:

    chmod 600 .env  # Restrict access to owner only

💡 Examples

Content Creation Workflow

# Create SEO-optimized blog post
/myai-content-writer "10 Essential WordPress Security Tips" --word_count 1200 --seo_keywords "wordpress security,website protection,wp security tips"

# Create technical documentation  
/myai-content-writer "API Integration Guide" --tone technical --audience developers --word_count 1500

# Create and publish to WordPress
/myai-content-writer "Summer Marketing Strategies" --publish_to_wordpress true --tone professional

WordPress Administration Workflow

# Daily health check routine
/myai-wordpress-admin health-check --comprehensive

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

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

# Maintenance workflow
/myai-wordpress-admin update-check
/myai-wordpress-admin plugin-manage --update-all --check-security
/myai-wordpress-admin content-cleanup --remove-spam
/myai-wordpress-admin backup-verify

Content Publishing Workflow

# Create content locally
/myai-content-writer "Guide to Remote Team Management" --word_count 1000

# Review and edit the generated content
# (Content is saved as markdown file)

# Publish to WordPress
/myai-wordpress-publish "guide-to-remote-team-management.md" --status draft

# Or publish immediately
/myai-wordpress-publish "guide-to-remote-team-management.md" --status publish

🔍 Troubleshooting

Common Issues and Solutions

Commands Not Appearing in Claude Code

Problem: Custom slash commands don't appear in the / menu.

Solutions:

  1. Ensure files are in .claude/commands/ (not .myaidev/)
  2. Verify YAML frontmatter is valid
  3. Restart Claude Code
  4. Check file permissions (chmod 644 .claude/commands/*.md)

WordPress Connection Issues

Problem: Cannot connect to WordPress site.

Solutions:

  1. Verify credentials:

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

  2. Check WordPress settings:

    • Ensure REST API is enabled
    • Verify Application Password is created correctly
    • Check if site has HTTPS enabled

  3. Firewall/Security:

    • Whitelist your IP address
    • Temporarily disable security plugins for testing
    • Check hosting provider restrictions

SSH Connection Problems

Problem: SSH operations fail or timeout.

Solutions:

  1. Test SSH manually:

    ssh user@your-server

  2. Check SSH configuration:

    # Verify SSH config
cat ~/.ssh/config

# Check key permissions
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub

  3. Server-side checks:

    • Verify SSH daemon is running
    • Check firewall rules (port 22)
    • Confirm user has necessary permissions

Agent Not Working as Expected

Problem: Agent behavior doesn't match expectations.

Solutions:

  1. Check agent file:

    # Verify agent file exists and has correct format
cat .claude/agents/content-writer.md

  2. Validate YAML frontmatter:

    • Ensure proper YAML syntax
    • Verify all required fields are present
    • Check tool permissions

  3. Clear Claude Code cache:

    • Restart Claude Code
    • Clear browser cache if using web interface

Performance Issues

Problem: Operations are slow or timeout.

Solutions:

  1. Optimize WordPress database:

    /myai-wordpress-admin database-optimize

  2. Check server resources:

    /myai-wordpress-admin resource-monitor

  3. Review error logs:

    /myai-wordpress-admin error-analysis

Debug Mode

Enable debug mode for detailed error information:

# Add to your .env file
DEBUG=true
VERBOSE_LOGGING=true

Getting Help

  1. Check the logs: Look for error messages in Claude Code output
  2. Test components individually: Verify WordPress, SSH, and MCP connections separately
  3. Consult documentation: Review Claude Code official documentation
  4. Community support: Join Claude Code community forums
  5. GitHub issues: Report bugs and request features on the repository

🤝 Contributing

We welcome contributions to improve MyAIDev Method!

How to Contribute

  1. Fork the repository
  2. Create a feature branch: git checkout -b feature/new-agent
  3. Make your changes
  4. Test thoroughly
  5. Submit a pull request

Contribution Ideas

  • New agents: Create agents for different domains (code review, documentation, etc.)
  • Additional CLI support: Add support for more AI CLI tools
  • Enhanced integrations: Add support for other CMSs or platforms
  • Documentation improvements: Help improve guides and examples
  • Bug fixes: Fix issues and improve reliability

Development Setup

# Clone the repository
git clone https://github.com/myaione/myaidev-method.git
cd myaidev-method

# Install dependencies
npm install

# Test locally without publishing
npm pack
cd /path/to/test-project
npm install /path/to/myaidev-method-0.0.1.tgz
npx myaidev-method@latest init --claude

# Or link for development
npm link
cd /path/to/test-project
npm link myaidev-method
npx myaidev-method@latest init --claude

📄 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

  • Anthropic for Claude Code and the standards we follow
  • WordPress for the robust REST API
  • Community contributors who help improve this package

Author: Samuel Mukoti samuelm@openmy.ai

For questions, issues, or feature requests, please visit the GitHub repository.