tzurot-architecture

Delineates microservice boundaries for the Tzurot v3 architecture.

7|2|Updated May 17, 2025
One-click install
npx skills add https://github.com/lbds137/tzurot --skill tzurot-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tzurot-architecture
Source: https://github.com/lbds137/tzurot/tree/main/.claude/skills/tzurot-architecture
Command: npx skills add https://github.com/lbds137/tzurot --skill tzurot-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designing and maintaining a scalable microservices architecture requires clear boundaries, communication patterns, and a shared understanding of responsibilities. This Skill outlines Tzurot v3's architectural principles, guiding you in making informed design decisions.

Core Features & Use Cases

  • Clear Service Boundaries: Define the distinct responsibilities of bot-client (Discord interface), api-gateway (HTTP API + Job Queue), and ai-worker (AI processing + Memory).
  • Shared Code Management: Understand what belongs in common-types (types, utilities, shared services) to prevent duplication and ensure consistency across the monorepo.
  • Data Flow & Interaction Patterns: Trace the journey of a Discord message through the entire microservices stack to an AI response, clarifying inter-service communication.
  • Anti-Patterns from v2: Learn from past mistakes, avoiding over-engineering, excessive abstraction layers, and complex dependency injection containers.

Quick Start

Use the tzurot-architecture skill to determine which microservice should handle a new feature that involves both Discord interactions and AI processing, ensuring clear separation of concerns.

Frequently Asked Questions about tzurot-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I define microservice boundaries in a scalable system design?

Microservice boundaries separate distinct responsibilities into independent services. Tzurot v3 architecture delineates three core services: bot-client handles Discord interactions, api-gateway manages HTTP requests and job queues, and ai-worker processes AI logic and memory. Clear boundaries prevent circular dependencies and enforce single-responsibility ownership.

What's the best way to avoid circular dependencies when refactoring service boundaries?

Enforce strict single-responsibility boundaries and use shared types in a common-types module to prevent duplication across services. Constructor injection makes dependencies explicit. Each service owns specific code modules mapped to its responsibility, avoiding back-references and keeping the dependency graph acyclic.

Where should I place shared code and types in a microservices architecture?

Place shared types, utilities, and shared services in a common-types module accessible to all microservices. This prevents code duplication, ensures consistency across the monorepo, and maintains clean service boundaries without services depending directly on each other's implementation.

How do I determine which service should handle a feature spanning multiple microservices?

Trace the feature's data flow through your service architecture. In Tzurot v3, Discord interactions belong to bot-client, API requests to api-gateway, and AI processing to ai-worker. Assign ownership based on the primary responsibility; use inter-service communication patterns for cross-cutting concerns.

What anti-patterns should I avoid when designing microservices?

Avoid over-engineering, excessive abstraction layers, and complex dependency injection containers that obscure service responsibilities. Keep classes simple and focused. Use explicit constructor injection instead of service locators, and maintain clean separation between services to prevent the tight coupling that plagued earlier architecture versions.

Can I apply microservices design principles to a monorepo structure?

Yes. A monorepo can enforce microservices design through strict code ownership, shared type modules, and clear service boundaries without separate deployments. Tzurot v3 uses this approach: bot-client, api-gateway, and ai-worker maintain distinct responsibilities within a single codebase through constructor injection and anti-circular-dependency rules.