sage-architecture

Define modular boundaries and naming conventions for Sage applications.

12|1|Updated Jul 15, 2025
One-click install
npx skills add https://github.com/majiayu000/sage --skill sage-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sage-architecture
Source: https://github.com/majiayu000/sage/tree/main/.sage/skills/sage-architecture
Command: npx skills add https://github.com/majiayu000/sage --skill sage-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Sage architecture guide provides a cohesive blueprint to structure large Sage projects, reducing fragmentation and enabling scalable collaboration across teams.

Core Features & Use Cases

  • Module boundary enforcement: Every module should be kept under 200 lines unless split into submodules for clarity.
  • Layered responsibilities: Define clear responsibilities for cli, sdk, core, and tools to reduce cross-cutting concerns.
  • Naming and governance: Enforce consistent naming, RFC-compliant module schemas, and documentation of design decisions to aid onboarding.
  • Use Case: When planning a major refactor, apply these guidelines to decompose the project into smaller, coherent modules with explicit interfaces.

Quick Start

Start by auditing modules for boundaries, then codify layer responsibilities and naming conventions in the repo docs. Use this guide during planning and reviews to keep Sage architecture coherent.

Frequently Asked Questions about sage-architecture

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

FAQPage Schema
How do I enforce module boundaries in large projects to improve maintainability?

To enforce module boundaries for maintainability, keep every module under 200 lines and split larger ones into submodules. Define explicit interfaces and layered responsibilities to reduce cross-cutting concerns across cli, sdk, core, and tools components.

What is the best way to plan a major refactor for a fragmented project structure?

The best way to plan a refactor for a fragmented structure is applying architectural guidelines to decompose the project into smaller, coherent modules. Document module boundaries and naming conventions to ensure consistent governance during the restructuring process.

How do I define layered responsibilities for cli, sdk, core, and tools components?

Defining layered responsibilities involves assigning clear, specific duties to cli, sdk, core, and tools components to reduce cross-cutting concerns. Document these layer responsibilities and enforce them through regular code reviews and tooling checks.

Why does project structure chaos happen and when do I need modular design guidelines?

Project structure chaos happens when large projects lack cohesive blueprints, leading to fragmentation. You need modular design guidelines when scaling collaboration across teams, ensuring consistent naming, boundaries, and RFC-compliant module schemas for onboarding.

Can I use these architecture guidelines for both new planning and existing project governance?

Yes, you can use these architecture guidelines for both new planning and existing project governance. They apply to planning, refactoring, and governance tasks by codifying layer responsibilities and maintaining boundaries through code reviews and tooling.

What are the limitations of relying solely on naming conventions for code organization?

Relying solely on naming conventions limits code organization because it does not enforce structural boundaries. You must also document module schemas, define layered responsibilities, and use tooling to maintain governance across cli, sdk, core, and tools.