generate_summary_faq ai feature ready to commit

Author: chrismoroney

.gitignore

@@ -27,7 +27,3 @@ tags
 
 # Generated spell check config
 .spellcheck-non-draft.yml
-reports/generated-summary-faq/local-test.yml
-reports/generated-summary-faq/*.txt
-reports/generated-summary-faq/*.md
-reports/generated-summary-faq/*/

content/learning-paths/automotive/intro/_index.md

@@ -15,11 +15,9 @@ prerequisites:
 draft: true
 cascade:
     draft: true
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 author: Jason Andrews
 
 ### Tags

content/learning-paths/automotive/openadkit1_container/_index.md

@@ -14,59 +14,9 @@ learning_objectives:
 prerequisites:
     - An Arm Neoverse cloud instance, or a local Arm Neoverse Linux computer with at least 16 CPUs and 32GB of RAM
     - Familiarity with Docker and Docker Compose
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
-
-# START generated_summary_faq
-generated_summary_faq:
-  template_version: summary-faq-v3
-  generated_at: '2026-06-02T21:26:58Z'
-  generator: ai
-  ai_assisted: true
-  ai_review_required: true
-  model: gpt-5
-  prompt_template: summary-faq-v3
-  source_hash: 37913b2c4aed914d32dbdad054ebdd2b1d4587da3ede1a33ba81e3e68bf504a3
-  summary_generated_at: '2026-06-01T20:57:21Z'
-  summary_source_hash: 37913b2c4aed914d32dbdad054ebdd2b1d4587da3ede1a33ba81e3e68bf504a3
-  faq_generated_at: '2026-06-02T21:26:58Z'
-  faq_source_hash: 37913b2c4aed914d32dbdad054ebdd2b1d4587da3ede1a33ba81e3e68bf504a3
-  summary: >-
-    This Learning Path shows how to deploy and run a containerized autonomous driving simulation
-    using Autoware Open AD Kit on Arm Neoverse with Docker, illustrating SOAFEE-aligned Shift-Left
-    development. You will use a Linux Arm Neoverse instance—cloud or on‑prem—and Docker Compose
-    to launch the Open AD Kit demo, which starts a Visualizer and then runs Planning and Simulation
-    services defined in docker/docker-compose.yml. It introduces the SOAFEE architecture plus
-    the roles of ROS 2 and Open AD Kit. Prerequisites are an Arm Neoverse system with at least
-    16 CPUs and 32GB RAM, and familiarity with Docker and Docker Compose. Estimated time is 60
-    minutes; the example was tested on AWS EC2 and an Ampere Altra workstation.
-  faqs:
-  - question: What do I need before running the demo?
-    answer: >-
-      You need an Arm Neoverse cloud instance or a local Arm Neoverse Linux computer with at least
-      16 CPUs and 32GB of RAM. Familiarity with Docker and Docker Compose is also required.
-  - question: Should I use a cloud instance or an on-prem Arm Neoverse system?
-    answer: >-
-      You can use either. The example has been tested on AWS EC2 and an Ampere Altra workstation,
-      so choose the environment you have access to or that best fits your needs.
-  - question: Do I need to install Docker and Docker Compose?
-    answer: >-
-      Yes. Docker is required to run Open AD Kit, and the demo uses Docker Compose; refer to the
-      Docker install guide to set it up on Linux.
-  - question: What should I expect when I start the demo with Docker Compose?
-    answer: >-
-      The Visualizer service starts first in detached mode, followed by continuous execution of
-      the Planning and Simulation components. The ROS 2 commands and service definitions are specified
-      in docker/docker-compose.yml.
-  - question: Where can I inspect or adjust what gets executed?
-    answer: >-
-      Open the docker/docker-compose.yml file to review the service configuration, startup order,
-      and ROS command lines. You can use it as the basis for exploring advanced configurations
-      mentioned in the path.
-# END generated_summary_faq
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 
 author: Odin Shen
 

content/learning-paths/automotive/openadkit2_safetyisolation/_index.md

@@ -15,64 +15,9 @@ prerequisites:
     - Access to two Arm-based Neoverse cloud instances, or a local Arm Neoverse Linux system with at least 16 CPUs and 32 GB of RAM
     - Completion of the [Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](/learning-paths/automotive/openadkit1_container/) Learning Path
     - Basic familiarity with Docker
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
-
-# START generated_summary_faq
-generated_summary_faq:
-  template_version: summary-faq-v3
-  generated_at: '2026-06-02T21:27:35Z'
-  generator: ai
-  ai_assisted: true
-  ai_review_required: true
-  model: gpt-5
-  prompt_template: summary-faq-v3
-  source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf
-  summary_generated_at: '2026-06-01T20:57:59Z'
-  summary_source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf
-  faq_generated_at: '2026-06-02T21:27:35Z'
-  faq_source_hash: 92a6dac2b1674a44cd623a0c8c3189b38438124a6067ed7ca776999ff1d8b5bf
-  summary: >-
-    This advanced Learning Path shows automotive engineers how to prototype safety-critical isolation
-    for autonomous driving workloads on Arm Neoverse running Linux. You apply ISO 26262 concepts
-    (including ASIL and the V-model), use a safety island architectural approach, and separate
-    a simulation platform into independent, safety-isolated components. Communication between
-    components uses DDS in a publish-subscribe pattern, with containerized deployment and tooling
-    that includes Docker, ROS 2, and Python. Prerequisites include two Arm-based Neoverse cloud
-    instances or a local Arm Neoverse Linux system with at least 16 CPUs and 32 GB RAM, completion
-    of the “Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse” Learning
-    Path, and basic Docker familiarity. Estimated time to complete is about 60 minutes.
-  faqs:
-  - question: What do I need before running this path?
-    answer: >-
-      You need either two Arm-based Neoverse cloud instances or a local Arm Neoverse Linux system
-      with at least 16 CPUs and 32 GB of RAM. You must also have completed the “Deploy Open AD
-      Kit containerized autonomous driving simulation on Arm Neoverse” Learning Path and be familiar
-      with Docker.
-  - question: Can I use a single local system instead of two cloud instances?
-    answer: >-
-      Yes. A local Arm Neoverse Linux system with at least 16 CPUs and 32 GB of RAM is listed
-      as an alternative to two Arm-based Neoverse cloud instances.
-  - question: Which technologies are used for communication and isolation?
-    answer: >-
-      The path uses DDS with a publish–subscribe architecture and containerized deployment to
-      separate components and communicate between them. Tools referenced include Docker, ROS 2,
-      DDS, and Python on Linux.
-  - question: How are ISO 26262 and ASIL levels applied here?
-    answer: >-
-      The path introduces the ISO 26262 safety lifecycle aligned with the V-model and explains
-      how ASIL levels guide design and testing. You apply prevention and detection principles
-      and plan safe-state behavior as part of the workflow.
-  - question: What result should I expect and how do I know I’m on track?
-    answer: >-
-      Expect to separate the simulation platform into independent, safety-isolated components
-      that communicate via DDS. You should be able to describe a safety island architecture versus
-      a non-safety ECU and relate requirements to verification activities consistent with ISO
-      26262.
-# END generated_summary_faq
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 
 author: 
     - Odin Shen

content/learning-paths/automotive/system76-auto/_index.md

@@ -13,60 +13,9 @@ learning_objectives:
 
 prerequisites:
     - A System76 Thelio Astra desktop computer running Ubuntu 24.04. 
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
-
-# START generated_summary_faq
-generated_summary_faq:
-  template_version: summary-faq-v3
-  generated_at: '2026-06-02T21:28:14Z'
-  generator: ai
-  ai_assisted: true
-  ai_review_required: true
-  model: gpt-5
-  prompt_template: summary-faq-v3
-  source_hash: 2b758d2dcf28a683ab164e28578a736d6d730b81dfbc01a6765619052fcdebd0
-  summary_generated_at: '2026-06-01T20:58:28Z'
-  summary_source_hash: 2b758d2dcf28a683ab164e28578a736d6d730b81dfbc01a6765619052fcdebd0
-  faq_generated_at: '2026-06-02T21:28:14Z'
-  faq_source_hash: 2b758d2dcf28a683ab164e28578a736d6d730b81dfbc01a6765619052fcdebd0
-  summary: >-
-    This Learning Path shows how to set up a local automotive software development environment
-    on the Arm-based System76 Thelio Astra and build the Arm Automotive Solutions Software Reference
-    Stack. You will install Multipass on Ubuntu 24.04, create an Ubuntu 20.04 virtual machine,
-    and use Yocto, Docker, and Git to build the stack from the VM. The path introduces the Arm
-    Reference Design-1 AE (RD-1 AE) target, modeled by a Fixed Virtual Platform, and includes
-    running example applications such as a Parsec-enabled TLS demo. By the end, you will have
-    built and run the stack locally in a VM on Thelio Astra; no additional prerequisites beyond
-    the host hardware are listed.
-  faqs:
-  - question: What do I need before running the steps?
-    answer: >-
-      You need a System76 Thelio Astra desktop computer running Ubuntu 24.04. Before starting,
-      install Multipass using the Multipass install guide for Arm Linux. The path uses Multipass,
-      Yocto, Docker, and Git; no other prerequisites are explicitly listed.
-  - question: Which Ubuntu version should I use inside the Multipass VM?
-    answer: >-
-      The build steps use an Ubuntu 20.04 Multipass virtual machine. Multipass creates a cloud-style
-      VM on your desktop to isolate build and test tasks and split system resources.
-  - question: How do I begin the build of the Arm Automotive Solutions Software Reference Stack?
-    answer: >-
-      From the Ubuntu 20.04 Multipass VM, create a working directory and clone the repository
-      as shown in the steps. A successful clone without errors indicates the environment is ready
-      for the Yocto-based build process.
-  - question: Can I run the demos without RD-1 AE hardware?
-    answer: >-
-      Yes. The example applications demonstrate the software stack running on a Fixed Virtual
-      Platform that models the reference hardware system.
-  - question: What result should I expect from the Parsec demo?
-    answer: >-
-      The Parsec-enabled TLS demo illustrates an HTTPS session where a simple web page is transferred
-      over a TLS connection. This demonstrates use of Parsec’s common API to access security and
-      cryptographic services in the stack.
-# END generated_summary_faq
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 
 author: Jason Andrews
 

content/learning-paths/automotive/zenacssdebug/_index.md

@@ -17,65 +17,9 @@ prerequisites:
   - Ubuntu 22.04 host machine
   - Arm Development Studio 2024.1 or later with a valid license - for support see the [Install Guide for Arm DS](/install-guides/armds) 
   - Basic understanding of the Arm Zena CSS software stack, Armv8-A/Armv9-A cores, and Linux
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
-
-# START generated_summary_faq
-generated_summary_faq:
-  template_version: summary-faq-v3
-  generated_at: '2026-06-02T21:28:53Z'
-  generator: ai
-  ai_assisted: true
-  ai_review_required: true
-  model: gpt-5
-  prompt_template: summary-faq-v3
-  source_hash: 8dccdbdd4d9727f3466987ce918d9df0ed9d4d4f28cd613162bacab01d9c18f3
-  summary_generated_at: '2026-06-01T20:59:08Z'
-  summary_source_hash: 8dccdbdd4d9727f3466987ce918d9df0ed9d4d4f28cd613162bacab01d9c18f3
-  faq_generated_at: '2026-06-02T21:28:53Z'
-  faq_source_hash: 8dccdbdd4d9727f3466987ce918d9df0ed9d4d4f28cd613162bacab01d9c18f3
-  summary: >-
-    This introductory Learning Path shows how to debug the Arm Zena Compute Subsystem (CSS) Reference
-    Software Stack on a Fixed Virtual Platform using Arm Development Studio. You will launch the
-    Zena CSS FVP with the Iris debug server, create and save a custom debug configuration, and
-    set up connections for its heterogeneous subsystems: the Runtime Security Engine (Cortex-M55),
-    the Safety Island (Cortex-R82AE), and the primary compute cores (Cortex-A720AE) running Linux.
-    You will step the RSE from reset with TF-M symbols, attach to SI firmware, and attach to the
-    Linux kernel to debug user space processes. Prerequisites are Ubuntu 22.04, Arm Development
-    Studio 2024.1 or later with a valid license, and basic familiarity with Zena CSS, Armv8-A/Armv9-A,
-    and Linux.
-  faqs:
-  - question: What do I need before running the steps?
-    answer: >-
-      Use an Ubuntu 22.04 host and Arm Development Studio 2024.1 or later with a valid license.
-      A basic understanding of the Arm Zena CSS software stack, Armv8‑A/Armv9‑A cores, and Linux
-      is assumed.
-  - question: Why can’t Arm Development Studio connect if I launch the FVP from the build environment
-      command?
-    answer: >-
-      Launching with the provided build command does not enable the Iris debug server, so the
-      model cannot be debugged from Arm Development Studio. Re‑launch the model with additional
-      command‑line options that enable Iris; see FVP_RD_Aspen --help and follow the options shown
-      in the Learning Path.
-  - question: Which connection method should I choose in Arm Development Studio for this target?
-    answer: >-
-      Use the Iris interface to create a debug configuration for the Zena CSS FVP. As of Arm Development
-      Studio 2025.0 there is no out‑of‑the‑box configuration, so you will create your own and
-      save the connections as .launch files.
-  - question: How do I hold the RSE at reset and step through early boot?
-    answer: >-
-      Start a new tmux session if needed, then launch the FVP with the Iris server enabled and
-      without running so it stays at reset. Connect from Arm Development Studio, load Trusted
-      Firmware‑M symbols, and step from reset through the early boot sequence.
-  - question: Can I connect to the Safety Island and the Linux kernel simultaneously?
-    answer: >-
-      Yes. Arm Development Studio supports heterogeneous systems like Zena CSS, so you can create
-      separate connections and attach to all processors at the same time, including the Safety
-      Island firmware and the Linux kernel on the primary compute cores.
-# END generated_summary_faq
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 
 author: Ronan Synnott
 

content/learning-paths/cross-platform/_example-learning-path/_index.md

@@ -15,58 +15,9 @@ learning_objectives:
 
 prerequisites:
     - A [GitHub](https://github.com/) account
-
-generate_summary_faq: false
-
-rerun_summary: true
-rerun_faqs: true
-
-# START generated_summary_faq
-generated_summary_faq:
-  template_version: summary-faq-v3
-  generated_at: '2026-06-02T21:29:45Z'
-  generator: ai
-  ai_assisted: true
-  ai_review_required: true
-  model: gpt-5
-  prompt_template: summary-faq-v3
-  source_hash: a58d5eb4c4256f3e4f4374344ef0e73836e8b51ac7223b0a5238b22137ec0819
-  summary_generated_at: '2026-06-01T20:59:38Z'
-  summary_source_hash: a58d5eb4c4256f3e4f4374344ef0e73836e8b51ac7223b0a5238b22137ec0819
-  faq_generated_at: '2026-06-02T21:29:45Z'
-  faq_source_hash: a58d5eb4c4256f3e4f4374344ef0e73836e8b51ac7223b0a5238b22137ec0819
-  summary: >-
-    This introductory path shows content creators and software developers how to create and contribute
-    a new Arm Learning Path in about 60 minutes. You will set up a text editor, Hugo, and Git;
-    fork the GitHub repository; write your tutorial in markdown; choose one of six site categories
-    based on where the software runs; and add required metadata in the _index.md file so pages
-    render consistently. You will use Hugo to review content locally, commit and push changes
-    to your fork, and submit a pull request for review. All Learning Paths are community-created
-    and published under the Creative Commons Attribution-ShareAlike 4.0 International License.
-  faqs:
-  - question: What do I need before running the steps?
-    answer: >-
-      You need a GitHub account. Three tools are mandatory for authoring: a text editor, the Hugo
-      static site generator, and Git.
-  - question: How do I know whether my topic belongs in a Learning Path?
-    answer: >-
-      A Learning Path is a concise tutorial with detailed steps to complete a specific task. It
-      is not product documentation, marketing material, product or developer news, or a place
-      to embed or link to videos.
-  - question: Which category should I use when adding my Learning Path?
-    answer: >-
-      Choose the category closest to the environment where the software runs: servers-and-cloud-computing,
-      laptops-and-desktops, embedded-and-microcontrollers, iot, mobile-graphics-and-gaming, or
-      automotive. If you are unsure, ask on GitHub.
-  - question: Where do I set the Learning Path metadata, and are there naming rules?
-    answer: >-
-      Add metadata in the _index.md file; it is used by the site to keep Learning Paths consistent.
-      The title should start with a verb, avoid adjectives, and be as concise as possible.
-  - question: How do I contribute my Learning Path for review?
-    answer: >-
-      Commit your changes with Git and push them to your fork on GitHub, then open a pull request.
-      Only you can see changes made to your fork until you submit the pull request.
-# END generated_summary_faq
+generate_summary_faq: true
+rerun_summary: false
+rerun_faqs: false
 
 author: Zach Lasiuk