orkestra-go

Implement Orkestra modular monolith modules with Huma v2 API standards.

1|1|Updated Dec 20, 2025
One-click install
npx skills add https://github.com/orkestra-cc/orkestra --skill orkestra-go
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: orkestra-go
Source: https://github.com/orkestra-cc/orkestra/tree/main/.claude/skills/orkestra-go
Command: npx skills add https://github.com/orkestra-cc/orkestra --skill orkestra-go

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides architectural guidance and implementation standards for the Orkestra modular monolith, ensuring consistent development across its core-only base and addon modules.

Core Features & Use Cases

  • Module Lifecycle Management: Standardizes the implementation of the Module interface, including registration, dependency injection, and lifecycle hooks.
  • Cross-Module Communication: Enforces the use of shared interfaces and the ServiceRegistry to prevent tight coupling between modules.
  • Tenancy & Security: Provides patterns for implementing two-tier tenancy (operator vs. client) and RBAC using Huma v2 and context-aware middleware.

Quick Start

Ask the orkestra-go skill to generate a new module scaffold that implements the BaseModule interface and registers its dependencies in the catalog.

Frequently Asked Questions about orkestra-go

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

FAQPage Schema
How do I structure a modular monolith in Go to prevent tight coupling between modules?

To prevent tight coupling in a Go modular monolith, enforce shared interfaces and utilize a ServiceRegistry for cross-module communication. This standardizes module lifecycle management and ensures dependencies are properly injected without direct references.

What is the standard way to scaffold a new backend module that registers its own dependencies?

Scaffolding a new backend module requires generating a structure that implements the BaseModule interface and registers its dependencies in a central catalog. This enforces proper lifecycle hook integration and maintains compliance with core-only base requirements.

How do I implement two-tier tenancy and RBAC in a Huma v2 API?

Implementing two-tier tenancy and RBAC with Huma v2 requires applying context-aware middleware to differentiate operator versus client access levels. This provides standardized security patterns for multi-tenant API routing within the modular backend.

Does the Orkestra modular monolith architecture support multi-tenant API routing?

Yes, the Orkestra modular monolith architecture supports multi-tenant API routing. It provides specific architectural patterns and implementation standards to handle two-tier tenancy, distinguishing between operator and client API contexts securely using Huma v2.

What are the limitations of using a ServiceRegistry for cross-module communication in a monolith?

Using a ServiceRegistry limits cross-module communication to predefined shared interfaces, preventing tight coupling but restricting direct method calls. Modules must strictly adhere to the BaseModule interface and ADR-0006 compliance for lifecycle consistency.