skills.rest
karitham
karithamCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

software-architecture

Analyze and structure software systems using bounded contexts and dependency rejection.

2|Updated Mar 16, 2021
Search Tags:#design#architecture#reliability#event-driven#bounded-context#dataflow#module-boundaries
One-click install
npx skills add https://github.com/karitham/dotfiles --skill software-architecture-karitham
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: software-architecture
Source: https://github.com/karitham/dotfiles/tree/main/modules/opencode/skills/software-architecture
Command: npx skills add https://github.com/karitham/dotfiles --skill software-architecture-karitham

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides a disciplined framework for designing and structuring non-trivial software systems to reduce complexity and manage side effects.

Core Features & Use Cases

  • Bounded contexts and deep module boundaries to minimize coupling.
  • Impure-Pure-Impure sandwich guidance to isolate I/O from business logic.
  • Event-driven patterns, dataflow thinking, and resilience guidelines to support scalable architectures.

Quick Start

Draft a high-level architecture plan for the target project, identifying public versus internal boundaries and a first-cut module structure.

Frequently Asked Questions about software-architecture

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

FAQPage Schema
How do I structure complex software to manage side effects and reduce coupling?▼

Isolate I/O from business logic using the impure-pure-impure sandwich pattern. This design guideline separates external interactions from pure functional code, ensuring reliable dataflow modeling and cleaner module decomposition.

What is the best way to design event-driven architecture for scalable systems?▼

Design event-driven architecture by applying resilience guidelines and dataflow thinking. This approach supports scalable architectures by structuring systems to react to events while maintaining strict module boundaries and bounded contexts.

Does this software architecture approach work for small projects and API design?▼

Yes, this approach applies to API design and projects of varying sizes. You can draft a high-level architecture plan to define module boundaries and structure internal versus public interfaces effectively, regardless of scale.

How do I start defining module boundaries for a new software system?▼

Start by drafting a high-level architecture plan that identifies public versus internal boundaries. This first-cut module structure applies dependency rejection to enforce bounded contexts and minimize unwanted coupling across the system.

When should I use bounded contexts in software architecture?▼

Use bounded contexts when managing complexity in non-trivial software systems. This pattern enforces dependency rejection and deep module boundaries, preventing side effects from propagating across different functional areas of an application.

Related Skills

Explore More Software Engineering Skills→
skyf0xxskyf0xx
26

hedgehog-planning-intake

Convert project descriptions into BMAD-based technical build plans and TODO checklists.

Community
Advanced
aRustyDevaRustyDev
1

microservices-patterns

Design microservices architectures with service boundaries, event-driven communication, and resilience patterns.

Community
Advanced
whatiskadudoingwhatiskadudoing
11

Managing Side Effects Functionally

Separates Side effects from pure core logic in TypeScript using IO-style sequencing and quarantining patterns.

Community
Advanced
oalansilvaoalansilva

domain-modeling

Identify and define domains and bounded contexts for complex software systems.

Community
Advanced