mdsoc-architecture-writing

Map repository architecture into layered MDSOC with visibility rules and migration plans.

1|Updated Mar 8, 2026
One-click install
npx skills add https://github.com/ormastes/simple --skill mdsoc-architecture-writing
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: mdsoc-architecture-writing
Source: https://github.com/ormastes/simple/tree/main/.codex/skills/mdsoc-architecture-writing
Command: npx skills add https://github.com/ormastes/simple --skill mdsoc-architecture-writing

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Write or refactor layered MDSOC-style architecture docs for this repo, especially for compiler, loader, interpreter, and shared tree-node visibility. Use when the task asks for layers, tree encapsulation, public-to-next-layer rules, common node extraction, or sibling-private/tree-private analysis.

Core Features & Use Cases

  • Layered architecture mapping with explicit visibility between adjacent layers.
  • Extraction of common tree nodes into a shared layer to reduce duplication.
  • Documentation of public surfaces and facades between layers, with enforcement guidelines.

Quick Start

Review doc/architecture and the real module tree, then draft a current-state map and a to-be MDSOC design with common nodes and visibility rules.

Frequently Asked Questions about mdsoc-architecture-writing

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

FAQPage Schema
How do I document layered architecture with explicit module visibility rules?▼

Document layered architecture with explicit visibility by mapping current-state module paths, then drafting a to-be design that extracts common tree nodes and enforces public-facing facades between adjacent layers.

What is MDSOC architecture and when do I need to write docs for it?▼

MDSOC architecture is a layered design emphasizing explicit module visibility and tree encapsulation. You need to document it when refactoring compiler, loader, or interpreter components to enforce public-to-next-layer rules and reduce duplicated tree nodes.

How do I extract common tree nodes into a shared architecture layer?▼

Extract common tree nodes by analyzing the real module tree to identify duplicated paths, then refactoring them into a shared layer to reduce duplication while preserving exact repository paths and documenting the migration plan.

Does this architecture documentation approach report visibility violations?▼

Yes, the architecture documentation approach reports visibility violations. It analyzes existing architecture docs and the real module tree, ensuring output adheres to the visibility model and flags any public-to-next-layer rule breaches.

What is the best way to map current-state module paths before refactoring?▼

The best way to map current-state module paths is using command-line search tools like rg and find to scan the repository, reviewing existing architecture documentation to establish a baseline before drafting the to-be MDSOC design.

When should I not use a layered MDSOC architecture design?▼

You should not use a layered MDSOC architecture design when your repository lacks distinct compiler, loader, or interpreter layers, or when your project does not require strict tree encapsulation and explicit public-facing facades between adjacent modules.