scalable-architecture

Define contracts and abstractions to decouple modules with dependency inversion.

Updated Mar 12, 2026
One-click install
npx skills add https://github.com/Hashzin-0/Curion --skill scalable-architecture-hashzin-0
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: scalable-architecture
Source: https://github.com/Hashzin-0/Curion/tree/main/.opencode/skills/scalable-architecture
Command: npx skills add https://github.com/Hashzin-0/Curion --skill scalable-architecture-hashzin-0

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Hidden coupling and direct imports between features create fragile systems where a change in one module can break others and make testing difficult; this skill prescribes contracts, inversion of control, and event-driven interactions to keep modules replaceable and independently testable.

Core Features & Use Cases

  • Contracts-first design: define clear interfaces before implementations so consumers depend on abstractions rather than concrete modules.
  • Dependency inversion & DI: ensure high-level business logic owns contracts while low-level infrastructure implements them, with wiring at the composition root.
  • Event-driven side effects: replace direct cross-feature calls with event emissions and listeners to decouple side effects.
  • Use Case: When adding an orders feature that needs user data, design an IUserRepository contract, implement it in infra, inject it into the order use case, and emit user:created events for notifications and analytics so no feature imports another directly.

Quick Start

Ask the assistant to analyze a proposed cross-feature change and output the required contracts, DI wiring, and event handlers that decouple the involved modules.

Frequently Asked Questions about scalable-architecture

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

FAQPage Schema
How do I decouple modules and prevent hidden coupling in backend features?

To decouple modules and prevent hidden coupling, define clear contracts and abstractions before implementations so consumers depend on interfaces rather than concrete modules directly.

What is the best way to design cross-domain interactions without direct imports?

The best way to design cross-domain interactions without direct imports is using event-driven side effects, replacing direct cross-feature calls with event emissions and listeners to decouple modules.

How do I apply dependency inversion when adding a new feature?

Apply dependency inversion by ensuring high-level business logic owns contracts while low-level infrastructure implements them, wiring dependencies at the composition root for testable, replaceable implementations.

Does dependency injection work with contracts-first design for replaceable components?

Dependency injection works seamlessly with contracts-first design by injecting abstract interfaces into use cases, ensuring modules remain independently testable and implementations easily replaceable.

Why does direct cross-feature calling create fragile system architecture?

Direct cross-feature calling creates fragile architecture because hidden coupling means a change in one module can break others, making testing difficult and modules non-replaceable.