Updated markdown errors with Claude's help.

Author: snvgglebear

docs/basics/java_basics.md

@@ -8,24 +8,26 @@ Learning What's What
 
 - Objects, variables, and classes (in Java) make up our programs. We define, modify, and use these variables and objects to make our programs run.
 - Programs use key words to define characteristics of variables or objects. Basic keywords:
-    - `#!java public` - an object accessible by other classes (files)
-    - `#!java private` - an object only accessible by its containing class (file).
-    - `#!java protected` - like private but can be seen by subclasses
-    - `#!java return` - value to return or give back after method execution (run). 
-    - `#!java void` - a method that returns no value
-    - `#!java null` - a value that means empty or nothing
-
-!!! Warning "IMPORTANT NOTE"
+    - `public` - an object accessible by other classes (files)
+    - `private` - an object only accessible by its containing class (file).
+    - `protected` - like private but can be seen by subclasses
+    - `return` - value to return or give back after method execution (run). 
+    - `void` - a method that returns no value
+    - `null` - a value that means empty or nothing
+
+!!! warning "IMPORTANT NOTE"
 	Java is case sensitive, meaning capitalization matters!
 ***
 
 ## Classes
 
 - Classes are the files that contain our programming
 - A program can be made up of one class but can also be made up of many classes
-    - All programs run a main class that can optionally load additional classes either directly or indirectly 
-    - !!! example
-    	main loads class1, class1 loads class2
+    - All programs run a main class that can optionally load additional classes either directly or indirectly
+
+    !!! example
+        main loads class1, class1 loads class2
+
 - Classes are made up of variables and methods and are often used to separate and organize your code.
 - Classes can also **call** (use) variables or methods of other classes if those have been set to public.
 
@@ -37,8 +39,9 @@ Learning What's What
     - They can be called again if the class is programmed to be unloaded (destroyed) and reloaded.
     - Calls to methods, and assignment of values, within the constructor will run as soon as the class is called (loaded) in the code.
     - The **new** operator creates an object of a type of class using a constructor
-    - !!! example
-    	classObject = new className();
+
+    !!! example
+        classObject = new className();
 
 ***
 
@@ -82,25 +85,28 @@ Learning What's What
 - Variables are assigned names and data types on creation
     - Names can be anything with the exception of pre-existing keywords such as `public` or `int`
 - Data types define what type of data is being stored in the variables:
-    - `#!java int` - integers (whole numbers)
-    - `#!java double` - double precision floating point (fractional/decimal values) 
-    - `#!java boolean` - true or false (true = 1 or false = 0) values.
-    - `#!java string` - text values contained in parentheses
-    - !!! Example "Example: `#!java int sum;`"
-    	A variable that can hold whole number values
-	- !!! Example "Example: `#!java boolean isFull = true;`"
-    	A variable can either hold a true or false value and is being assigned a true value
+    - `int` - integers (whole numbers)
+    - `double` - double precision floating point (fractional/decimal values)
+    - `boolean` - true or false (true = 1 or false = 0) values.
+    - `string` - text values contained in parentheses
+
+!!! example "Example: `int sum;`"
+    A variable that can hold whole number values
+
+!!! example "Example: `boolean isFull = true;`"
+	A variable can either hold a true or false value and is being assigned a true value
 
 ### Constants
 
 Most variables can have their values assigned or reassigned at any point elsewhere in your program. To avoid having a variable change its value during runtime you can make it a **constant**
 
-- In Java you can create constants using the `#!java static final` keywords together in front of the data type of the variable
-    - The static modifier causes the variable to be available without loading the class where it is defined. 
+- In Java you can create constants using the `static final` keywords together in front of the data type of the variable
+    - The static modifier causes the variable to be available without loading the class where it is defined.
     - The final modifier causes the variable to be unchangeable.
     - Java constants are normally declared in ALL CAPS. Words in Java constants are normally separated by underscores.
-    - !!! Example "Example: `#!java public static final double PI_VALUE = 3.14159;`"
-        A variable that cannot be modified during code run time.
+
+!!! example "Example: `public static final double PI_VALUE = 3.14159;`"
+    A variable that cannot be modified during code run time.
 
 ### Scope
 
@@ -171,9 +177,10 @@ Most variables can have their values assigned or reassigned at any point elsewhe
 - There are also many different conventions when programming, this ensures that programs are readable between different people.
 - A common naming convention:
     - Programming is often done in CamelCase or lowerCamelCase
-    - Instead of adding spaces, capitalize the first letter of each word 
-    - !!! example
-        ThreeMotorDrive, driveForward, setSpeed
+    - Instead of adding spaces, capitalize the first letter of each word
+
+!!! example
+    ThreeMotorDrive, driveForward, setSpeed
 
-!!! info  
+!!! info
     There are other naming conventions, but for this tutorial we will use the camel cases

docs/basics/wpilib.md

@@ -9,10 +9,10 @@ Making FRC Programming Easy
 - The WPI Robotics library (WPILib) is a set of software classes that interfaces with the hardware and software in your FRC RoboRIO.
     - There are classes to handle sensors, motor speed controllers, the driver station, and a number of other utility functions.
 - Documentation is available at <http://first.wpi.edu/FRC/roborio/release/docs/java>
-- WPILib adds those sensors and controllers as additional data types (like `#!java int` or `#!java double`) and classes.
+- WPILib adds those sensors and controllers as additional data types (like `int` or `double`) and classes.
 
-/// details | Examples  
-  		`Talon`, `Solenoid`, `Encoder`...
+??? example "Examples"
+    `Talon`, `Solenoid`, `Encoder`...
 
 ***
 
@@ -41,13 +41,14 @@ Making FRC Programming Easy
     - Some variables (parts) would be: **leftEye**, **rightEye**, **nose**, **leftEar**, **rightEar**.
     - Some example methods would be **closeEyes** or **openEyes** since these are things the dog are capable of.
         - These methods would use both the **leftEye** and **rightEye** and close them.
-    - /// details | example
-    	```java
-    	//This method closes the dog eyes
+
+    ??? example
+        ```java
+        //This method closes the dog eyes
         public void closeEyes(){
-    		leftEye.close();
-    		rightEye.close();
-    	```
+            leftEye.close();
+            rightEye.close();
+        ```
 - A robot example of a **Drivetrain** subsystem would have **leftMotor**, and **rightMotor** as variables and **setSpeed** as a method telling it how to set the speed of those motor controllers.
 - Having the **setSpeed** method tells our program that our **Drivetrain** subsystem can set its speed.
     - ??? example
@@ -68,48 +69,56 @@ Making FRC Programming Easy
     - A **command** is an action a **subsystem(s)** performs.
     - For example you may want your robot to drive full speed forward so you make a command class called **DriveForward**.
         - Since a robot uses a **Drivetrain** subsystem to control its motors, this command would call our previously created **setSpeed** method from that subsystem.
-- !!! Tip 
-	**Subsystems** define what the robot is made of and what it can do while **commands** actually tell the robot to do those things
+
+!!! tip
+    **Subsystems** define what the robot is made of and what it can do while **commands** actually tell the robot to do those things
+
 - Using a dog as an example we can tell the dog to blink by creating a **BlinkEyes** command
     - The command would call the method, **closeEyes()** then the method **openEyes()**
-- ??? example "BlinkEyes Command"
-  	```java
+
+??? example "BlinkEyes Command"
+    ```java
     //This command will continuously run the two methods in execute
     protected void execute() {
-      	dog.head.closeEyes();
-      	dog.head.openEyes();
+        dog.head.closeEyes();
+        dog.head.openEyes();
     }
-  	```
+    ```
+
 - A robot example of a **DriveForward** command would call (use) the **setSpeed** methods that we created in the **Drivetrain** subsystem
 - **DriveForward**, when executed, will tell our robot to drive forward using the **Drivetrain** subsystem
-- ??? example "DriveForward Command"
-  	```java
+
+??? example "DriveForward Command"
+    ```java
     //This command tells the robot to drive forward full speed
-	protected void initialize(){
-		robot.drivetrain.setSpeed(1.0);
-	}
-  	```
+    protected void initialize(){
+        robot.drivetrain.setSpeed(1.0);
+    }
+    ```
 
 #### Default Command Structure
 
 - The template for FRC commands actually come with some pre-defined methods that have special properties for FRC robots, they are:
-    - `#!java void initialize()` - Methods in here are called just before this Command runs the first time.
-    - `#!java void execute()` - Methods in here are called repeatedly when this Command is scheduled to run
-    - `#!java boolean isFinished()` - When this returns true, the Command stops running execute() 
-    - `#!java void end()` - Methods in here are called once after isFinished returns true
-    - `#!java void interrupted()` - Methods in here are called when another command which requires one or more of the same subsystems is scheduled to run
-- !!! Tip
-	It is good practice to call `end()` in `interrupted()`
+    - `void initialize()` - Methods in here are called just before this Command runs the first time.
+    - `void execute()` - Methods in here are called repeatedly when this Command is scheduled to run
+    - `boolean isFinished()` - When this returns true, the Command stops running execute()
+    - `void end()` - Methods in here are called once after isFinished returns true
+    - `void interrupted()` - Methods in here are called when another command which requires one or more of the same subsystems is scheduled to run
+
+!!! tip
+    It is good practice to call `end()` in `interrupted()`
 
 ***
 
 ### Overview of execution
 
-- In FRC programming our main class is **Robot.java** and all other classes (command files and subsystem files) must be loaded from **Robot.java** either directly or indirectly 
-    - !!! Example
-        **Robot.java** loads **RobotContainer.java**, **RobotContainer.java** loads **DriveForward.java**.
+- In FRC programming our main class is **Robot.java** and all other classes (command files and subsystem files) must be loaded from **Robot.java** either directly or indirectly
+
+!!! example
+    **Robot.java** loads **RobotContainer.java**, **RobotContainer.java** loads **DriveForward.java**.
+
 - All **subsystem** files must be added to **RobotContainer.java**.
-    - This loads our **subsystems** into the code and allow its public methods to be useable by other files such as commands later by typing `#!java RobotContainer.nameOfSubsystem.desiredMethod();`
+    - This loads our **subsystems** into the code and allow its public methods to be useable by other files such as commands later by typing `RobotContainer.nameOfSubsystem.desiredMethod();`
 
 ***
 
@@ -125,5 +134,5 @@ See [Default Project Contents](../programming/new_project.md#default-project-con
 - **Subsystems** define what the robot is made of and what it can do while **commands** actually tell the robot to do those things
 - All classes must directly or indirectly connect to **Robot.java**.
     - All **Subsystems** must be added to **RobotContainer.java** 
-- **RobotMap.java** holds port numbers and IDs accessible throughout the program by typing: `#!java RobotMap.NameOfMotor()`
+- **RobotMap.java** holds port numbers and IDs accessible throughout the program by typing: `RobotMap.NameOfMotor()`
 - **RobotContainer.java** contains our publicly accessible instances of our subsystems. It also connects our commands to physical controllers.

docs/code_examples/2026KitBotInline/RobotContainer.java

@@ -84,10 +84,12 @@ private void configureBindings() {
     // value). The X-axis is also inverted so a positive value (stick to the right)
     // results in clockwise rotation (front of the robot turning right). Both axes
     // are also scaled down so the rotation is more easily controllable.
+    // --8<-- [start: drive-config]
     driveSubsystem.setDefaultCommand(
         driveSubsystem.driveArcade(
             () -> -driverController.getLeftY() * DRIVE_SCALING,
             () -> -driverController.getRightX() * ROTATION_SCALING));
+    // --8<-- [end: drive-config]
   }
 
   /**

docs/code_examples/2026KitBotInline/commands/DriveArcadeCommand.java

@@ -0,0 +1,70 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.commands;
+
+import java.util.function.DoubleSupplier;
+
+import edu.wpi.first.wpilibj2.command.Command;
+import frc.robot.subsystems.CANDriveSubsystem;
+
+/**
+ * An example command that uses an arcade drive subsystem. This command demonstrates
+ * how to create a command that gets input from joystick axes and drives the robot.
+ */
+public class DriveArcadeCommand extends Command {
+  // --8<-- [start: class-variables]
+  private final DoubleSupplier xSpeed;
+  private final DoubleSupplier zRotation;
+  private final CANDriveSubsystem driveSubsystem;
+  // --8<-- [end: class-variables]
+
+  /**
+   * Creates a new DriveArcadeCommand.
+   *
+   * @param xSpeed the input for movement speed as a DoubleSupplier (a function that returns a double)
+   * @param zRotation the input for rotation speed as a DoubleSupplier
+   * @param driveSubsystem the subsystem that this command requires
+   */
+  // --8<-- [start: constructor-signature]
+  public DriveArcadeCommand(
+      DoubleSupplier xSpeed, DoubleSupplier zRotation, CANDriveSubsystem driveSubsystem) {
+    // --8<-- [end: constructor-signature]
+    // --8<-- [start: constructor-body]
+    this.xSpeed = xSpeed;
+    this.zRotation = zRotation;
+    this.driveSubsystem = driveSubsystem;
+    // Use addRequirements() here to declare subsystem dependencies.
+    addRequirements(driveSubsystem);
+    // --8<-- [end: constructor-body]
+  }
+
+  // Called when the command is initially scheduled.
+  @Override
+  public void initialize() {}
+
+  // Called every time the scheduler runs while the command is scheduled.
+  // --8<-- [start: execute-method]
+  @Override
+  public void execute() {
+    driveSubsystem.arcadeDrive(xSpeed.getAsDouble(), zRotation.getAsDouble());
+  }
+  // --8<-- [end: execute-method]
+
+  // Called once the command ends or is interrupted.
+  // --8<-- [start: end-method]
+  @Override
+  public void end(boolean interrupted) {
+    driveSubsystem.arcadeDrive(0, 0);
+  }
+  // --8<-- [end: end-method]
+
+  // Returns true when the command should end.
+  // --8<-- [start: is-finished-method]
+  @Override
+  public boolean isFinished() {
+    return false; // This command never finishes on its own; it runs continuously
+  }
+  // --8<-- [end: is-finished-method]
+}

docs/code_examples/2026KitBotInline/subsystems/CANDriveSubsystem.java

@@ -27,7 +27,10 @@ public class CANDriveSubsystem extends SubsystemBase {
   private final SparkMax rightFollower;
 
   // --8<-- [end: motors]
+
+  // --8<-- [start: differential-drive-variable]
   private final DifferentialDrive drive;
+  // --8<-- [end: differential-drive-variable]
 
   // --8<-- [start: constructor]
 
@@ -44,35 +47,45 @@ public CANDriveSubsystem() {
     // Set can timeout. Because this project only sets parameters once on
     // construction, the timeout can be long without blocking robot operation. Code
     // which sets or gets parameters during operation may need a shorter timeout.
+    // --8<-- [start: can-timeout]
     leftLeader.setCANTimeout(250);
     rightLeader.setCANTimeout(250);
     leftFollower.setCANTimeout(250);
     rightFollower.setCANTimeout(250);
+    // --8<-- [end: can-timeout]
 
     // Create the configuration to apply to motors. Voltage compensation
     // helps the robot perform more similarly on different
     // battery voltages (at the cost of a little bit of top speed on a fully charged
     // battery). The current limit helps prevent tripping
     // breakers.
+    // --8<-- [start: voltage-compensation]
     SparkMaxConfig config = new SparkMaxConfig();
     config.voltageCompensation(12);
     config.smartCurrentLimit(DRIVE_MOTOR_CURRENT_LIMIT);
+    // --8<-- [end: voltage-compensation]
 
     // Set configuration to follow each leader and then apply it to corresponding
     // follower. Resetting in case a new controller is swapped
     // in and persisting in case of a controller reset due to breaker trip
+    // --8<-- [start: follower-config]
     config.follow(leftLeader);
     leftFollower.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
     config.follow(rightLeader);
     rightFollower.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
+    // --8<-- [end: follower-config]
 
     // Remove following, then apply config to right leader
+    // --8<-- [start: right-leader-config]
     config.disableFollowerMode();
     rightLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
+    // --8<-- [end: right-leader-config]
     // Set config to inverted and then apply to left leader. Set Left side inverted
     // so that postive values drive both sides forward
+    // --8<-- [start: left-inversion]
     config.inverted(true);
     leftLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
+    // --8<-- [end: left-inversion]
   }
 
   // --8<-- [end: constructor]
@@ -82,8 +95,10 @@ public void periodic() {
   }
 
   // Command factory to create command to drive the robot with joystick inputs.
+  // --8<-- [start: drive-arcade-method]
   public Command driveArcade(DoubleSupplier xSpeed, DoubleSupplier zRotation) {
     return this.run(
         () -> drive.arcadeDrive(xSpeed.getAsDouble(), zRotation.getAsDouble()));
   }
+  // --8<-- [end: drive-arcade-method]
 }