When the enemy move between waypoints if a waypoint is too big he will stuck on it how can i solve it ?

The problem is if there are two waypoints and the enemy need to get to the second waypoint so he stuck in the first one and it's all shaking the enemy and it's taking him some time until he can pass the waypoint and continue to the target waypoint.

For example if it's cubes the waypoints if i set the cubes size to 0.1 or 0.5 or to 1 it's all fine. But if i set the cubes size to 10-20-30 so if there are two waypoints on same route and the enemy need to get to the second waypoint he can't pass the first one to get to the second one. He stuck on it.

 using System.Collections;
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
 using UnityStandardAssets.Characters.ThirdPerson;
 
 public class WayPoints : MonoBehaviour {
 
     public GameObject[] waypoints;
     public Transform target;
     public float moveSpeed = 10f;
     public float moveSpeed1 = 10f;
     public float slowDownSpeed = 3f;
     public float reverseSlowDownSpeed = 3f;
     public float rotationSpeed = 1f;
     private Transform myTransform;
     private int targetsIndex = 0;
     private Vector3 originalPosition;
     private GameObject[] robots;
 
     public Transform reverseTarget;
     private int reverseTargetsIndex = 0;
     private Vector3 reverseOriginalPosition;
 
     void Awake()
     {
         myTransform = transform;
     }
     // Use this for initialization
     void Start()
     {
         waypoints = GameObject.FindGameObjectsWithTag("ClonedObject");
         robots = GameObject.FindGameObjectsWithTag("Robots");
 
         AddColliderToWaypoints();
         originalPosition = robots[0].transform.position;
         reverseOriginalPosition = robots[1].transform.position;
     }
 
     // Update is called once per frame
     void Update()
     {
         if (MyCommands.walkbetweenwaypoints == true)
         {
             WayPointsAI();
             ReverseWayPointsAI();
         }
 
         DrawLinesInScene();
     }
 
     private void WayPointsAI()
     {
         if (targetsIndex == waypoints.Length)
             targetsIndex = 0;
         target = waypoints[targetsIndex].transform;
         float distance = Vector3.Distance(robots[0].transform.position, target.transform.position);
         robots[0].transform.rotation = Quaternion.Slerp(robots[0].transform.rotation, Quaternion.LookRotation(target.position - robots[0].transform.position), rotationSpeed * Time.deltaTime);
 
         //move towards the player
         if (distance < 30)
         {
             robots[0].transform.position += robots[0].transform.forward * slowDownSpeed * Time.deltaTime;
         }
         else
         {
             robots[0].transform.position += robots[0].transform.forward * moveSpeed * Time.deltaTime;
         }
         if (distance < target.transform.localScale.magnitude)
         {
             targetsIndex++;
         }
     }
 
     private void ReverseWayPointsAI()
     {
         if (reverseTargetsIndex == 0)
             reverseTargetsIndex = waypoints.Length -1;
         reverseTarget = waypoints[reverseTargetsIndex].transform;
         float distance = Vector3.Distance(robots[1].transform.position, reverseTarget.transform.position);
         robots[1].transform.rotation = Quaternion.Slerp(robots[1].transform.rotation, Quaternion.LookRotation(reverseTarget.position - robots[1].transform.position), rotationSpeed * Time.deltaTime);
 
         //move towards the player
         if (distance < 30)
         {
             robots[1].transform.position += robots[1].transform.forward * reverseSlowDownSpeed * Time.deltaTime;
         }
         else
         {
             robots[1].transform.position += robots[1].transform.forward * moveSpeed1 * Time.deltaTime;
         }
         if (distance < target.transform.localScale.magnitude)
         {
             reverseTargetsIndex--;
         }
     }
 
     void RandomWayPointsAI()
     {
         
     }
 
     void DrawLinesInScene()
     {
         // draw lines between each checkpoint //
         for (int i = 0; i < waypoints.Length - 1; i++)
         {
             Debug.DrawLine(waypoints[i].transform.position, waypoints[i + 1].transform.position, Color.blue);
         }
 
         // draw a line between the original transform start position 
         // and the current transform position //
         Debug.DrawLine(originalPosition, robots[0].transform.position, Color.red);
         Debug.DrawLine(reverseOriginalPosition, robots[1].transform.position, Color.red);
 
         // draw a line between current transform position and the next waypoint target
         // each time reached a waypoint.
         if (target != null)
             Debug.DrawLine(target.transform.position, robots[0].transform.position, Color.green);
         if (reverseTarget != null)
             Debug.DrawLine(reverseTarget.transform.position, robots[1].transform.position, Color.green);
     }
 
     void AddColliderToWaypoints()
     {
         foreach (GameObject go in waypoints)
         {
             SphereCollider sc = go.AddComponent<SphereCollider>() as SphereCollider;
             sc.isTrigger = true;
         }
     }
 }
 

I tried to solve it using magnitude but it didn't solve it. I tried before to use the target size / 2 but it didn't solve it either.

This is how i'm doing it now with magnitude

 if (distance < target.transform.localScale.magnitude)

But i'm not sure if this is the right way to solve it and it's not working good yet. Not solved the problem.

I want that if there are two waypoints on same line and he need to get to the second waypoint so he will go around the first waypoint. Instead he stuck on it's wall of the cube and then shaking stuttering and moving to the side then continue to the right waypoint.

And it's only happening when the waypoints(cubes) are very big.