architect-first

Guide architectural decisions with complete design documentation before implementation.

1|Updated May 15, 2026
One-click install
npx skills add https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech --skill architect-first-hyagoviana
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architect-first
Source: https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech/tree/main/meu-projeto/.claude/skills/architect-first
Command: npx skills add https://github.com/hyagoviana/Sistema_Hyago_Viana_Adabtech --skill architect-first-hyagoviana

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

architect-first ensures new features and refactors start from complete architecture and documentation, reducing rework, hidden coupling, and capability loss by enforcing clear quality gates before implementation.

Core Features & Use Cases

  • Architecture before code: Requires design and documentation (diagrams, data flows, component interactions, and configuration schema) to be completed before any implementation.
  • Capability preservation: Prevents regression by explicitly validating that all prior capabilities/granularity are maintained via a baseline comparison.
  • Zero coupling validation: Detects cross-module hard dependencies using a coupling checker and enforces independent expansion packs/config-driven integration.
  • Multi-agent validation: Forces structural decisions to be reviewed and approved from PO/Architect/User perspectives with recorded rationale.
  • Tests as an escape hatch: Allows pragmatic coding only when backed by a defined test plan and supporting logs/observability.

Quick Start

Use the architect-first skill when planning a structural change by documenting the current state, drafting complete design documentation with A/B/C options, and running the coupling and pre-implementation validation steps before writing code.

Frequently Asked Questions about architect-first

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

FAQPage Schema
How do I prevent capability loss and hidden coupling when refactoring software architecture?

To prevent capability loss and hidden coupling during refactoring, enforce architecture-first documentation and zero-coupling checks before implementation. This approach requires baseline comparisons and multi-agent validation to ensure structural changes preserve existing capabilities.

What is the best way to document architectural design before writing new feature code?

The best way to document architectural design is by drafting complete documentation including diagrams, data flows, component interactions, and configuration schemas with A/B/C options. This must be completed and validated before any feature implementation begins.

When do I need multi-agent validation for structural changes in my project?

You need multi-agent validation for structural changes when making architectural decisions that impact capabilities. This forces review and approval from PO, Architect, and User perspectives with recorded rationale to prevent unauthorized structural modifications.

Does this approach work with externalizing hardcoded configuration values to YAML?

Yes, this approach works with externalizing configuration to YAML by enforcing stop rules against hardcoded mutable configuration values. Configuration schemas must be documented during the architecture phase and validated with tests and scripts before implementation.

Can I write pragmatic code without full architecture documentation if I have tests?

Yes, you can write pragmatic code without full architecture documentation when backed by a defined test plan and supporting logs or observability. Tests serve as an escape hatch, but structural changes still require PO, Architect, or User validation.

How do I check for zero coupling between modules before starting a refactor?

To check for zero coupling between modules, use a coupling checker to detect cross-module hard dependencies during the pre-implementation validation phase. This enforces independent expansion packs and config-driven integration before any code is written.