Core Concepts

Golden Path is built around the idea of "paved roads" — well-defined, architect-approved paths that make it easy for developers to do the right thing by default.

The Paved Roads Philosophy

In large organizations, software architects define best practices, patterns, and conventions — but enforcing them across teams is hard. Developers often reinvent the wheel or deviate from standards because there's no easy way to apply architectural decisions consistently.

Golden Path solves this by encoding architectural knowledge into skills and architecture packages that AI assistants can execute. Standalone skills provide universal capabilities like requirements analysis and architecture reviews, while architecture packages bundle the full set of patterns and skills needed for a specific architecture style. Architects define the golden path once, and every developer on the team can generate code that follows it — automatically, consistently, and at scale.

Architecture Packages

An architecture package defines a complete software architecture style for a specific tech stack. Each package includes a manifest describing its layers, patterns, and conventions, along with a set of skills that implement specific tasks.

Golden Path comes with a set of example packages for .NET that demonstrate how architecture packages work in practice:

• Clean Architecture — Domain-centric design with strict dependency rules.
• Modular Monolith — Independent modules within a single deployable unit.
• Microservices — Independently deployable services communicating via events.

These examples are fully functional and ready to use, but you can also create your own packages for any tech stack. Point plan_architecture at an existing reference repo, and the AI extracts the structural patterns into a reusable package. Discover community-created packages in the Marketplace.

Skills

A skill is a reusable, multi-step instruction set with YAML frontmatter and step-by-step phases. Skills are stored in the database and become MCP tools automatically.

Golden Path supports two types of skills:

• Standalone skills — Available regardless of which architecture is selected. These handle cross-cutting concerns like analyzing requirements, reviewing architecture decisions, or planning migrations.
• Architecture skills — Bundled with an architecture package and available after selecting it. These implement architecture-specific tasks like creating a solution, adding a service, or implementing a feature following the package's patterns.

name: add-service
description: Adds a new microservice with all required layers.
args:
  - name: service_name
    description: Name of the new service (PascalCase)
    required: true

Phases

Each skill is organized into phases that the AI executes sequentially:

1. Preparation — Validate prerequisites
2. Project Creation — Scaffold projects and references
3. Implementation — Write source files from templates
4. Registration — Wire up dependency injection
5. Verification — Build and run tests

Templates

Templates are source code files with variable placeholders that get replaced during processing. They are referenced in phases using template references that specify the source template and target output path.

Variables

Variables come from two sources: skill arguments (user-provided values like ServiceName) and architecture configuration (layer names like DomainLayer, ApplicationLayer).

Conditionals

Templates support conditional blocks using comment-based if/endif markers. Blocks are included or excluded based on configuration flags like typed-id, guid, or endpoint style.

Marketplace

The Marketplace is a community-driven discovery layer. Users can publish their architectures and skills as public, and others can:

• Star — bookmark for read-only access (appears in your sidebar's ★ Starred section, available via MCP)
• Fork — create an independent copy with full edit rights (appears in your Owned section)

The Flow

Standalone skills are available immediately — use them anytime for requirements analysis, architecture reviews, or migration planning. For architecture-specific work, the flow is:

1. Discover — Browse the Marketplace or use standalone skills to analyze your requirements
2. Select — Activate an architecture package (your own, starred, or shared), unlocking its skills
3. Execute — Call architecture skills (as MCP tools) to create solutions and implement features
4. Iterate — Each skill guides the AI through structured phases with templates