diff --git a/curriculum/challenges/english/blocks/lecture-working-with-common-array-methods/6732b28eeadda1158cdbff7b.md b/curriculum/challenges/english/blocks/lecture-working-with-common-array-methods/6732b28eeadda1158cdbff7b.md
index ec90375a2b1..5bd1ec4e69d 100644
--- a/curriculum/challenges/english/blocks/lecture-working-with-common-array-methods/6732b28eeadda1158cdbff7b.md
+++ b/curriculum/challenges/english/blocks/lecture-working-with-common-array-methods/6732b28eeadda1158cdbff7b.md
@@ -5,50 +5,66 @@ challengeType: 19
 dashedName: how-can-you-check-if-an-array-contains-a-certain-value
 ---
 
-# --description--
+# --interactive--
 
 In JavaScript, the `includes()` method is a simple and efficient way to check if an array contains a specific value. This method returns a boolean value: `true` if the array contains the specified element, and `false` otherwise. 
 
 The `includes()` method is particularly useful when you need to quickly verify the presence of an element in an array without needing to know its exact position. Let's start with an example of how to use the `includes()` method:
 
+:::interactive_editor
+
 ```js
 let fruits = ["apple", "banana", "orange", "mango"];
 console.log(fruits.includes("banana")); // true
 console.log(fruits.includes("grape"));  // false
 ```
 
+:::
+
 In this example, we have an array of fruits. We use the `includes()` method to check if `banana` is in the array. It returns `true` because `banana` is indeed present. We then check for `grape`, which returns `false` because it's not in the array.
 
 The `includes()` method is case-sensitive when dealing with strings. This means that `Banana` with a capital B and `banana` with all lowercase letters are considered different values. Here's an example that illustrates this:
 
+:::interactive_editor
+
 ```js
 let fruits = ["apple", "banana", "orange"];
 console.log(fruits.includes("banana")); // true
 console.log(fruits.includes("Banana")); // false
 ```
 
+:::
+
 In this case, `banana` (all in lowercase) is found in the array, but `Banana` (with the first letter capitalized) is not, so the second `includes()` call returns `false`.
 
 The `includes()` method can also accept an optional second parameter that specifies the position in the array to start the search. This is useful if you want to check for an element's presence in a specific part of the array. Here's how you can use this feature:
 
+:::interactive_editor
+
 ```js
 let numbers = [10, 20, 30, 40, 50, 30, 60];
 console.log(numbers.includes(30, 3)); // true
 console.log(numbers.includes(30, 4)); // true
 ```
 
+:::
+
 For the first `console.log`, we are looking for the number `30` starting at index `3`. In this case, there is a number `30` that appears after index `3`, so the `includes()` method returns `true`. 
 
 The same is true for the second `console.log`. We are looking for the number `30` starting at index `4`. Since the number `30` does appear after that index, then it will return `true`. 
 
 It's worth noting that `includes()` uses the strict equality comparison (`===`), which means it can distinguish between different types. For example:
 
+:::interactive_editor
+
 ```js
 let mixedArray = [1, "2", 3, "4", 5];
 console.log(mixedArray.includes(2));  // false
 console.log(mixedArray.includes("2")); // true
 ```
 
+:::
+
 In this case, the number `2` and the string `"2"` are considered different data types. So, the first `console.log` will return `false`, while the second `console.log` will return `true`.
 
 The `includes()` method is a powerful tool for checking the presence of elements in arrays. It's simple to use, efficient, and can save you from writing more complex loops or conditions to search through arrays. Whether you're working with strings, numbers, or mixed data types, `includes()` provides a straightforward way to verify if a value exists in your array.