Fixed a bunch more formatting errors in the Markdown and code snippets.

Author: snvgglebear

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep:*)"
+    ]
+  }
+}

.devcontainer/devcontainer.json

@@ -11,6 +11,7 @@
 	"postCreateCommand": [
 		"pip3 install --user -r requirements.txt",
 		"pip3 install --user first-agentic-csa"
+		"curl -fsSL https://claude.ai/install.sh | bash"
 	],
 	"customizations": {
 		"vscode": {

docs/code_examples/2026KitBotInline/Constants.java

@@ -15,7 +15,7 @@
  * wherever the constants are needed, to reduce verbosity.
  */
 public final class Constants {
-  // --8<-- [start: constants]
+  // --8<-- [start:constants]
   public static final class DriveConstants {
     // Motor controller IDs for drivetrain motors
     public static final int LEFT_LEADER_ID = 1;
@@ -27,7 +27,7 @@ public static final class DriveConstants {
     // likelihood of tripping breakers or damaging CIM motors
     public static final int DRIVE_MOTOR_CURRENT_LIMIT = 60;
   }
-  //--8<-- [end: constants]
+  //--8<-- [end:constants]
 
   public static final class FuelConstants {
     // Motor controller IDs for Fuel Mechanism motors

docs/code_examples/2026KitBotInline/RobotContainer.java

@@ -84,12 +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]
+    // --8<-- [start:drive-config]
     driveSubsystem.setDefaultCommand(
         driveSubsystem.driveArcade(
             () -> -driverController.getLeftY() * DRIVE_SCALING,
             () -> -driverController.getRightX() * ROTATION_SCALING));
-    // --8<-- [end: drive-config]
+    // --8<-- [end:drive-config]
   }
 
   /**

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

@@ -14,11 +14,11 @@
  * how to create a command that gets input from joystick axes and drives the robot.
  */
 public class DriveArcadeCommand extends Command {
-  // --8<-- [start: class-variables]
+  // --8<-- [start:class-variables]
   private final DoubleSupplier xSpeed;
   private final DoubleSupplier zRotation;
   private final CANDriveSubsystem driveSubsystem;
-  // --8<-- [end: class-variables]
+  // --8<-- [end:class-variables]
 
   /**
    * Creates a new DriveArcadeCommand.
@@ -27,44 +27,44 @@ public class DriveArcadeCommand extends Command {
    * @param zRotation the input for rotation speed as a DoubleSupplier
    * @param driveSubsystem the subsystem that this command requires
    */
-  // --8<-- [start: constructor-signature]
+  // --8<-- [start:constructor-signature]
   public DriveArcadeCommand(
       DoubleSupplier xSpeed, DoubleSupplier zRotation, CANDriveSubsystem driveSubsystem) {
-    // --8<-- [end: constructor-signature]
-    // --8<-- [start: constructor-body]
+    // --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]
+    // --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]
+  // --8<-- [start:execute-method]
   @Override
   public void execute() {
     driveSubsystem.arcadeDrive(xSpeed.getAsDouble(), zRotation.getAsDouble());
   }
-  // --8<-- [end: execute-method]
+  // --8<-- [end:execute-method]
 
   // Called once the command ends or is interrupted.
-  // --8<-- [start: end-method]
+  // --8<-- [start:end-method]
   @Override
   public void end(boolean interrupted) {
     driveSubsystem.arcadeDrive(0, 0);
   }
-  // --8<-- [end: end-method]
+  // --8<-- [end:end-method]
 
   // Returns true when the command should end.
-  // --8<-- [start: is-finished-method]
+  // --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]
+  // --8<-- [end:is-finished-method]
 }

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

@@ -20,19 +20,19 @@
 import static frc.robot.Constants.DriveConstants.*;
 
 public class CANDriveSubsystem extends SubsystemBase {
-  // --8<-- [start: motors]
+  // --8<-- [start:motors]
   private final SparkMax leftLeader;
   private final SparkMax leftFollower;
   private final SparkMax rightLeader;
   private final SparkMax rightFollower;
 
-  // --8<-- [end: motors]
+  // --8<-- [end:motors]
 
-  // --8<-- [start: differential-drive-variable]
+  // --8<-- [start:differential-drive-variable]
   private final DifferentialDrive drive;
-  // --8<-- [end: differential-drive-variable]
+  // --8<-- [end:differential-drive-variable]
 
-  // --8<-- [start: constructor]
+  // --8<-- [start:constructor]
 
   public CANDriveSubsystem() {
     // create brushed motors for drive
@@ -47,58 +47,58 @@ 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]
+    // --8<-- [start:can-timeout]
     leftLeader.setCANTimeout(250);
     rightLeader.setCANTimeout(250);
     leftFollower.setCANTimeout(250);
     rightFollower.setCANTimeout(250);
-    // --8<-- [end: can-timeout]
+    // --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]
+    // --8<-- [start:voltage-compensation]
     SparkMaxConfig config = new SparkMaxConfig();
     config.voltageCompensation(12);
     config.smartCurrentLimit(DRIVE_MOTOR_CURRENT_LIMIT);
-    // --8<-- [end: voltage-compensation]
+    // --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]
+    // --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]
+    // --8<-- [end:follower-config]
 
     // Remove following, then apply config to right leader
-    // --8<-- [start: right-leader-config]
+    // --8<-- [start:right-leader-config]
     config.disableFollowerMode();
     rightLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
-    // --8<-- [end: right-leader-config]
+    // --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]
+    // --8<-- [start:left-inversion]
     config.inverted(true);
     leftLeader.configure(config, ResetMode.kResetSafeParameters, PersistMode.kPersistParameters);
-    // --8<-- [end: left-inversion]
+    // --8<-- [end:left-inversion]
   }
 
-  // --8<-- [end: constructor]
+  // --8<-- [end:constructor]
 
   @Override
   public void periodic() {
   }
 
   // Command factory to create command to drive the robot with joystick inputs.
-  // --8<-- [start: drive-arcade-method]
+  // --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]
+  // --8<-- [end:drive-arcade-method]
 }

docs/programming/AKitStructureReference.md

@@ -1,9 +1,3 @@
----
-title: AdvantageKit Reference
-layout: default
-nav_order: 11
-parent: architecture
----
 # AdvantageKit Code Structure Reference
 
 This document contains a quick reference for how we structure our code.
@@ -114,7 +108,7 @@ We can add all of these values into our `IntakeIOInputs` class.
 Finally, add a `updateInputs(IntakeIOInputs inputs)` method that our `IOImplementation`s can call to record these values.
 Our `IntakeIO` file should look something like this now:
 
-```Java
+```java
 // Imports go here
 
 public interface IntakeIO {
@@ -157,7 +151,7 @@ This will contain all of the hardware we want to interact with on the real robot
 First, we will need to define the hardware we want to use.
 In this case, they will be two `TalonFX`s.
 
-```Java
+```java
 private final TalonFX pivot = new TalonFX(IntakeSubsystem.PIVOT_MOTOR_ID);
 private final TalonFX roller = new TalonFX(IntakeSubsystem.ROLLER_MOTOR_ID);
 ```
@@ -168,7 +162,7 @@ For the sake of brevity, I won't cover that in detail here. *MAKE SUBSYSTEM WALK
 
 In the end you should have something like:
 
-```Java
+```java
 public class IntakeIOReal implements IntakeIO {
     private final TalonFX pivot = new TalonFX(IntakeSubsystem.PIVOT_MOTOR_ID);
     private final TalonFX roller = new TalonFX(IntakeSubsystem.ROLLER_MOTOR_ID);
@@ -213,7 +207,7 @@ It will also contain Command factories to allow the rest of our code to interfac
 
 Add the io and io inputs to the class:
 
-```Java
+```java
 // Snip imports
 
 public class IntakeSubsystem extends SubsystemBase {
@@ -229,7 +223,7 @@ public class IntakeSubsystem extends SubsystemBase {
 
 Then we can add a few Command factories to control the subsystem:
 
-```Java
+```java
 public Command intake(double volts) {
     return Commands.run(() -> {
         io.setAngle(INTAKE_ANGLE);
@@ -247,7 +241,7 @@ public Command stop() {
 
 Finally, let's add our `periodic()` method to update and log our inputs.
 
-```Java
+```java
 @Override
 public void periodic() {
     io.updateInputs();
@@ -258,7 +252,7 @@ public void periodic() {
 
 Overall, `IntakeSubsystem` should roughly look like:
 
-```Java
+```java
 // Snip imports
 
 public class IntakeSubsystem extends SubsystemBase {

docs/programming/AdvantageKit.md

@@ -53,9 +53,9 @@ While this does require some additional effort to write subsystems, it also make
 
 ### Exercises
 
-- Follow this [tutorial](2.8_KitbotAKitRefactor.md) to add AdvantageKit to your kitbot code.
+- Follow this tutorial to add AdvantageKit to your kitbot code. *(coming soon)*
 
 ### Notes
 
-- See the [AdvantageKit Structure Reference](2.7_AKitStructureReference.md) article for more on the IO layer structure
+- See the [AdvantageKit Structure Reference](AKitStructureReference.md) article for more on the IO layer structure
 - [Here](https://drive.google.com/drive/folders/1qNMZ7aYOGI31dQNAwt7rhFo97NR7mxtr) are some logs from our 2023-2024 season

docs/programming/autonomous.md

@@ -35,15 +35,15 @@ In this section we will be going over:
 
 !!! summary ""
     **2)** Before the constructor create a **double** called **distance**
-	```Java
+	```java
 		private Double distance;
 	```
 
     - We will use this to tell the command to finish when the robot drives the inputted distance
 
 	**3)** Also create a **Timer** called `runtime`. 
 	 
-	```Java
+	```java
 		private Time runTime;
 	```