[Skill 名] architect-reviewer

Architect-Reviewer Skill

This skill allows an AI assistant to act as an architect or reviewer for a given problem. The AI assistant will provide a high-level design, identify potential issues, and suggest improvements.

Use Cases

• System Design: Design a new system or component based on requirements.
• Code Review: Review existing code for architectural soundness, best practices, and potential issues.
• Solution Architecture: Propose a solution architecture for a business problem.
• Technology Evaluation: Evaluate different technologies or frameworks for a specific use case.

Parameters

• problem_description (string, required): A detailed description of the problem or system to be designed/reviewed.
• context (string, optional): Additional context or background information relevant to the problem.
• design_principles (array of strings, optional): A list of design principles or guidelines to adhere to (e.g., "scalability," "security," "cost-effectiveness").
• output_format (string, optional, default: "markdown"): The desired output format for the review (e.g., "markdown," "json").

Example Usage

{
  "skill": "architect-reviewer",
  "parameters": {
    "problem_description": "Design a highly available and scalable e-commerce platform that can handle 1 million concurrent users and process 1000 orders per second. The platform should support product catalog management, user authentication, shopping cart functionality, and order processing.",
    "design_principles": ["scalability", "high availability", "security", "cost-effectiveness"],
    "context": "The existing platform is monolithic and struggles with performance under heavy load. We want to migrate to a microservices-based architecture."
  }
}

Output Structure (Markdown Example)

# Architectural Review for E-commerce Platform

## High-Level Design

### 1. Microservices Architecture
*   **Services:**
    *   `Product Service`: Manages product catalog.
    *   `User Service`: Handles user authentication and profiles.
    *   `Cart Service`: Manages shopping carts.
    *   `Order Service`: Processes orders.
    *   `Payment Service`: Integrates with payment gateways.
    *   `Notification Service`: Sends order confirmations, etc.
*   **Communication:** Asynchronous communication using message queues (e.g., Kafka, RabbitMQ) for inter-service communication. REST APIs for client-facing interactions.
*   **API Gateway:** Single entry point for all client requests, handles routing, authentication, and rate limiting.

### 2. Data Storage
*   **Polyglot Persistence:**
    *   `Product Service`: NoSQL database (e.g., MongoDB, DynamoDB) for flexible product schemas.
    *   `User Service`: Relational database (e.g., PostgreSQL, MySQL) for ACID compliance.
    *   `Cart Service`: In-memory data store (e.g., Redis) for fast access and session management.
    *   `Order Service`: Relational database for transactional integrity.
*   **Data Replication:** Implement multi-region replication for high availability and disaster recovery.

### 3. Scalability & High Availability
*   **Containerization:** Deploy services using Docker and orchestrate with Kubernetes.
*   **Auto-scaling:** Configure horizontal auto-scaling for all services based on load metrics.
*   **Load Balancing:** Use load balancers (e.g., AWS ELB, Nginx) to distribute traffic across service instances.
*   **Caching:** Implement CDN for static assets and in-memory caches (e.g., Redis) for frequently accessed data.
*   **Database Sharding/Clustering:** Distribute data across multiple database instances for scalability.

### 4. Security
*   **Authentication & Authorization:** OAuth 2.0 / OIDC for user authentication, JWT for API authorization.
*   **Network Security:** VPCs, security groups, network ACLs to isolate services.
*   **Data Encryption:** Encrypt data at rest and in transit.
*   **API Security:** Rate limiting, input validation, WAF.

## Potential Issues and Improvements

### 1. Data Consistency in Microservices
*   **Issue:** Maintaining data consistency across multiple services with polyglot persistence can be challenging (e.g., distributed transactions).
*   **Improvement:** Implement the Saga pattern for complex business transactions spanning multiple services. Use eventual consistency where appropriate.

### 2. Operational Complexity
*   **Issue:** Microservices introduce significant operational overhead (monitoring, logging, deployment, debugging).
*   **Improvement:**
    *   **Observability:** Implement a robust observability stack (e.g., Prometheus for metrics, Grafana for dashboards, ELK stack/Loki for logging, Jaeger/Zipkin for distributed tracing).
    *   **CI/CD:** Automate deployments with a comprehensive CI/CD pipeline.
    *   **Infrastructure as Code (IaC):** Manage infrastructure using tools like Terraform or CloudFormation.

### 3. Cost Optimization
*   **Issue:** Cloud costs can escalate rapidly with a highly distributed system.
*   **Improvement:**
    *   **Right-sizing:** Continuously monitor resource utilization and right-size instances.
    *   **Serverless:** Consider using serverless functions (e.g., AWS Lambda) for event-driven or less frequently accessed components.
    *   **Reserved Instances/Savings Plans:** Utilize cost-saving options for predictable workloads.

### 4. Latency with Distributed Transactions
*   **Issue:** While Saga pattern helps with consistency, it can introduce latency due to multiple service calls.
*   **Improvement:** Optimize critical paths to minimize inter-service communication. Consider command query responsibility segregation (CQRS) for read-heavy operations to reduce load on transactional services.

## Conclusion

The proposed microservices architecture addresses the scalability and high availability requirements. Careful attention to data consistency, operational complexity, and cost optimization will be crucial for successful implementation.