Skill UI

This detailed guide helps authors assess the scientific rigor and scope fit for manuscripts targeting Composites Part B: Engineering. It covers advanced domains like composite mechanics, manufacturing processes, multiscale modeling, and multifunctional materials. It emphasizes that a strong contribution must demonstrate a clear, mechanism-driven advance from material science to structural application, supported by rigorous, quantitative experimental evidence and model validation.

This guide assists researchers in transforming vague datasets or observations into robust, positive, and economics-driven research questions suitable for prestigious accounting journals (like JAE). It teaches key concepts, such as identifying economic friction, distinguishing between normative and positive questions, establishing plausible identification strategies, and mapping the topic to specific academic domains.

Apply Eric Evans-inspired Domain-Driven Design rules for modeling complex domains. Define bounded contexts, protect ubiquitous language, and design aggregates. Use this skill for strategic domain modeling, context mapping, repositories, and domain services before making design or code decisions.

Apply lightweight Domain-Driven Design rules for bounded contexts, subdomains, and tactical modeling without unnecessary ceremony. Ideal for practical software architecture guidance and design decisions in complex systems.

Apply Vaughn Vernon-inspired rules for building aggregates, domain events, repositories, and application services. This skill helps structure code using bounded contexts and domain logic, ensuring clean architecture and maintainable software design during development.

Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems. This skill helps in designing new backend systems, refactoring monolithic applications, and establishing architecture standards for your team. It is suitable for migrating from tightly coupled to loosely coupled architectures and planning microservices decomposition.

This skill simulates Bill Gates, a Microsoft co-founder and global technology strategist. It provides expert advice on business strategy, software industry architecture, systematic investing, and data-driven philanthropy. Use this for specialized tasks requiring Gates' specific domain knowledge and strategic perspective.

This skill guides the definition of relationships and integration contracts between distinct bounded contexts within a complex system using Domain-Driven Design (DDD) patterns. It is crucial for preventing domain leakage, planning anti-corruption layers (ACLs), and clarifying ownership boundaries when multiple services interact, ensuring a robust and scalable system architecture.

This skill guides the architectural definition of complex business domains using Domain-Driven Design (DDD). It helps in defining core subdomains, separating services by bounded contexts, and establishing a unified ubiquitous language. It is essential for decomposing monoliths, structuring microservices, and aligning team ownership with clear domain boundaries.

This skill guides the application of Domain-Driven Design (DDD) tactical patterns, including defining aggregates, modeling value objects, managing repositories, and utilizing domain events. It helps developers translate complex domain rules into clean, robust, and behavior-rich code structures, ensuring invariants are explicitly enforced.

Expert in event sourcing, CQRS, and event-driven architecture patterns. Masters event store design, projection building, saga orchestration, and eventual consistency patterns. Use for systems requiring audit trails, complex domain modeling, or temporal queries.

This skill provides a comprehensive framework for mastering microservices architecture patterns. It covers critical aspects of building robust, distributed systems, including defining service boundaries (Domain-Driven Design), managing inter-service communication, handling distributed data transactions, and implementing various resilience patterns (e.g., circuit breaker, circuit breaker). It is essential for large-scale system decomposition.