Architecture Patterns
Consolidated architecture validation and enforcement patterns covering clean architecture, backend layer separation, project structure conventions, and test standards. Each category has individual rule files in rules/ loaded on-demand. House scars and dated decisions rescued from retired reference tutorials live in references/ork-delta.md; the tutorials themselves are upstream's job (see "Upstream coverage" below).
Quick Reference
| Category |
Rules |
Impact |
When to Use |
| Clean Architecture |
3 |
HIGH |
SOLID principles, hexagonal architecture, ports & adapters, DDD |
| Project Structure |
2 |
HIGH |
Folder conventions, nesting depth, import direction, barrel files |
| Backend Layers |
3 |
HIGH |
Router/service/repository separation, DI, file naming |
| Test Standards |
3 |
MEDIUM |
AAA pattern, naming conventions, coverage thresholds |
| Right-Sizing |
2 |
HIGH |
Architecture tier selection, over-engineering prevention, context-aware enforcement |
Total: 13 rules across 5 categories
Quick Start
# Clean Architecture: Dependency Inversion via Protocol
class IUserRepository(Protocol):
async def get_by_id(self, id: str) -> User | None: ...
class UserService:
def __init__(self, repo: IUserRepository):
self._repo = repo # Depends on abstraction, not concretion
# FastAPI DI chain: DB -> Repository -> Service
def get_user_service(db: AsyncSession = Depends(get_db)) -> UserService:
return UserService(PostgresUserRepository(db))
# Project Structure: Unidirectional Import Architecture
shared/lib -> components -> features -> app
(lowest) (highest)
# Backend Layers: Strict Separation
Routers (HTTP) -> Services (Business Logic) -> Repositories (Data Access)
Clean Architecture
SOLID principles, hexagonal architecture, ports and adapters, and DDD tactical patterns for maintainable backends.
| Rule |
File |
Key Pattern |
| Hexagonal Architecture |
rules/clean-hexagonal.md |
Driving/driven ports, adapter implementations, layer structure |
| SOLID & Dependency Rule |
rules/clean-dependency-rule.md |
Protocol-based interfaces, dependency inversion, FastAPI DI |
| DDD Tactical Patterns |
rules/clean-ports-adapters.md |
Entities, value objects, aggregate roots, domain events |
Design review checklist: checklists/solid-checklist.md. Domain entity scaffold: scripts/domain-entity-template.py.
Key Decisions
| Decision |
Recommendation |
| Protocol vs ABC |
Protocol (structural typing) |
| Dataclass vs Pydantic |
Dataclass for domain, Pydantic for API |
| Repository granularity |
One per aggregate root |
| Transaction boundary |
Service layer, not repository |
| Event publishing |
Collect in aggregate, publish after commit |
Project Structure
Feature-based organization, max nesting depth, unidirectional imports, and barrel file prevention.
| Rule |
File |
Key Pattern |
| Folder Structure & Nesting |
rules/structure-folders.md |
React/Next.js and FastAPI layouts, 4-level max nesting, barrel file rules |
| Import Direction & Location |
references/structure-import-direction.md |
Unidirectional imports, cross-feature prevention, component/hook placement |
Blocking Rules
| Rule |
Check |
| Max Nesting |
Max 4 levels from src/ or app/ |
| No Barrel Files |
No index.ts re-exports (tree-shaking issues) |
| Component Location |
React components in components/ or features/ only |
| Hook Location |
Custom hooks in hooks/ or features/*/hooks/ only |
| Import Direction |
Unidirectional: shared -> components -> features -> app |
Backend Layers
FastAPI Clean Architecture with router/service/repository layer separation and blocking validation.
| Rule |
File |
Key Pattern |
| Layer Separation |
rules/backend-layers.md |
Router/service/repository boundaries, forbidden patterns, async rules |
| Dependency Injection |
rules/backend-di.md |
Depends() chains, blocked DI patterns, violation detection |
| File Naming & Exceptions |
rules/backend-repository.md |
Naming conventions, async rules, domain exceptions |
House scars for this category (exception-to-HTTP status map, import-level violation greps, DI override teardown): references/ork-delta.md.
Layer Boundaries
| Layer |
Responsibility |
Forbidden |
| Routers |
HTTP concerns, request parsing, auth checks |
Database operations, business logic |
| Services |
Business logic, validation, orchestration |
HTTPException, Request objects |
| Repositories |
Data access, queries, persistence |
HTTP concerns, business logic |
Test Standards
Testing best practices with AAA pattern, naming conventions, isolation, and coverage thresholds.
| Rule |
File |
Key Pattern |
| AAA Pattern & Isolation |
rules/testing-aaa.md |
Arrange-Act-Assert, test isolation, parameterized tests |
| Naming Conventions |
references/testing-naming-conventions.md |
Descriptive behavior-focused names for Python and TypeScript |
| Coverage & Location |
rules/testing-coverage.md |
Coverage thresholds, fixture scopes, and (per references/ork-delta.md) the no-co-location rule |
Coverage Requirements
| Area |
Minimum |
Target |
| Overall |
80% |
90% |
| Business Logic |
90% |
100% |
| Critical Paths |
95% |
100% |
| New Code |
100% |
100% |
Right-Sizing
Context-aware backend architecture enforcement. Rules adjust strictness based on project tier detected by scope-appropriate-architecture.
Enforcement procedure:
- Read project tier from
scope-appropriate-architecture context (set during brainstorm/implement Step 0)
- If no tier set, auto-detect using signals in
Read("rules/right-sizing-tiers.md")
- Apply tier-based enforcement matrix — skip rules marked OFF for detected tier
- Security rules are tier-independent — always enforce SQL parameterization, input validation, auth checks
| Rule |
File |
Key Pattern |
| Architecture Sizing Tiers |
rules/right-sizing-tiers.md |
Interview/MVP/production/enterprise sizing matrix, LOC estimates, detection signals |
| Right-Sizing Decision Guide |
rules/right-sizing-decision.md |
ORM, auth, error handling, testing recommendations per tier, over-engineering tax |
Tier-Based Rule Enforcement
| Rule |
Interview |
MVP |
Production |
Enterprise |
| Layer separation |
OFF |
WARN |
BLOCK |
BLOCK |
| Repository pattern |
OFF |
OFF |
WARN |
BLOCK |
| Domain exceptions |
OFF |
OFF |
BLOCK |
BLOCK |
| Dependency injection |
OFF |
WARN |
BLOCK |
BLOCK |
| OpenAPI documentation |
OFF |
OFF |
WARN |
BLOCK |
Manual override: User can set tier explicitly to bypass auto-detection (e.g., "I want enterprise patterns for this take-home to demonstrate skill").
Decision Flowchart
Is this a take-home or hackathon?
YES --> Flat architecture. Single file or 3-5 files. Done.
NO -->
Is this a prototype or MVP with < 3 months runway?
YES --> Simple layered. Routes + services + models. No abstractions.
NO -->
Do you have > 5 engineers or complex domain rules?
YES --> Clean architecture with ports/adapters.
NO --> Layered architecture. Add abstractions only when pain appears.
When NOT to Use
Not every project needs architecture patterns. Match complexity to project tier:
| Pattern |
Interview |
Hackathon |
MVP |
Growth |
Enterprise |
Simpler Alternative |
| Repository pattern |
OVERKILL (~200 LOC) |
OVERKILL |
BORDERLINE |
APPROPRIATE |
REQUIRED |
Direct ORM calls in service (~20 LOC) |
| DI containers |
OVERKILL (~150 LOC) |
OVERKILL |
LIGHT ONLY |
APPROPRIATE |
REQUIRED |
Constructor params or module-level singletons (~10 LOC) |
| Event-driven arch |
OVERKILL (~300 LOC) |
OVERKILL |
OVERKILL |
SELECTIVE |
APPROPRIATE |
Direct function calls between services (~30 LOC) |
| Hexagonal architecture |
OVERKILL (~400 LOC) |
OVERKILL |
OVERKILL |
BORDERLINE |
APPROPRIATE |
Flat modules with imports (~50 LOC) |
| Strict layer separation |
OVERKILL (~250 LOC) |
OVERKILL |
WARN |
BLOCK |
BLOCK |
Routes + models in same file (~40 LOC) |
| Domain exceptions |
OVERKILL (~100 LOC) |
OVERKILL |
OVERKILL |
BLOCK |
BLOCK |
Built-in ValueError/HTTPException (~5 LOC) |
Rule of thumb: If a pattern shows OVERKILL for the detected tier, do NOT use it. Use the simpler alternative. A take-home with hexagonal architecture signals over-engineering, not skill.
Anti-Patterns (FORBIDDEN)
# CLEAN ARCHITECTURE
# NEVER import infrastructure in domain layer
from app.infrastructure.database import engine # In domain layer!
# NEVER leak ORM models to API layer
@router.get("/users/{id}")
async def get_user(id: str, db: Session) -> UserModel: # Returns ORM model!
# NEVER have domain depend on framework
from fastapi import HTTPException
class UserService:
def get(self, id: str):
raise HTTPException(404) # Framework in domain!
# PROJECT STRUCTURE
# NEVER create files deeper than 4 levels from src/
# NEVER create barrel files (index.ts re-exports)
# NEVER import from higher layers (features importing from app)
# NEVER import across features (use shared/ for common code)
# BACKEND LAYERS
# NEVER use database operations in routers
# NEVER raise HTTPException in services
# NEVER instantiate services without Depends()
# TEST STANDARDS
# NEVER mix test files with source code
# NEVER use non-descriptive test names (test1, test, works)
# NEVER share mutable state between tests without reset
Upstream coverage (do not restate)
Long-form tutorials on these topics were removed from this skill (2026-07-31 wrap-plus-delta campaign). Read them at the first-party source; only floors, scars, and house decisions belong here (see references/ork-delta.md).
| Topic |
First-party source |
| Hexagonal architecture, ports and adapters walkthrough |
Alistair Cockburn, https://alistair.cockburn.us/hexagonal-architecture/ and Architecture Patterns with Python, https://www.cosmicpython.com/ |
| SOLID principles tutorial (Protocol-based) |
Architecture Patterns with Python, https://www.cosmicpython.com/ and Python Protocol spec, https://typing.python.org/en/latest/spec/protocol.html |
| DDD tactical patterns (entities, value objects, aggregates, domain events) |
Architecture Patterns with Python, https://www.cosmicpython.com/ |
| FastAPI dependency injection, auth dependencies, DI test overrides |
FastAPI docs (context7: /tiangolo/fastapi), https://fastapi.tiangolo.com/tutorial/dependencies/ and skill ork:python-backend |
| Router/service/repository layer walkthrough |
FastAPI bigger applications, https://fastapi.tiangolo.com/tutorial/bigger-applications/ and skill ork:python-backend |
| Full FastAPI clean-architecture example app |
FastAPI full-stack template, https://github.com/fastapi/full-stack-fastapi-template |
| Next.js folder layout and structure-violation catalog |
Next.js project structure docs, https://nextjs.org/docs/app/getting-started/project-structure (skill vercel:nextjs) |
| AAA pattern, isolation, parameterized tests, fixture scoping, coverage config |
Skill ork:testing-unit; pytest docs, https://docs.pytest.org/en/stable/ and Vitest coverage, https://vitest.dev/config/#coverage |
Related Skills
ork:scope-appropriate-architecture - Project tier detection that drives right-sizing enforcement
ork:quality-gates - YAGNI gate uses tier context to validate complexity
ork:distributed-systems - Distributed locking, resilience, idempotency patterns
ork:api-design - REST API design, versioning, error handling
ork:testing-unit - Unit testing: AAA pattern, fixtures, mocking, factories
ork:testing-e2e - E2E testing: Playwright, page objects, visual regression
ork:testing-integration - Integration testing: API endpoints, database, contracts
ork:python-backend - FastAPI, SQLAlchemy, asyncio patterns
ork:database-patterns - Schema design, query optimization, migrations
1---
2name: architecture-patterns
3license: MIT
4compatibility: "Claude Code 2.1.251+."
5description: Architecture validation and patterns for clean architecture, backend structure enforcement, project structure validation, test standards, and context-aware sizing. Use when designing system boundaries, enforcing layered architecture, validating project structure, defining test standards, or choosing the right architecture tier for project scope.
6tags: [architecture, clean-architecture, validation, structure, enforcement, testing-standards, right-sizing, over-engineering, context-aware]
7skills: [scope-appropriate-architecture]
8context: fork
9agent: backend-system-architect
10version: 2.1.0
11author: OrchestKit
12user-invocable: false
13disable-model-invocation: false
14complexity: high
15persuasion-type: reference
16effort: high
17metadata:
18 source: https://skillmd.com/skills/yonatangross/architecture-patterns
19 category: document-asset-creation
20allowed-tools:
21 - Read
22 - Glob
23 - Grep
24 - WebFetch
25 - WebSearch
26paths: ["src/**", "package.json", "tsconfig.json"]
27---
28
29<!-- directive-density: intentional (teaches anti-patterns; NEVER markers describe real layering violations, not aspirational guidance) -->
30
31# Architecture Patterns
32
33Consolidated architecture validation and enforcement patterns covering clean architecture, backend layer separation, project structure conventions, and test standards. Each category has individual rule files in `rules/` loaded on-demand. House scars and dated decisions rescued from retired reference tutorials live in `references/ork-delta.md`; the tutorials themselves are upstream's job (see "Upstream coverage" below).
34
35## Quick Reference
36
37| Category | Rules | Impact | When to Use |
38|----------|-------|--------|-------------|
39| [Clean Architecture](#clean-architecture) | 3 | HIGH | SOLID principles, hexagonal architecture, ports & adapters, DDD |
40| [Project Structure](#project-structure) | 2 | HIGH | Folder conventions, nesting depth, import direction, barrel files |
41| [Backend Layers](#backend-layers) | 3 | HIGH | Router/service/repository separation, DI, file naming |
42| [Test Standards](#test-standards) | 3 | MEDIUM | AAA pattern, naming conventions, coverage thresholds |
43| [Right-Sizing](#right-sizing) | 2 | HIGH | Architecture tier selection, over-engineering prevention, context-aware enforcement |
44
45**Total: 13 rules across 5 categories**
46
47## Quick Start
48
49```python
50# Clean Architecture: Dependency Inversion via Protocol
51class IUserRepository(Protocol):
52 async def get_by_id(self, id: str) -> User | None: ...
53
54class UserService:
55 def __init__(self, repo: IUserRepository):
56 self._repo = repo # Depends on abstraction, not concretion
57
58# FastAPI DI chain: DB -> Repository -> Service
59def get_user_service(db: AsyncSession = Depends(get_db)) -> UserService:
60 return UserService(PostgresUserRepository(db))
61```
62
63```
64# Project Structure: Unidirectional Import Architecture
65shared/lib -> components -> features -> app
66(lowest) (highest)
67
68# Backend Layers: Strict Separation
69Routers (HTTP) -> Services (Business Logic) -> Repositories (Data Access)
70```
71
72## Clean Architecture
73
74SOLID principles, hexagonal architecture, ports and adapters, and DDD tactical patterns for maintainable backends.
75
76| Rule | File | Key Pattern |
77|------|------|-------------|
78| Hexagonal Architecture | `rules/clean-hexagonal.md` | Driving/driven ports, adapter implementations, layer structure |
79| SOLID & Dependency Rule | `rules/clean-dependency-rule.md` | Protocol-based interfaces, dependency inversion, FastAPI DI |
80| DDD Tactical Patterns | `rules/clean-ports-adapters.md` | Entities, value objects, aggregate roots, domain events |
81
82Design review checklist: `checklists/solid-checklist.md`. Domain entity scaffold: `scripts/domain-entity-template.py`.
83
84### Key Decisions
85
86| Decision | Recommendation |
87|----------|----------------|
88| Protocol vs ABC | Protocol (structural typing) |
89| Dataclass vs Pydantic | Dataclass for domain, Pydantic for API |
90| Repository granularity | One per aggregate root |
91| Transaction boundary | Service layer, not repository |
92| Event publishing | Collect in aggregate, publish after commit |
93
94## Project Structure
95
96Feature-based organization, max nesting depth, unidirectional imports, and barrel file prevention.
97
98| Rule | File | Key Pattern |
99|------|------|-------------|
100| Folder Structure & Nesting | `rules/structure-folders.md` | React/Next.js and FastAPI layouts, 4-level max nesting, barrel file rules |
101| Import Direction & Location | `references/structure-import-direction.md` | Unidirectional imports, cross-feature prevention, component/hook placement |
102
103### Blocking Rules
104
105| Rule | Check |
106|------|-------|
107| Max Nesting | Max 4 levels from src/ or app/ |
108| No Barrel Files | No index.ts re-exports (tree-shaking issues) |
109| Component Location | React components in components/ or features/ only |
110| Hook Location | Custom hooks in hooks/ or features/*/hooks/ only |
111| Import Direction | Unidirectional: shared -> components -> features -> app |
112
113## Backend Layers
114
115FastAPI Clean Architecture with router/service/repository layer separation and blocking validation.
116
117| Rule | File | Key Pattern |
118|------|------|-------------|
119| Layer Separation | `rules/backend-layers.md` | Router/service/repository boundaries, forbidden patterns, async rules |
120| Dependency Injection | `rules/backend-di.md` | Depends() chains, blocked DI patterns, violation detection |
121| File Naming & Exceptions | `rules/backend-repository.md` | Naming conventions, async rules, domain exceptions |
122
123House scars for this category (exception-to-HTTP status map, import-level violation greps, DI override teardown): `references/ork-delta.md`.
124
125### Layer Boundaries
126
127| Layer | Responsibility | Forbidden |
128|-------|---------------|-----------|
129| Routers | HTTP concerns, request parsing, auth checks | Database operations, business logic |
130| Services | Business logic, validation, orchestration | HTTPException, Request objects |
131| Repositories | Data access, queries, persistence | HTTP concerns, business logic |
132
133## Test Standards
134
135Testing best practices with AAA pattern, naming conventions, isolation, and coverage thresholds.
136
137| Rule | File | Key Pattern |
138|------|------|-------------|
139| AAA Pattern & Isolation | `rules/testing-aaa.md` | Arrange-Act-Assert, test isolation, parameterized tests |
140| Naming Conventions | `references/testing-naming-conventions.md` | Descriptive behavior-focused names for Python and TypeScript |
141| Coverage & Location | `rules/testing-coverage.md` | Coverage thresholds, fixture scopes, and (per `references/ork-delta.md`) the no-co-location rule |
142
143### Coverage Requirements
144
145| Area | Minimum | Target |
146|------|---------|--------|
147| Overall | 80% | 90% |
148| Business Logic | 90% | 100% |
149| Critical Paths | 95% | 100% |
150| New Code | 100% | 100% |
151
152## Right-Sizing
153
154Context-aware backend architecture enforcement. Rules adjust strictness based on project tier detected by `scope-appropriate-architecture`.
155
156**Enforcement procedure:**
1571. Read project tier from `scope-appropriate-architecture` context (set during brainstorm/implement Step 0)
1582. If no tier set, auto-detect using signals in `Read("rules/right-sizing-tiers.md")`
1593. Apply tier-based enforcement matrix — skip rules marked OFF for detected tier
1604. **Security rules are tier-independent** — always enforce SQL parameterization, input validation, auth checks
161
162| Rule | File | Key Pattern |
163|------|------|-------------|
164| Architecture Sizing Tiers | `rules/right-sizing-tiers.md` | Interview/MVP/production/enterprise sizing matrix, LOC estimates, detection signals |
165| Right-Sizing Decision Guide | `rules/right-sizing-decision.md` | ORM, auth, error handling, testing recommendations per tier, over-engineering tax |
166
167### Tier-Based Rule Enforcement
168
169| Rule | Interview | MVP | Production | Enterprise |
170|------|-----------|-----|------------|------------|
171| Layer separation | OFF | WARN | BLOCK | BLOCK |
172| Repository pattern | OFF | OFF | WARN | BLOCK |
173| Domain exceptions | OFF | OFF | BLOCK | BLOCK |
174| Dependency injection | OFF | WARN | BLOCK | BLOCK |
175| OpenAPI documentation | OFF | OFF | WARN | BLOCK |
176
177**Manual override:** User can set tier explicitly to bypass auto-detection (e.g., "I want enterprise patterns for this take-home to demonstrate skill").
178
179### Decision Flowchart
180
181```
182Is this a take-home or hackathon?
183 YES --> Flat architecture. Single file or 3-5 files. Done.
184 NO -->
185
186Is this a prototype or MVP with < 3 months runway?
187 YES --> Simple layered. Routes + services + models. No abstractions.
188 NO -->
189
190Do you have > 5 engineers or complex domain rules?
191 YES --> Clean architecture with ports/adapters.
192 NO --> Layered architecture. Add abstractions only when pain appears.
193```
194
195## When NOT to Use
196
197Not every project needs architecture patterns. Match complexity to project tier:
198
199| Pattern | Interview | Hackathon | MVP | Growth | Enterprise | Simpler Alternative |
200|---------|-----------|-----------|-----|--------|------------|---------------------|
201| Repository pattern | OVERKILL (~200 LOC) | OVERKILL | BORDERLINE | APPROPRIATE | REQUIRED | Direct ORM calls in service (~20 LOC) |
202| DI containers | OVERKILL (~150 LOC) | OVERKILL | LIGHT ONLY | APPROPRIATE | REQUIRED | Constructor params or module-level singletons (~10 LOC) |
203| Event-driven arch | OVERKILL (~300 LOC) | OVERKILL | OVERKILL | SELECTIVE | APPROPRIATE | Direct function calls between services (~30 LOC) |
204| Hexagonal architecture | OVERKILL (~400 LOC) | OVERKILL | OVERKILL | BORDERLINE | APPROPRIATE | Flat modules with imports (~50 LOC) |
205| Strict layer separation | OVERKILL (~250 LOC) | OVERKILL | WARN | BLOCK | BLOCK | Routes + models in same file (~40 LOC) |
206| Domain exceptions | OVERKILL (~100 LOC) | OVERKILL | OVERKILL | BLOCK | BLOCK | Built-in ValueError/HTTPException (~5 LOC) |
207
208**Rule of thumb:** If a pattern shows OVERKILL for the detected tier, do NOT use it. Use the simpler alternative. A take-home with hexagonal architecture signals over-engineering, not skill.
209
210## Anti-Patterns (FORBIDDEN)
211
212```python
213# CLEAN ARCHITECTURE
214# NEVER import infrastructure in domain layer
215from app.infrastructure.database import engine # In domain layer!
216
217# NEVER leak ORM models to API layer
218@router.get("/users/{id}")
219async def get_user(id: str, db: Session) -> UserModel: # Returns ORM model!
220
221# NEVER have domain depend on framework
222from fastapi import HTTPException
223class UserService:
224 def get(self, id: str):
225 raise HTTPException(404) # Framework in domain!
226
227# PROJECT STRUCTURE
228# NEVER create files deeper than 4 levels from src/
229# NEVER create barrel files (index.ts re-exports)
230# NEVER import from higher layers (features importing from app)
231# NEVER import across features (use shared/ for common code)
232
233# BACKEND LAYERS
234# NEVER use database operations in routers
235# NEVER raise HTTPException in services
236# NEVER instantiate services without Depends()
237
238# TEST STANDARDS
239# NEVER mix test files with source code
240# NEVER use non-descriptive test names (test1, test, works)
241# NEVER share mutable state between tests without reset
242```
243
244## Upstream coverage (do not restate)
245
246Long-form tutorials on these topics were removed from this skill (2026-07-31 wrap-plus-delta campaign). Read them at the first-party source; only floors, scars, and house decisions belong here (see `references/ork-delta.md`).
247
248| Topic | First-party source |
249|-------|--------------------|
250| Hexagonal architecture, ports and adapters walkthrough | Alistair Cockburn, https://alistair.cockburn.us/hexagonal-architecture/ and Architecture Patterns with Python, https://www.cosmicpython.com/ |
251| SOLID principles tutorial (Protocol-based) | Architecture Patterns with Python, https://www.cosmicpython.com/ and Python Protocol spec, https://typing.python.org/en/latest/spec/protocol.html |
252| DDD tactical patterns (entities, value objects, aggregates, domain events) | Architecture Patterns with Python, https://www.cosmicpython.com/ |
253| FastAPI dependency injection, auth dependencies, DI test overrides | FastAPI docs (context7: /tiangolo/fastapi), https://fastapi.tiangolo.com/tutorial/dependencies/ and skill ork:python-backend |
254| Router/service/repository layer walkthrough | FastAPI bigger applications, https://fastapi.tiangolo.com/tutorial/bigger-applications/ and skill ork:python-backend |
255| Full FastAPI clean-architecture example app | FastAPI full-stack template, https://github.com/fastapi/full-stack-fastapi-template |
256| Next.js folder layout and structure-violation catalog | Next.js project structure docs, https://nextjs.org/docs/app/getting-started/project-structure (skill vercel:nextjs) |
257| AAA pattern, isolation, parameterized tests, fixture scoping, coverage config | Skill ork:testing-unit; pytest docs, https://docs.pytest.org/en/stable/ and Vitest coverage, https://vitest.dev/config/#coverage |
258
259## Related Skills
260
261- `ork:scope-appropriate-architecture` - Project tier detection that drives right-sizing enforcement
262- `ork:quality-gates` - YAGNI gate uses tier context to validate complexity
263- `ork:distributed-systems` - Distributed locking, resilience, idempotency patterns
264- `ork:api-design` - REST API design, versioning, error handling
265- `ork:testing-unit` - Unit testing: AAA pattern, fixtures, mocking, factories
266- `ork:testing-e2e` - E2E testing: Playwright, page objects, visual regression
267- `ork:testing-integration` - Integration testing: API endpoints, database, contracts
268- `ork:python-backend` - FastAPI, SQLAlchemy, asyncio patterns
269- `ork:database-patterns` - Schema design, query optimization, migrations