ai-playbook 1.0.0

package/skills/architecture/skill.md

@@ -0,0 +1,189 @@
+# Architecture Skill
+
+## Purpose
+
+The Architecture skill enables software engineers to design, analyze, and evolve complex systems with clear separation of concerns, scalability, and maintainability. This skill focuses on system-level design patterns, component relationships, data flows, integration strategies, and architectural decision-making that balance technical requirements with business constraints.
+
+---
+
+## Table of Contents
+
+1. [Core Competencies](#core-competencies)
+2. [Specific Domains & Tools](#specific-domains--tools)
+3. [Best Practices](#best-practices)
+4. [Deliverables](#deliverables)
+5. [Success Criteria](#success-criteria)
+
+---
+
+## Core Competencies
+
+### 1. **System Decomposition**
+Break monolithic problems into discrete, independently manageable components. Identify component boundaries, define interfaces, and minimize coupling. Apply domain-driven design principles to structure components around business capabilities. Document component responsibilities and interaction patterns.
+
+**Application**: Transforming large systems into microservices, redesigning legacy monoliths, planning multi-team development, establishing service boundaries.
+
+### 2. **Layered Architecture Design**
+Design horizontal layers (presentation, business logic, data access, infrastructure) with clear contracts between layers. Separate concerns by function and ensure each layer has a specific responsibility. Establish patterns for inter-layer communication and data transformation.
+
+**Application**: Creating n-tier applications, designing web frameworks, establishing API boundaries, separating concerns in monolithic applications.
+
+### 3. **Scalability Architecture**
+Design systems that handle growing load horizontally and vertically. Plan for database scaling (replication, sharding, partitioning), caching strategies, load balancing, and asynchronous processing. Identify bottlenecks early and design for elasticity.
+
+**Application**: Planning infrastructure growth, designing distributed databases, implementing caching layers, queue-based architecture for async workloads.
+
+### 4. **Data Architecture & Modeling**
+Design data structures, schemas, and storage strategies aligned with business requirements. Choose appropriate data models (relational, document, graph, key-value). Plan for data consistency, replication, backup strategies, and migration paths.
+
+**Application**: Database schema design, polyglot persistence strategies, data warehouse architecture, event sourcing design.
+
+### 5. **Integration Architecture**
+Design how independent systems communicate and exchange data. Select appropriate integration patterns (APIs, message queues, webhooks, event streams, batch processes). Manage data consistency across system boundaries.
+
+**Application**: Designing service meshes, implementing API gateways, building event-driven systems, orchestrating cross-system workflows.
+
+### 6. **API Design & Contract Management**
+Design APIs with clear contracts that enable loose coupling and independent evolution. Apply versioning strategies, establish governance models, manage API lifecycle. Design for extensibility and backward compatibility.
+
+**Application**: RESTful API design, GraphQL schema design, SDK design, managing API evolution and deprecation.
+
+### 7. **Asynchronous Architecture**
+Design systems using async patterns for improved resilience and scalability. Implement message brokers, event buses, job queues, and eventual consistency models. Handle retries, dead lettering, and ordering guarantees.
+
+**Application**: Building event-driven systems, implementing saga patterns, designing queue-based workflows, handling background jobs.
+
+### 8. **Caching Strategy**
+Design caching layers to reduce latency and database load. Select cache granularity, eviction policies, invalidation strategies, and consistency models. Balance between freshness and performance.
+
+**Application**: Multi-level caching (L1, L2, distributed), cache-aside pattern, write-through/write-behind strategies, distributed cache management.
+
+### 9. **Security Architecture**
+Design systems with security as a first-class concern. Plan authentication, authorization, encryption, secrets management, rate limiting, and threat modeling. Establish security boundaries and access control.
+
+**Application**: Zero-trust architecture, API security design, encryption strategy, secrets rotation, network segmentation.
+
+### 10. **Resilience & Fault Tolerance**
+Design systems that gracefully handle failures. Implement circuit breakers, bulkheads, retries, timeouts, and fallback mechanisms. Plan for partial degradation and graceful degradation.
+
+**Application**: Building fault-tolerant systems, designing for cascading failure prevention, implementing health checks, planning disaster recovery.
+
+### 11. **Event-Driven Architecture**
+Design systems where components communicate through events. Define event schemas, establish event sourcing patterns, implement event replay capabilities. Manage ordering and exactly-once processing.
+
+**Application**: Building real-time systems, implementing audit trails, designing temporal queries, handling high-frequency data updates.
+
+### 12. **Domain-Driven Design (DDD)**
+Apply strategic and tactical DDD principles. Identify bounded contexts, establish ubiquitous language, design aggregates and entities. Integrate multiple bounded contexts through context mapping.
+
+**Application**: Large-scale system design, team organization around domains, reducing coupling in complex domains, managing legacy system boundaries.
+
+### 13. **Architecture Decision Records (ADRs)**
+Document architectural decisions with context, alternatives, rationale, and consequences. Create living documents that explain trade-offs and inform future design. Establish decision frameworks for consistency.
+
+**Application**: Maintaining system knowledge, onboarding new team members, tracking architectural evolution, justifying technical decisions.
+
+### 14. **Technology Selection**
+Evaluate and select technologies that fit architectural requirements. Consider operational burden, vendor lock-in, community support, licensing, and team expertise. Document technology decisions and rationale.
+
+**Application**: Choosing databases, frameworks, languages, infrastructure platforms, evaluating open-source vs. commercial solutions.
+
+### 15. **Evolutionary Architecture**
+Design systems that can be modified incrementally without rewriting. Plan for incremental modernization, strangler pattern migrations, and feature flags. Balance current requirements with future flexibility.
+
+**Application**: Migrating monoliths to microservices, upgrading frameworks, adopting new patterns, managing technical debt strategically.
+
+### 16. **Observability Architecture**
+Design systems with comprehensive logging, metrics, and tracing. Plan for structured logging, distributed tracing, metrics collection, and alert strategies. Enable rapid diagnosis of failures.
+
+**Application**: Implementing distributed tracing, designing metrics hierarchies, establishing logging standards, planning observability for complex systems.
+
+### 17. **Configuration Management**
+Design configuration strategies that balance security, flexibility, and consistency. Manage environment-specific configurations, secrets, feature flags. Enable rapid iterations without redeployment.
+
+**Application**: Multi-environment configuration, secrets management, feature flag architecture, environment parity.
+
+### 18. **Dependency Management**
+Design systems with minimal and well-understood dependencies. Manage version compatibility, plan for dependency upgrades, monitor for vulnerabilities. Establish clear dependency policies.
+
+**Application**: Monorepo strategies, package management, managing transitive dependencies, planning dependency updates.
+
+---
+
+## Specific Domains & Tools
+
+### Architecture Patterns
+- **Monolithic**: Vertical slices, layered architecture, hexagonal architecture
+- **Distributed**: Microservices, service mesh, distributed monolith
+- **Event-Driven**: Event sourcing, CQRS, saga patterns
+- **Data-Intensive**: Stream processing, batch processing, lambda architecture
+
+### Design Patterns
+- Creational: Factory, Builder, Singleton
+- Structural: Facade, Proxy, Adapter, Decorator
+- Behavioral: Observer, Strategy, Command, Mediator, State
+
+### Integration Patterns
+- Synchronous: REST, RPC, gRPC
+- Asynchronous: Message queues, event streams, webhooks
+- Choreography vs. Orchestration
+
+### Tools & Frameworks
+- Architecture Documentation: C4 Model, ArchiMate, UML
+- Visualization: Draw.io, Lucidchart, Architecture Decision Records
+- Analysis: Architecture linters, dependency analyzers, design review tools
+- Code-Based Architecture: ArchUnit, NDepend, SonarQube
+
+---
+
+## Best Practices
+
+1. **Start with Requirements**: Architecture must serve business and technical requirements. Understand scalability targets, consistency requirements, resilience needs before designing.
+
+2. **Design for Change**: Assume requirements will evolve. Design for incremental modification, not perfection. Plan for refactoring and modernization.
+
+3. **Minimize Coupling**: Reduce dependencies between components. Use contracts and interfaces. Design for independent deployment and testing.
+
+4. **Explicit Trade-offs**: Every architectural decision involves trade-offs. Document alternatives considered and rationale. Make trade-offs visible to stakeholders.
+
+5. **Validate Assumptions**: Test architectural decisions early. Build proof-of-concepts for critical decisions. Validate scalability, consistency, and resilience assumptions.
+
+6. **Consistency in Patterns**: Use consistent patterns across the system. Establish conventions that reduce cognitive load. Document patterns clearly.
+
+7. **Design for Observability**: Build systems that can be understood in production. Plan for debugging, monitoring, and alerting. Make failure modes visible.
+
+8. **Plan for Evolution**: Design systems that can evolve over time. Plan for technology upgrades, pattern changes, and team scaling. Avoid architectural lock-in.
+
+9. **Document Rationale**: Explain why architectural decisions were made. Document trade-offs and alternatives. Enable future teams to make informed decisions.
+
+10. **Review Continuously**: Regularly review architecture against requirements. Adjust as requirements change. Plan for incremental improvement.
+
+---
+
+## Deliverables
+
+- **Architecture Diagrams**: System context diagrams, component diagrams, deployment diagrams, data flow diagrams
+- **Architecture Decision Records**: Documented decisions with rationale and trade-offs
+- **Component Specifications**: Clear component boundaries, interfaces, responsibilities, and interactions
+- **Data Architecture**: Schema designs, data models, consistency strategies, backup and recovery plans
+- **Integration Plans**: API specifications, integration patterns, data exchange mechanisms
+- **Scalability Analysis**: Bottleneck identification, growth projections, scaling strategies
+- **Security Architecture**: Threat models, access control design, encryption strategies
+- **Resilience Plans**: Failure mode analysis, mitigation strategies, recovery procedures
+- **Technology Selection Report**: Evaluation of alternatives with rationale
+- **Migration & Evolution Roadmap**: Phased approach for architectural changes
+
+---
+
+## Success Criteria
+
+1. **Requirements Alignment**: Architecture clearly addresses all stated requirements and constraints
+2. **Clear Decomposition**: Components have clear boundaries and can be understood independently
+3. **Stakeholder Alignment**: Architecture decisions are understood and agreed upon by stakeholders
+4. **Flexibility**: System can be modified incrementally without major rewrites
+5. **Scalability**: Architecture can accommodate growth in load, data, and complexity
+6. **Maintainability**: New team members can understand the system structure within reasonable timeframes
+7. **Resilience**: System handles failures gracefully without cascading impacts
+8. **Documentation**: Architecture is documented thoroughly with rationale for decisions
+9. **Consistency**: Patterns are applied consistently across the system
+10. **Risk Mitigation**: Technical risks are identified and mitigated proactively

package/skills/design-architecture/README.md

@@ -0,0 +1,107 @@
+# Design Architecture
+
+## Overview
+
+The **Design Architecture** skill enables AI models to create and refine user interfaces, interaction patterns, and design systems that are intuitive, accessible, scalable, and maintain visual consistency across products and platforms.
+
+This skill balances aesthetics, functionality, and user experience with technical feasibility and business goals.
+
+---
+
+# Goals
+
+* Create intuitive user interfaces
+* Design accessible experiences
+* Build scalable design systems
+* Maintain visual consistency
+* Improve user satisfaction
+* Enable rapid iteration
+* Support multiple platforms
+* Balance aesthetics and function
+
+---
+
+# Capabilities
+
+## Design Systems
+* Component libraries
+* Design tokens
+* Pattern documentation
+* Style guides
+
+## Interface Design
+* Information architecture
+* Navigation design
+* Form design
+* Layout composition
+
+## User Experience
+* User research
+* Accessibility design
+* Responsive design
+* Interaction design
+
+## Visual Design
+* Typography systems
+* Color systems
+* Motion design
+* Branding consistency
+
+---
+
+# When to Use
+
+* Creating design systems
+* Designing user interfaces
+* Improving accessibility
+* Establishing design standards
+* Redesigning products
+* Creating prototypes
+* Conducting design reviews
+
+---
+
+# Expected Workflow
+
+```
+Understand Users & Goals
+        ↓
+Research & Analyze
+        ↓
+Define Information Architecture
+        ↓
+Create Wireframes
+        ↓
+Design Mockups
+        ↓
+Iterate Based on Feedback
+        ↓
+Handoff to Development
+```
+
+---
+
+# Best Practices
+
+Always:
+* Research user needs
+* Design for accessibility
+* Maintain consistency
+* Test designs with users
+* Design for multiple devices
+* Document decisions
+* Iterate frequently
+
+Never:
+* Skip user research
+* Ignore accessibility
+* Create inconsistent interfaces
+* Design without testing
+* Assume mobile will work automatically
+* Forget about edge cases
+
+---
+
+# Success Criteria
+
+Successful design architecture creates intuitive interfaces, meets WCAG standards, maintains consistency, improves user satisfaction, and enables efficient development.

package/skills/design-architecture/examples.md

@@ -0,0 +1,84 @@
+# Design Architecture Skill - Examples
+
+This document contains practical examples demonstrating when and how to use the Design Architecture Skill.
+
+---
+
+# Example 1 - Design System Creation
+
+## User Request
+Create a design system for this organization.
+
+## Expected Behavior
+* Define design tokens (colors, typography, spacing)
+* Create component library
+* Document design patterns
+* Establish governance model
+* Create usage guidelines
+* Plan for scale
+
+---
+
+# Example 2 - Information Architecture
+
+## User Request
+Redesign the information architecture for this complex product.
+
+## Expected Behavior
+* Analyze current structure
+* Identify usability issues
+* Propose new hierarchy
+* Design navigation
+* Create wireframes
+* User test with mockups
+
+---
+
+# Example 3 - Accessibility Audit
+
+## User Request
+Audit this interface for accessibility issues.
+
+## Expected Behavior
+* Check WCAG compliance
+* Test keyboard navigation
+* Verify color contrast
+* Test screen readers
+* Document issues
+* Recommend fixes
+
+---
+
+# Example 4 - Dashboard Design
+
+## User Request
+Design a performance monitoring dashboard.
+
+## Expected Behavior
+* Define information needs
+* Choose visualizations
+* Organize layout
+* Design interactions
+* Create high-fidelity mockup
+* Plan for responsiveness
+
+---
+
+# Example 5 - Form Optimization
+
+## User Request
+Redesign this user signup form for better conversion.
+
+## Expected Behavior
+* Analyze current form
+* Simplify field requirements
+* Design progressive disclosure
+* Improve error handling
+* Create high-fidelity mockup
+* Plan user testing
+
+---
+
+# Success Criteria
+
+Successful design architecture creates intuitive interfaces, maintains consistency, supports accessibility, and improves user satisfaction.

package/skills/design-architecture/skill.md

@@ -0,0 +1,192 @@
+# Design Architecture Skill
+
+## Purpose
+
+The Design Architecture skill enables the creation and refinement of user interfaces, interaction patterns, and design systems that are intuitive, accessible, and scalable. This skill focuses on translating user needs and business requirements into cohesive visual and interaction designs that maximize usability while maintaining consistency across products and platforms. Design architecture balances aesthetics, functionality, and user experience with technical feasibility and business goals.
+
+---
+
+## Table of Contents
+
+1. [Core Competencies](#core-competencies)
+2. [Specific Domains & Tools](#specific-domains--tools)
+3. [Best Practices](#best-practices)
+4. [Deliverables](#deliverables)
+5. [Success Criteria](#success-criteria)
+
+---
+
+## Core Competencies
+
+### 1. **Design System Architecture**
+Create cohesive design systems that provide consistency across products. Define component libraries, design tokens (colors, typography, spacing), and patterns. Establish documentation and governance for design system evolution. Enable teams to build consistently without duplicating effort.
+
+**Application**: Creating enterprise design systems, establishing component libraries, scaling design across multiple products, maintaining design consistency across platforms.
+
+### 2. **Information Architecture**
+Design how information is organized and accessed. Create clear hierarchies, navigation models, and mental models that users understand intuitively. Plan for content growth and changing user needs. Establish consistent organizational patterns.
+
+**Application**: Designing information hierarchies, creating navigation systems, organizing content, planning user journeys, establishing mental models.
+
+### 3. **Interaction Design**
+Design how users interact with systems. Create clear affordances that guide users toward intended actions. Design responsive feedback mechanisms and progressive disclosure. Plan state transitions and edge cases. Ensure interactions feel natural and intentional.
+
+**Application**: Designing user flows, creating interaction patterns, designing form interactions, planning error states, designing micro-interactions.
+
+### 4. **Visual Hierarchy & Composition**
+Use visual design principles to guide user attention and comprehension. Design with emphasis, contrast, alignment, and white space. Create visual relationships that communicate meaning and priority. Design for rapid scanning and information processing.
+
+**Application**: Designing dashboards, creating report interfaces, designing content-heavy layouts, designing mobile interfaces, creating marketing sites.
+
+### 5. **Accessibility & Inclusive Design**
+Design systems that work for all users regardless of ability. Meet WCAG standards for color contrast, typography, keyboard navigation, and screen readers. Design with diverse user needs in mind. Plan for assistive technology compatibility.
+
+**Application**: Ensuring color contrast meets WCAG AA, designing keyboard-navigable interfaces, creating alt text strategies, testing with assistive technologies.
+
+### 6. **Responsive & Adaptive Design**
+Design interfaces that work across devices and screen sizes. Plan for different input methods (touch, mouse, keyboard). Design flexible layouts and breakpoints. Optimize for performance on mobile devices.
+
+**Application**: Designing mobile-first experiences, creating responsive layouts, designing for multiple device classes, optimizing mobile performance.
+
+### 7. **Typography & Readability**
+Design with typography that maximizes readability and conveys meaning. Choose typefaces that work across contexts. Plan font sizes, line heights, and spacing for different content types. Design for scannability.
+
+**Application**: Establishing typography systems, designing for multilingual content, optimizing for web readability, creating reading experiences.
+
+### 8. **Color & Visual Language**
+Design color systems that convey meaning and emotion. Create accessible color combinations. Design for colorblind users. Establish visual languages that differentiate the product. Plan for dark mode and theming.
+
+**Application**: Creating color systems, designing for semantic meaning with color, supporting dark mode, designing accessible color schemes.
+
+### 9. **Motion & Animation**
+Use motion purposefully to guide attention and communicate state. Design animations that feel natural and don't overwhelm. Create transitions that clarify relationships and changes. Plan for performance impact.
+
+**Application**: Designing micro-interactions, creating loading states, designing transitions, planning for reduced-motion preferences.
+
+### 10. **Form Design & Input**
+Design forms that are intuitive and reduce friction. Plan progressive disclosure and validation feedback. Design for different input types and constraints. Minimize required fields and clear unnecessary steps.
+
+**Application**: Designing sign-up flows, creating checkout flows, designing data entry interfaces, planning validation and error messaging.
+
+### 11. **Data Visualization**
+Design visual representations of complex data that communicate insights quickly. Choose appropriate chart types for data relationships. Design for multiple audience types. Plan for interactivity and drill-down patterns.
+
+**Application**: Designing analytics dashboards, creating reports, designing real-time data displays, designing financial or statistical visualizations.
+
+### 12. **Component Design & Composition**
+Design reusable components that scale across systems. Define component variants and states. Create clear APIs for components. Plan for component composition and flexibility.
+
+**Application**: Creating button systems, designing card components, creating input components, designing modal and dialog patterns.
+
+### 13. **User Research & Validation**
+Conduct research that informs design decisions. Plan user testing for proposed designs. Gather feedback early and iterate. Establish success metrics for design changes.
+
+**Application**: Conducting usability tests, gathering user feedback, analyzing user behavior, validating design assumptions.
+
+### 14. **Design Patterns & Conventions**
+Establish recurring solutions to common design problems. Create pattern libraries for different contexts. Document when to use patterns. Plan for exceptions and edge cases.
+
+**Application**: Creating empty states, designing error states, designing loading states, designing confirmation patterns.
+
+### 15. **Responsive Navigation**
+Design navigation systems that work across devices and contexts. Plan for changing screen sizes and content growth. Create navigation that doesn't overwhelm. Design for mobile navigation patterns.
+
+**Application**: Designing desktop navigation, creating mobile navigation, designing hamburger menus, planning navigation patterns.
+
+### 16. **Theming & Customization**
+Design systems that support theming and customization. Create token systems for visual properties. Design for light/dark modes. Plan for user customization.
+
+**Application**: Supporting multiple themes, designing dark mode, creating customizable interfaces, supporting brand customization.
+
+### 17. **Onboarding & Tutorials**
+Design onboarding experiences that help users understand systems. Create progressive disclosure that doesn't overwhelm. Guide users through key features. Measure onboarding effectiveness.
+
+**Application**: Designing first-run experiences, creating feature tours, designing empty states, planning progressive onboarding.
+
+### 18. **Performance & Optimization**
+Design with performance in mind. Optimize visual assets, minimize rendering overhead, and plan for fast loading. Consider impact of design on performance. Design for low-bandwidth scenarios.
+
+**Application**: Optimizing for fast loading, designing progressive rendering, planning image strategies, designing for slow networks.
+
+---
+
+## Specific Domains & Tools
+
+### Design Systems & Tools
+- **Component Libraries**: Storybook, Bit, Chromatic
+- **Design Tools**: Figma, Adobe XD, Sketch
+- **Design Systems**: Material Design, Carbon, Ant Design
+- **Documentation**: Design system sites, component guides
+
+### User Experience Domains
+- **Web Applications**: Dashboard design, SaaS interfaces, data-heavy applications
+- **Mobile**: iOS, Android, responsive web design
+- **Emerging**: Voice interfaces, AR/VR, wearables
+
+### Research & Testing Methods
+- **Usability Testing**: Remote testing, moderated sessions, unmoderated studies
+- **User Research**: Interviews, surveys, analytics, user journey mapping
+- **Prototyping**: Low-fidelity, high-fidelity, interactive prototypes
+- **A/B Testing**: Multivariate testing, performance optimization
+
+### Tools & Technologies
+- **Prototyping**: Figma, Adobe XD, Sketch, InVision
+- **Analytics**: Google Analytics, Segment, Mixpanel
+- **Testing Tools**: UserTesting, Maze, Lookback
+- **Accessibility**: Axe DevTools, WAVE, NVDA, JAWS
+
+---
+
+## Best Practices
+
+1. **User-Centered Design**: Keep user needs at the center of all design decisions. Research before designing. Validate with users.
+
+2. **Consistency First**: Use consistent patterns, components, and interactions. Establish standards that enable users to predict behavior.
+
+3. **Simplicity Over Complexity**: Remove unnecessary elements. Reduce cognitive load. Favor clarity over cleverness.
+
+4. **Design for Accessibility**: Accessible design is good design for everyone. Plan for accessibility from the start, not as an afterthought.
+
+5. **Progressive Disclosure**: Don't overwhelm users with options. Reveal complexity only when needed. Prioritize essential information.
+
+6. **Test Early & Often**: Validate designs with users early. Don't wait for finished designs. Get feedback frequently.
+
+7. **Design Systems for Scale**: Create reusable components and patterns. Reduce duplication. Enable faster iteration.
+
+8. **Responsive by Default**: Design for all screen sizes. Prioritize mobile. Test on real devices.
+
+9. **Performance First**: Design with performance in mind. Optimize visual assets. Consider impact on user experience.
+
+10. **Iterate Based on Data**: Use analytics and user testing to inform decisions. Measure impact of design changes. Plan for continuous improvement.
+
+---
+
+## Deliverables
+
+- **Design System Documentation**: Component library, design tokens, patterns, usage guidelines
+- **Wireframes**: Low-fidelity representations of interface layouts and flows
+- **High-Fidelity Mockups**: Detailed visual designs with colors, typography, imagery
+- **Prototypes**: Interactive prototypes demonstrating user flows and interactions
+- **User Flows**: Diagram of user journeys and interaction sequences
+- **Design Patterns**: Documented solutions for recurring design problems
+- **Style Guide**: Typography, color, spacing, and visual language documentation
+- **Accessibility Audit**: Compliance assessment against WCAG guidelines
+- **Research Findings**: User research insights and usability test results
+- **Design Specifications**: Detailed specifications for developers (spacing, sizing, states)
+- **Animation Guide**: Motion principles, animation timing, transition specifications
+- **Component Specifications**: Detailed component definitions with variants and states
+
+---
+
+## Success Criteria
+
+1. **User Satisfaction**: Users find interfaces intuitive and easy to use (measured through NPS, satisfaction surveys)
+2. **Accessibility**: Interfaces meet WCAG AA standards and work with assistive technologies
+3. **Consistency**: Design patterns and components are applied consistently throughout product
+4. **Usability**: Users accomplish primary tasks with minimal friction (measured through task success rates)
+5. **Performance**: Design doesn't negatively impact page load time or responsiveness
+6. **Scalability**: Design system enables consistent design across multiple products and teams
+7. **Adoption**: Design system components used for >80% of new features (no reinvention)
+8. **Alignment**: Design aligns with brand identity and business goals
+9. **Flexibility**: System accommodates different contexts and content without requiring redesign
+10. **Maintainability**: Design system is documented and easy for teams to understand and extend