CLAUDE.md - Advanced LLM-Optimized Project Standards Router¶

@load context:[auto] + history:[recent] + related:[graph-expansion]

# Basic Loading
@load CS:api                    # Single section
@load [CS:* + TS:* + SEC:*]    # Multiple standards
@load KM:*                      # Knowledge management architecture
@load NIST-IG:*                 # NIST implementation guidance

# Advanced Loading
@load CS:api version:[latest] expand:[dependencies]
@load context:[react-app] auto:[true]
@load similar-to:[example-project] adapt:[team-size]

# Semantic Loading
@ask "How to build secure API" → auto-loads relevant standards
@need "performance optimization" → loads performance toolkit
@ask "how to organize docs" → loads KM:architecture + examples

@analyze [code] → compliance-report
@fix [violations] → automated-fixes
@suggest [improvements] → enhancement-plan
@validate [changes] → real-time-feedback

@generate [component] following:[standards] with:[patterns]
@create [test-suite] covering:[requirements] style:[team-preference]
@scaffold [project] using:[standards + templates]

@validate live:[true] show:[inline-hints] fix:[auto-safe]
@check pr:[url] comment:[violations] suggest:[fixes]

@show dependencies for:[CS:api]
@find related to:[SEC:auth]
@suggest path from:[current] to:[target-maturity]

@load CS:api version:[latest]
@migrate from:[old] to:[new] generate:[migration-script]
@diff versions:[previous...latest] impact:[current-project]

# Version info now in MANIFEST.yaml under 'versioning' section
@check versions in:[MANIFEST.yaml#versioning]

@show progression for:[testing-maturity]
@recommend next:[based-on-current-usage]
@generate training:[personalized-plan]

@visualize architecture:[current] highlight:[violations]
@generate diagram:[component-relationships] style:[mermaid]
@explain standard:[CS:patterns] format:[interactive-tutorial]

@fix-all type:[docstring] style:[google] preview:[true]
@update standards:[CS:previous→latest] project-wide:[true]
@enforce standards:[critical-only] auto-fix:[true]

@define workflow:[pre-release]
  - validate:[SEC:* + TS:coverage]
  - generate:[changelog, release-notes]
  - check:[breaking-changes]
  - notify:[stakeholders]

@template [api-endpoint] context:[fastapi + auth + postgres]
@template [react-component] patterns:[hooks + testing + accessibility]
@template [data-pipeline] style:[airflow + dbt + quality-checks]

@example [error-handling] for:[current-language] level:[team-expertise]
@show [best-practice] adapted-to:[project-patterns]

"How to handle errors properly" → CS:error-handling + examples
"Security best practices" → SEC:* prioritized by relevance
"Make code faster" → CS:performance + OBS:profiling + patterns

Based on your current file:
- Consider adding: [error-handling]
- Related standard: [SEC:validation]
- Similar pattern in: [other-module]

@report compliance:[current] trend:[30-days] gaps:[highlighted]
@track adoption:[team] standards:[all] frequency:[weekly]

Most used standards: [CS:api, TS:unit, SEC:auth]
Compliance score: 87% (+5% this month)
Top violations: [missing-docstrings, test-coverage]

@load tools:[language:level] → Load tools by recommendation level
@suggest tools:[category] → Get tool recommendations
@compare tools:[tool1 vs tool2] → Compare tool options
@migrate tools:[old→new] → Get migration guide

@show tools:[python:all] → List all Python tools
@show tools:[required] → Show all required tools
@show tools:[security:recommended] → Recommended security tools
@check tool:[name] → Check tool details and version

@generate config:[black + ruff + mypy] → Generate tool configs
@setup toolchain:[python + recommended] → Complete setup
@validate tools:[current] → Check tool compliance

# Setup new Python project with modern tools
@load tools:[python:required + python:recommended]
@generate config:[all] in:[pyproject.toml]

# Migrate from legacy tools
@migrate tools:[flake8→ruff + pylint→ruff]
@show migration:[step-by-step]

# Security audit toolchain
@load tools:[security:required]
@generate workflow:[security-scanning]

@integrate with:[vscode|intellij|vim]
@configure realtime:[validation + hints + fixes]
@sync settings:[team-wide]

@generate workflow:[github-actions|gitlab-ci|jenkins]
@configure gates:[quality + security + coverage]
@report to:[slack|email|dashboard]

When loading any standard:
- Include relevant security sections
- Validate against OWASP Top 10
- Check for exposed secrets
- Suggest security improvements

# Cache for session
@cache standards:[CS:api, SEC:auth] duration:[session]
@cache frequently-used:[CS:*, TS:unit] duration:[24h]

# Preload common patterns
@preload common:[bug_fix, new_feature, security_review]
@preload based-on:[project-type] auto:[true]

# Cache control
@cache-status  # Show cached standards and expiry
@cache-clear [specific-standard]  # Clear specific cache
@cache-refresh  # Update all cached standards

@if-cached CS:api use:[cache] else:[@load CS:api]
@fetch-if-modified CS:api since:[last-check]
@use-cached-or-micro CS:api  # Use cache, fallback to micro

@peek CS:api  # First 100 tokens preview
@summary CS:api  # AI-generated summary
@toc CS:api  # Table of contents only
@stats CS:api  # Size, sections, last updated

@lazy-load CS:api sections:[overview]  # Start minimal
@expand CS:api add:[patterns]  # Add more sections
@load-on-demand CS:api  # Load sections as referenced

@chunk CS:api size:[1000-tokens]  # Load in chunks
@stream CS:api  # Progressive streaming
@load CS:api until:[token-limit:5000]  # Stop at limit

@validate-remote code:[snippet] against:[CS:python]
@check-remote url:[github.com/user/repo] standards:[SEC:*]
@lint-remote file:[path] rules:[CS:style + TS:coverage]

# Remote access patterns now in standards-api.json
@see standards-api.json#direct_access

@validate-live enabled:[true] standards:[current-context]
@auto-fix-remote violations:[safe-only]
@suggest-fixes show:[inline] confidence:[high]

@remember preferences:[style, patterns, standards]
@learn from:[corrections, choices, feedback]
@adapt to:[team-conventions, project-patterns]

When you use: [pattern-A]
Also consider: [related-pattern-B]
Teams like yours use: [pattern-C]

@load NIST_IMPLEMENTATION_GUIDE.md + COMPLIANCE_STANDARDS.md + context:[nist-moderate]

# Quick Reference
Authentication → @nist ia-2, ia-5
Authorization → @nist ac-2, ac-3, ac-6
Encryption → @nist sc-8, sc-13
Logging → @nist au-2, au-3
Session management → @nist ac-12
Error handling → @nist si-11

# Format
@nist <control-id> "<brief description>"

@load compliance:nist-moderate  # Load moderate baseline controls
@load nist:[ac-* + ia-* + sc-*]  # Load specific families
@load evidence:[code + config + test]  # Load evidence patterns
@load NIST_IMPLEMENTATION_GUIDE.md  # Load quick start guide

@analyze [codebase] against:[standards] output:[report|suggestions|fixes]
@audit [pull-request] using:[CS:* + TS:* + SEC:*] flag:[violations|improvements]
@suggest improvements for:[file|module] based-on:[relevant-standards]

@fix [violation-type] in:[code-context] following:[standard-section]
@fix-all [violation-type] in:[directory|project]
@generate migration-script from:[old-standard] to:[new-standard]

@validate pull-request:[PR-URL]
@comment violations on:[specific-lines]
@block commit if:[critical-violations]

Task: [DESCRIPTION]
1. Identify context → @load smart:[context-aware]
2. Analyze requirements → Required: [list], Recommended: [list]
3. Generate solution → Following: [standards], Validating: [real-time]

Example 1: Auth endpoint → @load [CS:api + SEC:auth]
Example 2: Data endpoint → @load [CS:api + LEG:privacy]
Your task: [REQUIREMENT] → Applying patterns...

Initial: @generate based-on:[requirements]
+ "Add auth" → @enhance with:[SEC:auth]
+ "Optimize" → @optimize using:[CS:performance]