edit files for hackathon

modules/ROOT/pages/index copy.adoc

@@ -0,0 +1,17 @@
+= Red Hat Open Training Contributor Guide
+:navtitle: Home
+
+== Introduction
+
+This comprehensive guide serves as a reference for anyone interested in developing or contributing training content via the Red Hat Open Training program. 
+
+The Open Training program empowers subject matter experts within the organization to share their knowledge and expertise across the company and beyond.
+Read more about the program https://spaces.redhat.com/pages/viewpage.action?pageId=512755273[here,window=_blank].
+
+A key goal of this program is to enable "citizen developers" and reduce the time required to build and maintain training content.
+Creating training content for such a wide variety of products and technologies with fast product lifecycles to meet the needs of different audiences is impossible to do alone.
+It takes more than a single team to do this and Red Hat is the perfect place to solicit content and participation from a large group of highly skilled people that care about each other's success.
+
+If you are here, you are already interested.
+Move on to the xref:start_here:workflow.adoc[Getting Started] section if you are new to this.
+Otherwise, use the menu on the left to find a section you need.

modules/ROOT/pages/index.adoc

@@ -1,17 +1,34 @@
-= Red Hat Open Training Contributor Guide
-:navtitle: Home
+= Red Hat & NVIDIA AI Factory Content Accelerator
+:navtitle: Event Summary
 
-== Introduction
+== Welcome to the Hackathon
 
-This comprehensive guide serves as a reference for anyone interested in developing or contributing training content via the Red Hat Open Training program. 
+We are pleased to invite you to our AI Factory w/ NVIDIA Content Accelerator! This workshop is an intensive session designed to bridge the gap between product knowledge and real-world execution. Together, we will build the "field-opinionated" playbooks and technical blueprints required to deliver Red Hat and NVIDIA AI Factory solutions at scale.
 
-The Open Training program empowers subject matter experts within the organization to share their knowledge and expertise across the company and beyond.
-Read more about the program https://spaces.redhat.com/pages/viewpage.action?pageId=512755273[here,window=_blank].
+== The Philosophy: Why Your Experience Matters
 
-A key goal of this program is to enable "citizen developers" and reduce the time required to build and maintain training content.
-Creating training content for such a wide variety of products and technologies with fast product lifecycles to meet the needs of different audiences is impossible to do alone.
-It takes more than a single team to do this and Red Hat is the perfect place to solicit content and participation from a large group of highly skilled people that care about each other's success.
+In a world where AI can quickly shape and generate information, retaining the human aspect of knowledge transfer is critical. AI excels at pattern matching, but it lacks the "hard knocks" of trial and error. It does not inherently understand *why* a specific approach led to results, or why alternative methods might technically work but ultimately fail to achieve the best business outcomes.
 
-If you are here, you are already interested.
-Move on to the xref:start_here:workflow.adoc[Getting Started] section if you are new to this.
-Otherwise, use the menu on the left to find a section you need.
+Your true value lies in sharing the lessons learned through failure and iteration. By sharing your perspective, the nuances of your process, and the "Aha!" moments that crystallized your understanding, you translate raw blobs of information into a powerful enablement tool. You aren't just sharing a skill; you are empowering a co-worker to enable a customer and overcome the same journey in the future.
+
+== The Open Training Framework
+
+To capture this knowledge, we are leveraging the Red Hat Open Training framework. Open Training is Red Hat's self-service content development model that empowers subject matter experts to share their knowledge by creating training content. This collaborative approach complements our formal development efforts, ensuring that our materials stay timely, relevant, and grounded in real-world experience. 
+
+By contributing to this accelerator, you help foster a culture of continuous learning at Red Hat. 
+
+== Hackathon Goals & Outcomes
+
+To maintain focus, our work is divided into five core objectives. These will form the foundation of our new, elite content library:
+
+* **Production-Ready Deployments:** Develop repeatable Quickstarts, Playbooks, and Blueprints that move beyond basic training to provide a clear path for production-ready deployment.
+* **Autonomous Agents:** Build enablement on the Llama Stack API and NVIDIA OpenShell runtime to transition from simple chatbots to autonomous, industrial-scale AI agents.
+* **Performance Standards:** Establish hardware and storage benchmarking standards for NVIDIA-Certified Systems and high-performance environments.
+* **Security & Regulations:** Integrate STIG-hardened containers and RHEL for NVIDIA best practices to meet the requirements of regulated industries.
+* **Broader Field Enablement:** Create a high-impact content library to enable the broader field (Specialists, Consultants, and Partners) via existing enablement initiatives.
+
+== Next Steps
+
+Turning your expertise into a structured learning instrument can be challenging. In the following sections, we will outline the logistics of this event and how to use the "docs-as-code" AsciiDoc and Antora toolchain so you can start building immediately.
+
+---

modules/course_guide/pages/course_structure copy.adoc

@@ -0,0 +1,34 @@
+= Course Structure
+
+image::../qc-structure.jpg[]
+
+The structure of the course is organized as a hierarchy, so it's helpful to think of the content in terms of chapters, or modules, and then pages, or sections.
+
+At the top level (course), the antora.yml file defines the overall structure. It has the course title and the links to `nav.adoc` files in each module (aka chapter - they are the same thing here).
+
+[source]
+----
+name: course
+title: Course Title
+version: 1
+nav:
+- modules/ch1/nav.adoc
+- modules/ch2/nav.adoc
+- modules/ch3/nav.adoc
+----
+
+It may be clear at this point that we need a `modules` directory, with each module/chapter as a sub-directory. They do not need to be labeled ch1, ch2, etc, but their labels would need to appear in the above antora file.
+
+Each module/chapter directory should have a 'nav.adoc' file with the following syntax:
+
+[source]
+----
+* xref:index.adoc[]
+** xref:section1.adoc[]
+** xref:section2.adoc[]
+----
+
+This is the listing of the adoc files that actually contain the content. These should be placed in a `pages` directory. Any images that need to be referenced go into an `images` directory at the same level as `pages` and the 'nav.adoc' file referenced above. 
+
+See xref:references:asciidocqrg.adoc[Asciidoc quick reference guide] for help with drafting of your content.
+

modules/course_guide/pages/course_structure.adoc

@@ -1,34 +1,48 @@
-= Course Structure
+= Designing Memorable Enablement
+:navtitle: Enablement Design Guide
 
-image::../qc-structure.jpg[]
+== Introduction: From Architect to Educator
 
-The structure of the course is organized as a hierarchy, so it's helpful to think of the content in terms of chapters, or modules, and then pages, or sections.
+You are here because you are an elite technical expert. You design, build, and deploy complex architectures every day. However, building a highly effective learning experience requires a slightly different muscle. 
 
-At the top level (course), the antora.yml file defines the overall structure. It has the course title and the links to `nav.adoc` files in each module (aka chapter - they are the same thing here).
+It is easy to fall into the trap of simply writing down a list of commands and configurations. But a data dump is not a learning experience. If we want our peers to truly understand how to deploy Red Hat AI Factory with NVIDIA solutions at scale, we have to move beyond just *telling* them what to do. We must *show* them, challenge them, and share the context behind the keystrokes.
 
-[source]
-----
-name: course
-title: Course Title
-version: 1
-nav:
-- modules/ch1/nav.adoc
-- modules/ch2/nav.adoc
-- modules/ch3/nav.adoc
-----
+Here is your guide to building enablement that keeps learners engaged and makes the knowledge stick.
 
-It may be clear at this point that we need a `modules` directory, with each module/chapter as a sub-directory. They do not need to be labeled ch1, ch2, etc, but their labels would need to appear in the above antora file.
+== 1. Start with the "Why" and the "Aha!" Moment
 
-Each module/chapter directory should have a 'nav.adoc' file with the following syntax:
+Learners disengage when they don't understand why a specific task matters. Before you dive into the technical execution, frame the problem.
 
-[source]
-----
-* xref:index.adoc[]
-** xref:section1.adoc[]
-** xref:section2.adoc[]
-----
+* **Share the Context:** Briefly explain the business or technical challenge this blueprint solves. 
+* **Include the "Hard Knocks":** AI can generate code, but it doesn't have the scars of trial and error. Share what *didn't* work for you during your own learning journey. Explain the pitfalls you encountered and the "Aha!" moment that led to your ultimate solution.
+* **Keep the Human Element:** Write as if you are sitting next to a co-worker, explaining a new way to accomplish a task. Conversational, professional candor is far more engaging than dry textbook prose.
 
-This is the listing of the adoc files that actually contain the content. These should be placed in a `pages` directory. Any images that need to be referenced go into an `images` directory at the same level as `pages` and the 'nav.adoc' file referenced above. 
+== 2. Avoid the "Copy-Paste" Trap (Active vs. Passive Learning)
 
-See xref:references:asciidocqrg.adoc[Asciidoc quick reference guide] for help with drafting of your content.
+If a learner can complete your entire module just by mindlessly copying and pasting commands into a terminal, they haven't learned anything. You have built a script, not a course. 
 
+Force the learner to engage with the environment:
+
+* **Ask Questions:** Prompt them to run a command, observe the output, and ask them to verify a specific parameter before moving to the next step.
+* **Break Things Intentionally:** If you are building a *Break-Fix* scenario, give them a broken environment and a clear set of symptoms. Let them diagnose it like a puzzle rather than handing them the answer key upfront.
+* **Use the "How-To" Effectively:** For step-by-step *How-To* guides, ensure you emphasize active participation. Explain *what* the command is doing to the infrastructure before providing the code block.
+
+== 3. Manage the Cognitive Load
+
+Technical blueprints are heavy. If you present learners with a massive wall of text and code, their eyes will glaze over. Structure your content for scannability and flow.
+
+* **Chunk the Information:** Break complex workflows into smaller, digestible pages or sections. 
+* **Use formatting strategically:** Use bold text to emphasize key parameters. Use the AsciiDoc visual callouts (`NOTE:`, `IMPORTANT:`, `WARNING:`) to break up the visual monotony and draw attention to critical security or STIG requirements.
+* **Visualize the Architecture:** Do not explain a complex NVIDIA multi-node deployment with text alone. Use diagrams (placed in your `images/` folder) to anchor the learner's understanding of the topology before they touch the command line.
+
+== 4. The Anatomy of a Great Enablement Chapter
+
+When structuring a specific chapter or module in your repository, try following this proven arc:
+
+. **The Hook (The Problem):** Define the real-world scenario or customer pain point.
+. **The Strategy (The Concept):** Explain the architectural approach you are taking to solve it and *why* it is the best method.
+. **The Execution (The Lab):** Guide them through the hands-on deployment or troubleshooting steps. 
+. **The Verification (The Proof):** Show them how to test and validate that their deployment or fix was successful.
+. **The Takeaway:** Summarize the core lesson and how it applies to their daily interactions with customers.
+
+NOTE: Remember, your goal is to empower your colleagues. By shaping your raw knowledge into a structured, engaging instrument, you are building a community of capability around the Red Hat AI Factory.

modules/course_guide/pages/dev_spaces copy.adoc

@@ -0,0 +1,79 @@
+= Use Devspace (skip if using local system)
+
+Every Open Training course is developed in public GitHub repositories.
+In order to make development as easy as possible, we provide you with the option of using a Dev Spaces instance.
+If you're not familiar with this, just think of it as your normal IDE (VSCode in this case) running in the cloud.
+It has everything you should need to write asciidoc, render into a preview, and interact with GitHub to push and pull.
+
+:toc:
+
+== Set up or Access Dev Spaces Instance
+
+. After the GitHub repository is created for the course, you will see a `Developer Workspace` button in the README section of the repository.
++
+Click this button to launch the Dev Spaces instance.
++
+image::../click-devspace-button.png[]
+
+. When prompted, select the `Log in with OpenShift` button and use the credentials that you were provided.
++
+This is usually your Red Hat SSO credential.
++
+image::../click-login-with-openshift.png[]
+
+. Once you have successfully logged in, select the option to `Open the existing workspace` or `Switch to running workspace` if prompted.
++
+Ignore this step if not prompted for this option.
++
+image::../select-workspace-1.png[]
++
+image::../select-workspace-2.png[]
+
+. When the VSCode interface loads, click `Yes, I trust the authors`.
++
+image::../trust-authors.png[]
++
+NOTE: Why do I trust them?
+
+That is it!
+You are ready to start writing your content.
+The file and folder structure is already in place, so you just need to start filling in blanks and deleting files that you won't need.
+
+== Render content draft
+
+NOTE: Make your training content repository is initialized and the changes are committed by the training team before using it in the devspace.
+
+. Load your content repository in the devspace environment using the steps mentioned in FIXME
+. Click on the search bar for Workspace on top and click on Run Task option, then click devfile.
++
+image::../devspace-runtask.png[]
++
+. Click on `0-install` option and wait for it to finish.
+. Repeat the earlier step to select devfile and click on `1-watch` option this time.
+. Repeat the same steps and select `2-serve` option now.
+. Pop-up will be displayed at the bottom of the screen.
++
+image::../devspace-pop-up.png[]
+
+. Create `Open In New Tab` button.
+
+. On the next pop-up message: `Do you want VS Code - Open Source to open the external website?` click on `Open` button.
+
+. Rendered content will now be displayed in another tab.
+
+. You may continue with your content development in the `vscode` interface provided by devspace.
+
+. When you save your changes in the content files in devspace interface, the changes will be reflected in the rendered content url as soon as you refresh the url.
+
+See https://github.com/RedHatQuickCourses/course-starter-template/blob/main/DEVSPACE.md
+
+== Commit changes to GitHub
+
+FIXME
+
+. Step 1
+. Step 2
+
+== Next step
+
+Refer to the xref:section3.adoc[Quick course content format guide] for details on formatting your content layout.