skills.rest
peppone-choi
peppone-choiCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

verify-architecture

Validate backend code adherence to TDD, DDD, Clean Architecture, and Repository patterns.

Updated May 29, 2026
Search Tags:#code quality#tdd#architecture#ddd#clean architecture#repository pattern
One-click install
npx skills add https://github.com/peppone-choi/opensamguk --skill verify-architecture
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: verify-architecture
Source: https://github.com/peppone-choi/opensamguk/tree/main/.claude/skills/verify-architecture
Command: npx skills add https://github.com/peppone-choi/opensamguk --skill verify-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill automates the verification of backend code against established architectural principles like TDD, DDD, Clean Architecture, and the Repository Pattern, preventing architectural drift and ensuring code quality.

Core Features & Use Cases

  • Automated Code Audits: Checks for correct layer separation (Controller, Service, Repository), dependency direction, domain model independence, and proper repository pattern usage.
  • TDD Compliance: Verifies the existence and structure of tests for each layer, promoting test-driven development.
  • Use Case: Before merging a new feature, run this Skill to confirm that the newly added backend code follows the project's architectural guidelines, catching potential violations early in the development cycle.

Quick Start

Run the verify-architecture skill to check the backend code's adherence to architectural patterns.

Frequently Asked Questions about verify-architecture

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

FAQPage Schema
How do I check if my backend code follows Clean Architecture and DDD principles?▼

To verify backend code follows Clean Architecture and DDD, analyze package structure, dependency direction, and domain model isolation. This ensures strict separation of concerns and framework independence in domain entities.

What is the best way to prevent architectural drift in a repository pattern implementation?▼

Preventing architectural drift in repository pattern implementations requires automated code audits validating controller, service, and repository responsibilities. Catching structural violations early in development maintains code quality.

How do I verify TDD compliance and test coverage across different architectural layers?▼

To verify TDD compliance and test coverage across architectural layers, check the existence and structure of tests for each specific layer. This promotes test-driven development by validating controllers, services, and repositories have corresponding tests.

Can I use automated code audits to ensure domain entities remain framework independent?▼

Yes, automated code audits can ensure domain entities remain framework independent by analyzing dependency directions and domain model isolation. This validates that core domain logic stays strictly separated from external frameworks.

Does validating dependency direction help catch Clean Architecture violations before merging?▼

Validating dependency direction does help catch Clean Architecture violations before merging by ensuring dependencies point inward toward domain models. Running this verification on new backend code confirms adherence to project architectural guidelines early.

Related Skills

Explore More Software Engineering Skills→
lasswelltlasswellt
1

codebase-map

Analyze a codebase across technology, architecture, quality, and concerns to generate CODEBASE-MAP.md.

Community
Advanced
krzemienskikrzemienski
2

architecture-evolution-tracking

Detect architectural drift from ADRs and compute alignment scores.

Community
Advanced
haidonglethqbhaidonglethqb

ck:test

Automate unit, integration, e2e, and UI tests with coverage analysis.

Community
Advanced
yun520-1yun520-1
38

code-analyzer

Analyze codebases for architectural patterns, code quality, and DDD elements.

Community
Advanced