Standards Relationship Graph¶

Purpose¶

Maps relationships between standards to enable intelligent loading and comprehensive compliance.

Core Dependencies¶

Dependency Rules¶

→ requires → : Must load together
→ recommends → : Should load together
→ enhances → : Optional but beneficial
→ conflicts → : Cannot use together

Knowledge Management Dependencies¶

KM:* → complements → ALL standards (universal applicability)
KM:architecture → requires → CS:documentation
KM:ai-integration → requires → CLAUDE.md
KM:progressive-disclosure → enhances → ALL documentation
KM:cross-reference → requires → standards relationship mapping

Security Dependencies¶

SEC:auth → requires → CS:error-handling + CS:logging
SEC:api → requires → CS:api + TS:integration + CS:validation
SEC:encryption → requires → CS:security + LEG:privacy
SEC:container → requires → CN:docker + CN:kubernetes

Testing Dependencies¶

TS:unit → requires → CS:patterns + CS:error-handling
TS:integration → requires → CS:api + SEC:api
TS:performance → requires → OBS:metrics + CS:performance
TS:security → requires → SEC:* + CS:validation

Frontend Dependencies¶

FE:react → requires → CS:javascript + WD:components
FE:performance → requires → OBS:metrics + WD:optimization
FE:mobile → requires → FE:react-native + SEC:mobile
FE:pwa → requires → FE:performance + WD:offline

Data Dependencies¶

DE:pipelines → requires → CS:error-handling + TS:data + OBS:monitoring
DE:quality → requires → TS:validation + OBS:metrics
DE:streaming → requires → EVT:kafka + CS:async
DE:warehouse → requires → CS:sql + DE:modeling

MCP Dependencies¶

MCP:server → requires → CS:api + SEC:auth + CS:patterns
MCP:client → requires → MCP:server + CS:error-handling
MCP:tools → requires → MCP:server + CS:validation
MCP:resources → requires → MCP:server + CS:patterns
MCP:security → requires → SEC:auth + SEC:validation + LEG:privacy
MCP:* → recommends → EVT:patterns + TS:integration + KM:progressive-disclosure

Complementary Standards¶

When Using X, Also Consider Y¶

CS:api → consider → SEC:api + TS:integration + OBS:monitoring
CN:kubernetes → consider → OBS:* + SEC:container + COST:k8s
FE:* → consider → WD:* + SEO:technical + CS:performance
DE:* → consider → LEG:privacy + SEC:encryption + TS:data
PM:agile → consider → CS:architecture + TS:tdd + DOP:cicd
MCP:server → consider → SEC:* + OBS:monitoring + CS:performance
MCP:client → consider → CS:caching + TS:integration + OBS:metrics

Progressive Enhancement Paths¶

Maturity Levels¶

Level 1 (Basic) → Level 2 (Intermediate) → Level 3 (Advanced)

Coding Standards Path¶

CS:style → CS:architecture → CS:patterns → CS:optimization
   ↓           ↓                ↓              ↓
Basic      SOLID/DRY      Design Patterns   Advanced

Testing Evolution¶

TS:unit → TS:integration → TS:performance → TS:chaos
   ↓           ↓                ↓              ↓
70% cov    API tests       Load testing    Resilience

Security Maturity¶

SEC:basic → SEC:auth → SEC:advanced → SEC:zero-trust
    ↓           ↓           ↓              ↓
Passwords   OAuth/JWT    Encryption    Complete ZT

Conflict Resolution¶

Incompatible Standards¶

OLD:jquery ← conflicts → FE:react (Use one framework)
CS:callbacks ← conflicts → CS:async-await (Choose pattern)
PM:waterfall ← conflicts → PM:agile (Methodology choice)

Migration Paths¶

From: OLD:standard → To: NEW:standard
Path: @load MIGRATION:old-to-new

Standard Clusters¶

Full Stack Web Development¶

Core: [CS:javascript + FE:react + CS:api + DE:postgres]
Security: [SEC:auth + SEC:api + SEC:frontend]
Testing: [TS:jest + TS:integration + TS:e2e]
Operations: [DOP:cicd + OBS:monitoring + CN:docker]

Data Engineering Platform¶

Core: [DE:pipelines + DE:warehouse + CS:python]
Processing: [EVT:kafka + DE:spark + DE:airflow]
Quality: [DE:quality + TS:data + OBS:data-monitoring]
Governance: [LEG:privacy + SEC:encryption + DE:catalog]

Microservices Architecture¶

Core: [CN:microservices + CS:api + EVT:*]
Infrastructure: [CN:kubernetes + CN:service-mesh + DOP:gitops]
Observability: [OBS:distributed + OBS:tracing + OBS:metrics]
Reliability: [TS:chaos + CN:circuit-breaker + OBS:slo]

AI Integration Platform¶

Core: [MCP:* + CS:api + SEC:auth]
Server: [MCP:server + MCP:security + OBS:monitoring]
Client: [MCP:client + MCP:tools + CS:caching]
Testing: [TS:integration + TS:performance + MCP:testing]

Usage Examples¶

Automatic Expansion¶

User: @load CS:api
System: Also loading required: [CS:error-handling + CS:validation]
System: Recommended additions: [SEC:api + TS:integration + OBS:monitoring]

Conflict Detection¶

User: @load [PM:waterfall + PM:agile]
System: ⚠️ Conflict detected: These methodologies are incompatible
System: Choose one: [PM:waterfall] OR [PM:agile]

Path Guidance¶

User: How do I progress from basic to advanced testing?
System: Your testing maturity path:
1. Current: TS:unit (70% coverage)
2. Next: TS:integration + TS:mocking
3. Then: TS:performance + TS:security
4. Advanced: TS:chaos + TS:property-based