SysML v2 AI workflows SEM anchor example Templates

AI-Assisted MBSE (AIM) teaches practical, repeatable workflows for using AI to dramatically accelerate SysML v2 modeling - without sacrificing rigor, structure, or traceability.

The course is organized around a concrete anchor example (a Scanning Electron Microscope) to demonstrate how models evolve from early concepts through architecture, simulation, implementation, and verification.

This page provides the detailed module-by-module course outline. The module details below are presented in an expandable format so you can quickly skim the flow or drill into each module.

Template-Driven Acceleration with AI

A distinguishing feature of AIM is its emphasis on template-driven generation. Participants learn how to define reusable code and model generation templates that encode architectural decisions, modeling structure, and quality rules. AI is then used to populate those templates consistently and repeatedly.

This approach changes the economics of MBSE: engineers update intent or templates and regenerate artifacts, instead of manually reworking dozens of diagrams and specifications.

High-level generation strategy: generate system spec, then subsystem specs one at a time

At the highest level, AIM generates a system specification first, followed by detailed specifications for subsystems - one subsystem at a time. This staged approach establishes system-level intent before detailed architectural elaboration begins.

System specification template: domain model, high-level requirements, use cases, list of subsystems

Engineers begin by defining a system specification template. AI is then used to populate that template to generate a domain model, a set of high-level requirements, a set of use cases, and an initial list of subsystems.

Logical architecture template: subsystem requirements, parts decomposition, state machine, IBD

Once the system structure is in place, engineers apply logical architecture templates to each subsystem. These templates generate subsystem requirements, parts decomposition, subsystem state machines, and subsystem internal block diagrams. The result is dramatic acceleration: update intent or templates and regenerate artifacts, instead of manually reworking dozens of diagrams and specifications.

Who this course is for
  • SysML practitioners transitioning from SysML 1.x to SysML v2
  • Teams exploring AI to accelerate system modeling and development
  • Organizations that need faster modeling without losing rigor
  • Engineers building spec-to-model-to-code pipelines
What you will be able to do
  • Define and use generation templates for SysML v2 models
  • Maintain stable "golden samples" that constrain AI output
  • Regenerate system artifacts safely as designs evolve
  • Keep models, code, and verification artifacts aligned over time
Detailed course modules

Click a module to expand the details.

  • Template-driven generation as a core AIM principle
  • Human responsibility for structure and intent
  • AI as an execution engine, not a system designer
  • Regeneration as a first-class engineering activity
  • Why software-first thinking changes architecture
  • Aligning SysML models with object-oriented design
  • Avoiding architectures that software teams ignore
  • Domain-driven thinking as a unifying approach
  • Domain modeling via system specification templates
  • Generating domain objects, relationships, and vocabulary
  • Ensuring consistency across systems and variants
  • Regenerating domain artifacts as understanding evolves
  • Structured requirements templates
  • Detecting ambiguity and testability issues
  • Maintaining traceability without excessive overhead
  • Using AI to assist engineering judgment
  • Use case templates that drive consistent narratives
  • Discovering alternate and exception paths
  • Bridging stakeholder intent and system behavior
  • Avoiding brittle, over-templated behavior models
  • Subsystem-level architectural templates
  • Generating decomposition, behavior, and interfaces
  • Avoiding functional-decomposition traps
  • Preserving architectural coherence through regeneration
  • Mapping logical elements to physical components
  • Preserving intent during architectural refinement
  • Managing constraints and implementation detail
  • Understanding where AI helps - and where it does not
  • Constraint and parametric templates
  • Common simulation pitfalls: units, bindings, context
  • Accelerating setup while preserving correctness
  • Integrating behavior and parametrics coherently
  • Code generation templates derived from system models
  • Using AI to populate templates across subsystems
  • Regenerating code as models evolve
  • Achieving significant reductions in development effort
  • Schema templates based on domain models
  • Aligning data design with behavior and requirements
  • Maintaining consistency through regeneration
  • Using AI within clearly defined structural guardrails
  • UI flow templates derived from use cases
  • Maintaining consistency between UI and system behavior
  • Accelerating UI specification with AI
  • Preserving traceability and testability
  • Test templates derived from behavior and requirements
  • AI-assisted generation of test suites
  • Regenerating tests as systems evolve
  • Coverage across nominal and off-nominal scenarios