architecture-foundation

Identify architectural concerns and write dependency DAGs into capabilities.yaml.

Updated Jun 4, 2026
One-click install
npx skills add https://github.com/Kohlex/autopilot-plugin --skill architecture-foundation-kohlex
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-foundation
Source: https://github.com/Kohlex/autopilot-plugin/tree/main/skills/architecture-foundation
Command: npx skills add https://github.com/Kohlex/autopilot-plugin --skill architecture-foundation-kohlex

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The architecture-foundation skill automates turning a Foundation into a structured, auditable architecture by identifying architectural concerns and generating per-concern binding contracts plus a dependency DAG.

Core Features & Use Cases

  • Deterministic concern identification: partitions Foundation capabilities into up to five architectural concerns based on arch_surface (or ADR-derived signals) and folds extras deterministically when needed.
  • Per-concern contract generation: wraps the appropriate GSD skill for each concern to produce bound, pinned contracts that describe dependencies and source capabilities.
  • DAG backwrite and traceability: expands contract dependencies into a capability-level DAG and writes it back into capabilities.yaml depends_on, preserving audit trails.
  • Validation and safety: ensures acyclic graphs and deterministic output suitable for downstream SPEC and planning stages.

Quick Start

Run the architecture-foundation skill after the Foundation phase to generate per-concern contracts and update capabilities.yaml.

Frequently Asked Questions about architecture-foundation

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

FAQPage Schema
How do I automate architecture binding contracts from Foundation capabilities?

You can automate architecture binding by identifying concerns from Foundation capabilities and emitting per-concern binding contracts. The process wraps chosen GSD skills non-interactively to generate bound contracts and write a dependency DAG directly into capabilities.yaml.

What is the best way to generate a dependency DAG from capabilities.yaml without creating extra files?

Generating a dependency DAG from capabilities.yaml is best handled by expanding contract dependencies and writing them back into the existing depends_on field. This approach avoids creating a second DAG file while preserving acyclic graph validation and audit trails.

How do architectural concerns get identified from Foundation capabilities and ADR signals?

Architectural concerns are identified by partitioning Foundation capabilities into up to five concerns based on arch_surface or ADR-derived signals. When extra capabilities exist, they are folded deterministically into the existing concern partitions.

Can I use architecture-foundation to write traceability data linking contracts to original capabilities?

Yes, you can use this approach to write traceability data linking generated contracts back to original capabilities. It ensures deterministic output suitable for downstream SPEC and planning stages while preserving full audit trails across the dependency DAG.

When should I run architecture binding after user stories in my workflow?

Architecture binding should run immediately after the user stories phase and before downstream SPEC and planning stages. Operating at this point ensures the Foundation capabilities include arch_surface and ADR signals needed to fan out and generate accurate per-concern contracts.

Why does my capabilities.yaml DAG validation fail when adding contract dependencies?

DAG validation fails when expanded contract dependencies create cyclic graphs within capabilities.yaml. Ensure the architecture binding process maintains acyclic graphs by correctly mapping per-concern contract dependencies into the depends_on field without circular references.