Workflow Patterns

Proven patterns and best practices for different development scenarios

Workflow Overview

NikCLI supports various workflow patterns optimized for different development scenarios. These proven patterns help you maximize productivity while maintaining code quality and consistency.

Feature Development

End-to-end feature implementation workflows

Maintenance & Refactoring

Code improvement and optimization patterns

Bug Fixing

Systematic debugging and issue resolution

Project Setup

New project initialization and configuration

Development Workflow Patterns

1. Feature Development Workflow

1. Requirements Analysis

   Start with clear feature requirements and planning

   > /plan create "User authentication with social login"
   
   📋 Feature Analysis:
   ├── Authentication methods (email, Google, GitHub)
   ├── User registration and login flows
   ├── Session management and security
   ├── Password reset functionality
   └── User profile management
   
   Estimated complexity: Medium-High
   Implementation time: 3-4 hours
   

2. Architecture Planning

   Define technical architecture and approach

   > Plan the technical implementation approach
   
   🏗️ Architecture Plan:
   
   Backend Components:
   ├── User model with Mongoose/Prisma
   ├── JWT authentication middleware
   ├── OAuth integration (Passport.js)
   ├── Email verification system
   └── Password reset with secure tokens
   
   Frontend Components:
   ├── Authentication forms (login/register)
   ├── Social login buttons
   ├── Protected route wrapper
   ├── User profile management
   └── Authentication context/store
   

3. Implementation Phase

   Execute the plan with coordinated development

   > /auto "Implement the authentication system according to the plan"
   
   🤖 Multi-agent execution:
   
   Backend Agent:
   ├── ✅ User model with validation
   ├── ✅ JWT middleware setup
   ├── 🔄 OAuth configuration
   └── ⏳ Email service integration
   
   Frontend Agent:
   ├── ✅ Login/register forms
   ├── 🔄 Social login integration
   └── ⏳ Authentication context
   
   Integration Agent:
   ├── 🔄 API endpoint testing
   └── ⏳ E2E flow validation
   

4. Testing & Validation

   Comprehensive testing and quality assurance

   > Add comprehensive tests for the authentication system
   
   🧪 Testing Implementation:
   
   Unit Tests:
   ├── User model validation
   ├── JWT token generation/verification
   ├── Password hashing functions
   └── OAuth callback handling
   
   Integration Tests:
   ├── Login/logout flows
   ├── Registration with email verification
   ├── Password reset workflow
   └── Social login integration
   
   E2E Tests:
   ├── Complete user journey
   ├── Cross-browser compatibility
   └── Mobile responsiveness
   

5. Documentation & Deployment

   Finalize with documentation and deployment preparation

   > Document the authentication system and prepare for deployment
   
   📚 Documentation:
   ├── API endpoint documentation
   ├── Frontend component usage
   ├── Configuration guide
   └── Security considerations
   
   🚀 Deployment Prep:
   ├── Environment variable setup
   ├── Database migration scripts
   ├── Security configuration
   └── Monitoring setup
   

2. Bug Fix Workflow

Issue Investigation

Systematic approach to understanding the problem

> The user login is failing intermittently with 500 errors

🔍 Bug Investigation Process:

1. Reproduce the Issue:
├── Gather error logs and stack traces
├── Identify reproduction steps
├── Check environment differences
└── Document failure patterns

2. Root Cause Analysis:
├── Database connection analysis
├── Authentication middleware review
├── Rate limiting investigation
└── Concurrent request handling

3. Impact Assessment:
├── Affected user percentage
├── Business impact analysis
├── Temporary workaround options
└── Fix priority determination

3. Refactoring Workflow

Code Quality Assessment

Analyze current state and identify improvement opportunities

> Analyze the codebase and suggest refactoring opportunities

📊 Code Quality Analysis:

Technical Debt Assessment:
├── Cyclomatic complexity analysis
├── Code duplication detection
├── Dependency analysis
├── Test coverage evaluation
└── Performance bottleneck identification

Refactoring Opportunities:
├── Extract common components/utilities
├── Improve error handling patterns
├── Optimize database queries
├── Enhance type safety
└── Modernize legacy code patterns

Priority Matrix:
├── High Impact, Low Effort: Quick wins
├── High Impact, High Effort: Major initiatives
├── Low Impact, Low Effort: Maintenance tasks
└── Low Impact, High Effort: Avoid unless necessary

Incremental Refactoring

Systematic approach to code improvement

> Refactor the user management system to improve maintainability

🔄 Incremental Refactoring Plan:

Phase 1: Foundation (1-2 days)
├── Extract reusable validation functions
├── Standardize error handling
├── Improve type definitions
└── Add comprehensive tests

Phase 2: Structure (2-3 days)
├── Separate concerns (controllers/services)
├── Implement repository pattern
├── Extract business logic
└── Optimize database operations

Phase 3: Enhancement (1-2 days)
├── Add caching layer
├── Improve API design
├── Enhance security measures
└── Performance optimization

Safety Measures:
├── Comprehensive test coverage before changes
├── Feature flags for gradual rollout
├── Database backup before migrations
└── Rollback plan preparation

Performance Optimization

Systematic performance improvement workflow

> Optimize application performance across frontend and backend

⚡ Performance Optimization Workflow:

1. Baseline Measurement:
├── Load time analysis
├── Bundle size audit
├── Database query profiling
├── Memory usage monitoring
└── API response time tracking

2. Frontend Optimization:
├── Code splitting implementation
├── Image optimization and lazy loading
├── Component memoization
├── Bundle analysis and tree shaking
└── Service worker caching

3. Backend Optimization:
├── Database indexing and query optimization
├── Redis caching implementation
├── API response compression
├── Connection pooling optimization
└── Background job processing

4. Infrastructure Optimization:
├── CDN configuration
├── Load balancer setup
├── Database replication
└── Monitoring and alerting

Project Setup Patterns

Full-Stack Application Setup

1. Project Initialization

   Set up the project structure and tooling

   > /auto "Create a new full-stack TypeScript application with React frontend and Node.js backend"
   
   🏗️ Project Structure Creation:
   
   ├── client/ (React TypeScript)
   │   ├── src/
   │   │   ├── components/
   │   │   ├── pages/
   │   │   ├── hooks/
   │   │   ├── services/
   │   │   └── types/
   │   ├── public/
   │   └── package.json
   │
   ├── server/ (Node.js TypeScript)
   │   ├── src/
   │   │   ├── routes/
   │   │   ├── models/
   │   │   ├── middleware/
   │   │   ├── services/
   │   │   └── types/
   │   └── package.json
   │
   ├── shared/ (Common types and utilities)
   ├── docker-compose.yml
   └── README.md
   

2. Development Environment

   Configure development tools and workflows

   > Set up development environment with TypeScript, ESLint, Prettier, and testing
   
   🛠️ Development Configuration:
   
   Code Quality:
   ├── TypeScript strict configuration
   ├── ESLint with TypeScript rules
   ├── Prettier formatting
   ├── Husky pre-commit hooks
   └── Lint-staged for optimized checks
   
   Testing Setup:
   ├── Vitest for unit testing
   ├── Testing Library for React components
   ├── Supertest for API testing
   ├── Playwright for E2E testing
   └── Coverage reporting configuration
   
   Development Tools:
   ├── Hot reload for both client and server
   ├── Environment variable management
   ├── Database setup with Docker
   ├── API documentation with OpenAPI
   └── Development scripts and aliases
   

3. CI/CD Pipeline

   Automated testing and deployment pipeline

   > Set up CI/CD pipeline with GitHub Actions
   
   🚀 CI/CD Configuration:
   
   Continuous Integration:
   ├── Automated testing on pull requests
   ├── Code quality checks (lint, format)
   ├── Type checking validation
   ├── Security vulnerability scanning
   └── Build verification
   
   Continuous Deployment:
   ├── Staging environment deployment
   ├── Production deployment with approval
   ├── Database migration automation
   ├── Health check validation
   └── Rollback capability
   
   Monitoring & Alerts:
   ├── Application performance monitoring
   ├── Error tracking and reporting
   ├── Uptime monitoring
   ├── Performance regression alerts
   └── Security incident notifications
   

Microservices Architecture

Service Design

Design microservices architecture

> Design a microservices architecture for an e-commerce platform

🏛️ Microservices Design:

Core Services:
├── User Service (authentication, profiles)
├── Product Service (catalog, inventory)
├── Order Service (cart, checkout, orders)
├── Payment Service (payment processing)
├── Notification Service (email, SMS, push)
└── Analytics Service (tracking, reporting)

Infrastructure Services:
├── API Gateway (routing, authentication)
├── Service Discovery (Consul/Eureka)
├── Configuration Service (centralized config)
├── Logging Service (centralized logging)
└── Monitoring Service (metrics, health checks)

Communication Patterns:
├── Synchronous: REST APIs for real-time operations
├── Asynchronous: Message queues for event processing
├── Event Sourcing: For audit trails and state reconstruction
└── CQRS: Separate read/write models for optimization

Team Collaboration Patterns

Code Review Workflow

Pre-Review Preparation

Prepare code for effective review

> Prepare my changes for code review

📝 Pre-Review Checklist:

Code Quality:
├── Self-review for obvious issues
├── Run all tests and ensure they pass
├── Verify linting and formatting compliance
├── Check for TODOs and incomplete features
└── Validate TypeScript compilation

Documentation:
├── Update relevant documentation
├── Add or update code comments
├── Create/update API documentation
├── Update changelog if applicable
└── Ensure commit messages are descriptive

Testing:
├── Add tests for new functionality
├── Update existing tests if needed
├── Verify test coverage meets requirements
├── Include integration/E2E tests where appropriate
└── Test edge cases and error scenarios

Review Process

Systematic code review approach

> Conduct a thorough code review

🔍 Review Process:

Architecture Review:
├── Evaluate design decisions
├── Check consistency with existing patterns
├── Assess scalability implications
├── Review security considerations
└── Validate performance impact

Code Quality Review:
├── Check for code clarity and readability
├── Evaluate error handling
├── Review naming conventions
├── Assess code reusability
└── Validate best practices adherence

Testing Review:
├── Evaluate test coverage
├── Review test quality and maintainability
├── Check for missing test scenarios
├── Validate test isolation
└── Assess integration test coverage

Documentation Review:
├── Check API documentation accuracy
├── Review code comments usefulness
├── Validate README updates
└── Ensure examples are working

Pair Programming with AI

AI-Assisted Development

Collaborative development with AI assistance

> Let's work together on implementing the payment processing feature

👥 Pair Programming Session:

Session Setup:
├── Define clear objectives and scope
├── Establish roles (driver/navigator)
├── Set up shared development environment
├── Prepare relevant documentation and resources
└── Configure AI assistant preferences

Development Process:
├── Break down tasks into small chunks
├── Implement incrementally with AI assistance
├── Continuous testing and validation
├── Regular refactoring and cleanup
└── Document decisions and learnings

Quality Assurance:
├── Continuous code review
├── Test-driven development approach
├── Security consideration validation
├── Performance impact assessment
└── Maintainability evaluation

Best Practices by Scenario

Feature Development

Structured Approach

• Start with planning mode
• Break into manageable phases
• Use autonomous mode for implementation
• Include comprehensive testing

Quality Gates

• Code review checkpoints
• Automated testing validation
• Performance impact assessment
• Security consideration review

Bug Fixing

Investigation First

• Reproduce reliably
• Understand root cause
• Assess impact and urgency
• Plan comprehensive fix

Prevention Focus

• Add tests for the bug scenario
• Implement monitoring/alerts
• Document the issue and solution
• Review related code areas

Refactoring

Safety First

• Comprehensive test coverage
• Incremental changes
• Feature flags for gradual rollout
• Rollback plan preparation

Value Focused

• Clear improvement objectives
• Measurable success criteria
• Stakeholder communication
• Documentation updates

New Projects

Foundation First

• Solid project structure
• Development tooling setup
• CI/CD pipeline early
• Documentation from start

Growth Oriented

• Scalable architecture
• Monitoring and observability
• Security by design
• Performance considerations

Workflow Customization

Custom Workflow Templates

Creating Custom Workflows

// ~/.nikcli/workflows/feature-development.json
{
  "name": "Feature Development Workflow",
  "description": "End-to-end feature implementation",
  "phases": [
    {
      "name": "Planning",
      "mode": "plan",
      "agents": ["planner-agent"],
      "checkpoints": ["requirements-review", "architecture-approval"]
    },
    {
      "name": "Implementation", 
      "mode": "autonomous",
      "agents": ["universal-agent", "frontend-agent", "backend-agent"],
      "parallel": true,
      "checkpoints": ["code-review", "test-coverage"]
    },
    {
      "name": "Integration",
      "mode": "chat",
      "agents": ["integration-agent"],
      "checkpoints": ["e2e-tests", "performance-validation"]
    }
  ],
  "quality_gates": {
    "test_coverage": 80,
    "code_quality": "A",
    "security_scan": "pass"
  }
}

Workflow Automation

# Activate custom workflow
nikcli workflow use feature-development

# Run workflow with parameters
nikcli workflow run feature-development \
  --feature "user authentication" \
  --complexity high \
  --timeline "3 days"

# Monitor workflow progress
nikcli workflow status

# Customize workflow for project
nikcli workflow customize feature-development \
  --add-checkpoint security-review \
  --set-coverage 90

Next Steps

CLI Commands

Master all available commands for workflow automation

Agent System

Understand how agents work together in workflows

Examples

See practical examples of workflow implementations

Advanced Features

Configure advanced workflow automation features

Workflows are most effective when tailored to your team’s specific needs. Start with the provided templates and customize them based on your project requirements and team preferences.