derive-design-patterns

Derive a design pattern catalog from architecture and NFR specifications.

3|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/kapilvirenahuja/garura --skill derive-design-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: derive-design-patterns
Source: https://github.com/kapilvirenahuja/garura/tree/main/core/components/skills/derive-design-patterns
Command: npx skills add https://github.com/kapilvirenahuja/garura --skill derive-design-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns logical and physical architecture decisions plus NFR drivers into a concrete, layer-by-layer design pattern catalog so teams can implement the product deterministically and consistently.

Core Features & Use Cases

  • Pattern catalog derivation: Converts logical architecture, physical runtime tiers, and NFR triggers into a structured design-patterns.yaml artifact.
  • Tiered coverage enforcement: Produces system-level, layer-level (when a backend exists), and component-level entries for every declared runtime tier to avoid gaps.
  • Forward-reference resolution: Satisfies NFR entries tagged as forward_ref_pending_design_patterns by emitting the required pattern(s).
  • Decision traceability: Writes a decision manifest that records selection rationale, grounding source, alternatives considered, and forward-reference resolution.

Quick Start

Use the tech-architect workflow to run derive-design-patterns and generate design-patterns.yaml and the associated decision manifest for your product architecture.

Frequently Asked Questions about derive-design-patterns

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

FAQPage Schema
How do I derive a design pattern catalog from architecture and NFRs?

Deriving a design pattern catalog from architecture and NFRs involves converting logical architecture, physical runtime tiers, and NFR triggers into a structured design-patterns.yaml artifact with tiered coverage enforcement.

How does forward-reference resolution work for NFRs in design pattern selection?

Forward-reference resolution for NFRs works by satisfying entries tagged as forward_ref_pending_design_patterns, automatically emitting the required system-level, layer-level, or component-level patterns to resolve pending dependencies.

What is the best way to enforce tiered coverage for design patterns across runtime tiers?

Enforcing tiered coverage for design patterns requires producing system-level, layer-level, and component-level entries for every declared runtime tier, ensuring no architectural gaps exist when converting NFR drivers into pattern selections.

Can I trace design pattern decisions back to their architecture and NFR sources?

Tracing design pattern decisions back to architecture and NFR sources is done by emitting a decision manifest that records selection rationale, grounding source, alternatives considered, and forward-reference resolution status.

Does intent-driven development require a decision manifest for pattern selection?

Intent-driven development requires a decision manifest for pattern selection to maintain deterministic implementation, recording the grounding source, alternatives considered, and resolution status for every architecture and NFR driver.

When do I need to generate layer-level design patterns for my architecture?

Generating layer-level design patterns is needed when a backend exists in your physical runtime tiers, ensuring every declared tier receives system-level, layer-level, and component-level pattern coverage during the architecture stage.