diff --git a/internal/board/board.go b/internal/board/board.go
index b7e8874..523905b 100644
--- a/internal/board/board.go
+++ b/internal/board/board.go
@@ -212,7 +212,7 @@ func (b *Board) RepositionStatus(currentIndex, targetIndex int) error {
 		return fmt.Errorf("unable to get the list of statuses; %w", err)
 	}
 
-	statuses = moveAndShuffle(statuses, currentIndex, targetIndex)
+	statuses = shuffle(statuses, currentIndex, targetIndex)
 
 	if err := b.normaliseStatusesPositionValues(statuses); err != nil {
 		return fmt.Errorf("unable to normalise the statuses position values; %w", err)
diff --git a/internal/board/shuffle.go b/internal/board/shuffle.go
index 042d781..9e57124 100644
--- a/internal/board/shuffle.go
+++ b/internal/board/shuffle.go
@@ -1,47 +1,26 @@
 package board
 
-// moveAndShuffle creates a new list where the element specified at the index of the current
-// position is moved to the index of the target position. Elements within the range of the
-// old and new positions will then shuffle forwards or backwards in the list depending on the
-// direction of the move.
+// shuffle takes a list of Statuses and swaps its position with the Status closer to its desired
+// position until it reaches it.
+//
 // This is currently used to move specified columns forwards or backwards on the Kanban board.
 // When a column changes position the other columns shuffle forward or backwards as required.
-func moveAndShuffle(input []Status, oldIndex, newIndex int) []Status {
+func shuffle(list []Status, oldIndex, newIndex int) []Status {
 	if newIndex == oldIndex {
-		return input
+		return list
 	}
 
-	output := make([]Status, len(input))
-
-	// copy the original slice and assign the target element to the
-	// new index.
-	copy(output, input)
-
-	output[newIndex] = input[oldIndex]
-
-	// shuffle the elements in range down the slice if the target element moves
-	// up the list.
 	if newIndex < oldIndex {
-		for index := newIndex; index <= oldIndex; index++ {
-			if index == oldIndex {
-				continue
-			}
-
-			output[index+1] = input[index]
+		for i := oldIndex; i > newIndex; i-- {
+			list[i], list[i-1] = list[i-1], list[i]
 		}
 
-		return output
+		return list
 	}
 
-	// shuffle the elements in range up the slice if the target element moves
-	// down the list.
-	for index := oldIndex; index <= newIndex; index++ {
-		if index == oldIndex {
-			continue
-		}
-
-		output[index-1] = input[index]
+	for i := oldIndex; i < newIndex; i++ {
+		list[i], list[i+1] = list[i+1], list[i]
 	}
 
-	return output
+	return list
 }