How to update assigned vector variable in unity C#

I am creating a 2D game but I can't seem to be able to have the speed vector variable change if something happens.

I have a timer variable that counts down and when it hits 0 it is supposed to change the speed: speed.x += 100 and speed.y += 100 but it does not do anything. I know the countdown works because I have tested it with other functions.

 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
 
 /// <summary>
 /// Parallax scrolling script that should be assigned to a layer
 /// </summary>
 public class Scrolling : MonoBehaviour
 {
 
     public float timeLeft = 5.0f;
     /// <summary>
     /// Scrolling speed
     /// </summary>
     public Vector2 speed = new Vector2(10, 10);
 
     /// <summary>
     /// Moving direction
     /// </summary>
     public Vector2 direction = new Vector2(-1, 0);
 
     /// <summary>
     /// Movement should be applied to camera
     /// </summary>
     public bool isLinkedToCamera = false;
 
     /// <summary>
     /// 1 - Background is infinite
     /// </summary>
     public bool isLooping = false;
 
     /// <summary>
     /// 2 - List of children with a renderer.
     /// </summary>
     private List<Transform> backgroundPart;
 
     // 3 - Get all the children
     void Start()
     {
         // For infinite background only
         if (isLooping)
         {
             // Get all the children of the layer with a renderer
             backgroundPart = new List<Transform>();
 
             for (int i = 0; i < transform.childCount; i++)
             {
                 Transform child = transform.GetChild(i);
 
                 // Add only the visible children
                 if (child.renderer != null)
                 {
                     backgroundPart.Add(child);
                 }
             }
 
             // Sort by position.
             // Note: Get the children from left to right.
             // We would need to add a few conditions to handle
             // all the possible scrolling directions.
             backgroundPart = backgroundPart.OrderBy(
                 t => t.position.x
                 ).ToList();
         }
     }
 
     void Update()
     {
 
         //Timer
         timeLeft -= Time .deltaTime ;
 
         if (timeLeft <= 0.0f)
         {
             speed.x += 100;
             speed.y += 100;
         }
 
 
         // Movement
         Vector3 movement = new Vector3(
             speed.x * direction.x,
             speed.y * direction.y,
             0);
 
         movement *= Time.deltaTime;
         transform.Translate(movement);
 
         // Move the camera
         if (isLinkedToCamera)
         {
             Camera.main.transform.Translate(movement);
         }
 
         // 4 - Loop
         if (isLooping)
         {
             // Get the first object.
             // The list is ordered from left (x position) to right.
             Transform firstChild = backgroundPart.FirstOrDefault();
 
             if (firstChild != null)
             {
                 // Check if the child is already (partly) before the camera.
                 // We test the position first because the IsVisibleFrom
                 // method is a bit heavier to execute.
                 if (firstChild.position.x < Camera.main.transform.position.x)
                 {
                     // If the child is already on the left of the camera,
                     // we test if it's completely outside and needs to be
                     // recycled.
                     if (firstChild.renderer.IsVisibleFrom(Camera.main) == false)
                     {
                         // Get the last child position.
                         Transform lastChild = backgroundPart.LastOrDefault();
                         Vector3 lastPosition = lastChild.transform.position;
                         Vector3 lastSize = (lastChild.renderer.bounds.max - lastChild.renderer.bounds.min);
 
                         // Set the position of the recyled one to be AFTER
                         // the last child.
                         // Note: Only work for horizontal scrolling currently.
                         firstChild.position = new Vector3(lastPosition.x + lastSize.x, firstChild.position.y, firstChild.position.z);
 
                         // Set the recycled child to the last position
                         // of the backgroundPart list.
                         backgroundPart.Remove(firstChild);
                         backgroundPart.Add(firstChild);
                     }
                 }
             }
         }
     }
 }