diff --git a/modules/10-basics/10-hello-world/description.es.yml b/modules/10-basics/10-hello-world/description.es.yml
index 0fbcd4f..98b8c99 100644
--- a/modules/10-basics/10-hello-world/description.es.yml
+++ b/modules/10-basics/10-hello-world/description.es.yml
@@ -18,8 +18,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-hello-world
-
   El texto *¡Hola, Mundo!* aparecerá en la pantalla gracias al comando `System.out.println()`, donde `println()` es una abreviatura de la expresión en inglés *print line*. Este comando muestra en la pantalla el valor especificado entre paréntesis `("¡Hola, Mundo!")`, en este caso, una cadena de texto. La cadena de texto se encierra entre comillas dobles `""`. Si no se hace esto, el compilador mostrará un error de sintaxis:
 
   ```bash
diff --git a/modules/10-basics/10-hello-world/es/README.md b/modules/10-basics/10-hello-world/es/README.md
index 990fb5a..9a4e880 100644
--- a/modules/10-basics/10-hello-world/es/README.md
+++ b/modules/10-basics/10-hello-world/es/README.md
@@ -14,8 +14,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-hello-world
-
 El texto *¡Hola, Mundo!* aparecerá en la pantalla gracias al comando `System.out.println()`, donde `println()` es una abreviatura de la expresión en inglés *print line*. Este comando muestra en la pantalla el valor especificado entre paréntesis `("¡Hola, Mundo!")`, en este caso, una cadena de texto. La cadena de texto se encierra entre comillas dobles `""`. Si no se hace esto, el compilador mostrará un error de sintaxis:
 
 ```bash
diff --git a/modules/10-basics/10-hello-world/ru/README.md b/modules/10-basics/10-hello-world/ru/README.md
index 26496f9..18eb1b1 100644
--- a/modules/10-basics/10-hello-world/ru/README.md
+++ b/modules/10-basics/10-hello-world/ru/README.md
@@ -14,8 +14,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-hello-world
-
 Текст *Hello, World!* появится на экране благодаря команде `System.out.println()`, где `println()` — это сокращение от английского *print line*. Она выводит на экран значение, указанное в скобках `("Hello, World!")` — в данном случае строку. Сама строка обрамляется двойными кавычками `""`. Если этого не сделать, то компилятор укажет на синтаксическую ошибку:
 
 ```bash
diff --git a/modules/20-arithmetics/50-priority/description.es.yml b/modules/20-arithmetics/50-priority/description.es.yml
index ba17942..9447a13 100644
--- a/modules/20-arithmetics/50-priority/description.es.yml
+++ b/modules/20-arithmetics/50-priority/description.es.yml
@@ -39,8 +39,6 @@ theory: |
 
   Recuerda: el código se escribe para las personas, porque las personas lo leerán, y las máquinas solo lo ejecutarán. Para las máquinas, no hay código "más" o "menos" comprensible, independientemente de si el código es correcto o no.
 
-  https://replit.com/@hexlet/java-basics-arithmetics
-
 instructions: |
 
   Dada la expresión `70 * 3 + 4 / 8 + 2`.
diff --git a/modules/20-arithmetics/50-priority/en/README.md b/modules/20-arithmetics/50-priority/en/README.md
index fafadee..84744c9 100644
--- a/modules/20-arithmetics/50-priority/en/README.md
+++ b/modules/20-arithmetics/50-priority/en/README.md
@@ -30,5 +30,3 @@ System.out.println(((8 / 2) + 5) - (-3 / 2)); // => 11
 ```
 
 Remember: code is for people, because it'll be read by people, and machines will only execute it. The only thing that matters for the machines is the correctness of code. They don't distinguish between "clear" or "confusing".
-
-https://replit.com/@hexlet/java-basics-arithmetics
diff --git a/modules/20-arithmetics/50-priority/es/README.md b/modules/20-arithmetics/50-priority/es/README.md
index 199af9f..f6f116b 100644
--- a/modules/20-arithmetics/50-priority/es/README.md
+++ b/modules/20-arithmetics/50-priority/es/README.md
@@ -34,5 +34,3 @@ System.out.println(((8 / 2) + 5) - (-4 / 2)); // => 11
 ```
 
 Recuerda: el código se escribe para las personas, porque las personas lo leerán, y las máquinas solo lo ejecutarán. Para las máquinas, no hay código "más" o "menos" comprensible, independientemente de si el código es correcto o no.
-
-https://replit.com/@hexlet/java-basics-arithmetics
diff --git a/modules/20-arithmetics/50-priority/ru/README.md b/modules/20-arithmetics/50-priority/ru/README.md
index 22ad28a..ab197fc 100644
--- a/modules/20-arithmetics/50-priority/ru/README.md
+++ b/modules/20-arithmetics/50-priority/ru/README.md
@@ -34,5 +34,3 @@ System.out.println(((8 / 2) + 5) - (-4 / 2)); // => 11
 ```
 
 Запомните: код пишется для людей, потому что код будут читать люди, а машины будут только исполнять его. Для машин нет «более» понятного или «менее» понятного кода, независимо от того, является ли код корректным или нет.
-
-https://replit.com/@hexlet/java-basics-arithmetics
diff --git a/modules/25-strings/20-strings-concatenation/description.es.yml b/modules/25-strings/20-strings-concatenation/description.es.yml
index 86cd935..bb4ffb9 100644
--- a/modules/25-strings/20-strings-concatenation/description.es.yml
+++ b/modules/25-strings/20-strings-concatenation/description.es.yml
@@ -41,8 +41,6 @@ theory: |
   System.out.println("King's  " + "  Landing"); // => King's    Landing
   ```
 
-  https://replit.com/@hexlet/java-basics-strings#Main.java
-
 instructions: |
 
   Utilizando `System.out.println()`, realiza la concatenación de palabras y muestra en la pantalla la siguiente frase:
diff --git a/modules/25-strings/20-strings-concatenation/en/README.md b/modules/25-strings/20-strings-concatenation/en/README.md
index 9014b5e..8135a21 100644
--- a/modules/25-strings/20-strings-concatenation/en/README.md
+++ b/modules/25-strings/20-strings-concatenation/en/README.md
@@ -46,5 +46,3 @@ System.out.print("King's " + " Landing");   // => King's  Landing
 
 System.out.print("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings
diff --git a/modules/25-strings/20-strings-concatenation/es/README.md b/modules/25-strings/20-strings-concatenation/es/README.md
index add2c34..e7dc00c 100644
--- a/modules/25-strings/20-strings-concatenation/es/README.md
+++ b/modules/25-strings/20-strings-concatenation/es/README.md
@@ -36,5 +36,3 @@ Un espacio es simplemente un símbolo más, al igual que los demás. Cuantos má
 System.out.println("King's " + " Landing");   // => King's  Landing
 System.out.println("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings#Main.java
diff --git a/modules/25-strings/20-strings-concatenation/ru/README.md b/modules/25-strings/20-strings-concatenation/ru/README.md
index 18f050c..ff8430c 100644
--- a/modules/25-strings/20-strings-concatenation/ru/README.md
+++ b/modules/25-strings/20-strings-concatenation/ru/README.md
@@ -36,5 +36,3 @@ System.out.println("King's" + " " + "Landing"); //  => King's Landing
 System.out.println("King's " + " Landing");   // => King's  Landing
 System.out.println("King's  " + "  Landing"); // => King's    Landing
 ```
-
-https://replit.com/@hexlet/java-basics-strings#Main.java
diff --git a/modules/30-variables/10-definition/description.es.yml b/modules/30-variables/10-definition/description.es.yml
index d8def01..85b5222 100644
--- a/modules/30-variables/10-definition/description.es.yml
+++ b/modules/30-variables/10-definition/description.es.yml
@@ -47,8 +47,6 @@ theory: |
   ¡Madre!
   </pre>
 
-  https://replit.com/@hexlet/java-basics-variables-1
-
   Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.
 
 instructions: |
diff --git a/modules/30-variables/10-definition/en/README.md b/modules/30-variables/10-definition/en/README.md
index 65539c7..e425a49 100644
--- a/modules/30-variables/10-definition/en/README.md
+++ b/modules/30-variables/10-definition/en/README.md
@@ -23,8 +23,6 @@ When the variable is created, you can start using it. It is substituted in those
   Father!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 For the name of the variable, any set of valid characters is used, which include letters of the English alphabet, numbers and the underscore character `_`. In this case, the number can not be put at the beginning. Variable names are case-sensitive, that is, the name `hello` and the name `heLLo` are two different names, and therefore two variables.
 
 The number of variables created is not limited in any way; large programs contain tens and hundreds of thousands of variable names:
diff --git a/modules/30-variables/10-definition/es/README.md b/modules/30-variables/10-definition/es/README.md
index f66c466..fc500d9 100644
--- a/modules/30-variables/10-definition/es/README.md
+++ b/modules/30-variables/10-definition/es/README.md
@@ -42,6 +42,4 @@ System.out.println(greeting2);
 ¡Madre!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 Para facilitar el análisis del programa, se recomienda crear variables lo más cerca posible del lugar donde se utilizan.
diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md
index a001e2e..de59d9e 100644
--- a/modules/30-variables/10-definition/ru/README.md
+++ b/modules/30-variables/10-definition/ru/README.md
@@ -42,6 +42,4 @@ Mother!
 Mother!
 </pre>
 
-https://replit.com/@hexlet/java-basics-variables-1
-
 Для удобства анализа программы переменные принято создавать как можно ближе к тому месту, где они используются.
diff --git a/modules/30-variables/12-change/description.es.yml b/modules/30-variables/12-change/description.es.yml
index f3ee9ed..8f47318 100644
--- a/modules/30-variables/12-change/description.es.yml
+++ b/modules/30-variables/12-change/description.es.yml
@@ -15,8 +15,6 @@ theory: |
   System.out.println(saludo);
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-2
-
   Java es un lenguaje de programación de tipado estático. Esto significa que el tipo de una variable se establece al definirla y no cambia después.
 
   En el ejemplo anterior, asignamos una cadena de texto al crear la variable. El compilador recuerda el tipo y verifica todos los cambios posteriores en la variable. Si intentamos asignar un número a esta misma variable, obtendremos el siguiente error:
diff --git a/modules/30-variables/12-change/en/README.md b/modules/30-variables/12-change/en/README.md
index 5ffdec9..0e09b8f 100644
--- a/modules/30-variables/12-change/en/README.md
+++ b/modules/30-variables/12-change/en/README.md
@@ -11,8 +11,6 @@ System.out.print(greeting);
 System.out.print(greeting);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 The name remains the same, but inside the other data. It should be noted that when changing variables, the type of data contained in them cannot change (this is not quite the case for object-oriented programming, but for the time being we will not go into details). If a variable was assigned a string, then when compiling this assignment — even before the program was started — java associates the data type “string” with this variable, and knows that there will always be only strings, and will not let it put something else in it.
 
 Variables are powerful, and at the same time dangerous thing. One can never be exactly sure what is written inside it without analyzing the code that is in front of the variable. This is exactly what the developers are doing during debugging, when they are trying to figure out why the program is not working or is not working as intended.
diff --git a/modules/30-variables/12-change/es/README.md b/modules/30-variables/12-change/es/README.md
index 37887c3..bc80a9d 100644
--- a/modules/30-variables/12-change/es/README.md
+++ b/modules/30-variables/12-change/es/README.md
@@ -10,8 +10,6 @@ System.out.println(saludo);
 System.out.println(saludo);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 Java es un lenguaje de programación de tipado estático. Esto significa que el tipo de una variable se establece al definirla y no cambia después.
 
 En el ejemplo anterior, asignamos una cadena de texto al crear la variable. El compilador recuerda el tipo y verifica todos los cambios posteriores en la variable. Si intentamos asignar un número a esta misma variable, obtendremos el siguiente error:
diff --git a/modules/30-variables/12-change/ru/README.md b/modules/30-variables/12-change/ru/README.md
index 4c3287d..4690d4e 100644
--- a/modules/30-variables/12-change/ru/README.md
+++ b/modules/30-variables/12-change/ru/README.md
@@ -10,8 +10,6 @@ System.out.println(greeting);
 System.out.println(greeting);
 ```
 
-https://replit.com/@hexlet/java-basics-variables-2
-
 Java — статически типизированный язык. Это значит, что тип переменной задается при определении и больше не меняется.
 
 В примере выше мы присвоили строку при создании переменной. Компилятор запоминает тип и проверяет все последующие изменения переменной. Если попробовать этой же переменной присвоить число, то мы получим следующую ошибку:
diff --git a/modules/30-variables/15-variable-expressions/description.es.yml b/modules/30-variables/15-variable-expressions/description.es.yml
index d415074..add4288 100644
--- a/modules/30-variables/15-variable-expressions/description.es.yml
+++ b/modules/30-variables/15-variable-expressions/description.es.yml
@@ -57,8 +57,6 @@ theory: |
   // => El precio es 3750 rublos
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-3
-
   Cualquier variable puede formar parte de cualquier expresión. En el momento de la evaluación, el valor de la variable se sustituye en lugar de su nombre. El valor de `amountDollars` se calcula antes de que se utilice en otras expresiones. Cuando llega el momento de usar la variable, Java conoce su valor porque ya lo ha calculado.
 
 instructions: |
diff --git a/modules/30-variables/15-variable-expressions/en/README.md b/modules/30-variables/15-variable-expressions/en/README.md
index c242223..c708cd6 100644
--- a/modules/30-variables/15-variable-expressions/en/README.md
+++ b/modules/30-variables/15-variable-expressions/en/README.md
@@ -46,8 +46,6 @@ var rublesCount = dollarsCount * rublesPerDollar; // => 3750
 System.out.print("The price is" + rublesCount + "rubles");
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 The price is 3750 rubles
 
 Any variable can be part of any expression. At the time of calculation, the value of the variable is substituted for its value.
diff --git a/modules/30-variables/15-variable-expressions/es/README.md b/modules/30-variables/15-variable-expressions/es/README.md
index 4408d9a..72e7182 100644
--- a/modules/30-variables/15-variable-expressions/es/README.md
+++ b/modules/30-variables/15-variable-expressions/es/README.md
@@ -52,6 +52,4 @@ System.out.println("El precio es " + amountRubles + " rublos");
 // => El precio es 3750 rublos
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 Cualquier variable puede formar parte de cualquier expresión. En el momento de la evaluación, el valor de la variable se sustituye en lugar de su nombre. El valor de `amountDollars` se calcula antes de que se utilice en otras expresiones. Cuando llega el momento de usar la variable, Java conoce su valor porque ya lo ha calculado.
diff --git a/modules/30-variables/15-variable-expressions/ru/README.md b/modules/30-variables/15-variable-expressions/ru/README.md
index fffa4b6..3d5d354 100644
--- a/modules/30-variables/15-variable-expressions/ru/README.md
+++ b/modules/30-variables/15-variable-expressions/ru/README.md
@@ -52,6 +52,4 @@ System.out.println("The price is " + rublesCount + " rubles");
 // => The price is 3750 rubles
 ```
 
-https://replit.com/@hexlet/java-basics-variables-3
-
 Любая переменная может быть частью любого выражения. В момент вычисления вместо имени переменной подставляется ее значение. Значение `dollarsCount` вычисляется до того, как она начнет использоваться в других выражениях. Когда подходит момент использования переменной, Java знает значение, потому что уже вычислил его.
diff --git a/modules/30-variables/18-variables-concatenation/description.es.yml b/modules/30-variables/18-variables-concatenation/description.es.yml
index 4ac7d24..bdf54b6 100644
--- a/modules/30-variables/18-variables-concatenation/description.es.yml
+++ b/modules/30-variables/18-variables-concatenation/description.es.yml
@@ -27,8 +27,6 @@ theory: |
   System.out.println(que); // => CaminodeReyes
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-4
-
 instructions: |
 
   Los sitios web constantemente envían correos electrónicos a sus usuarios. Una tarea típica es enviar automáticamente un correo electrónico personalizado, donde el nombre de usuario estará en el asunto. Si el nombre del usuario se almacena en algún lugar de la base de datos del sitio web como una cadena, la tarea de generar el asunto se reduce a la concatenación: por ejemplo, debes concatenar la cadena Hola con la cadena que contiene el nombre.
diff --git a/modules/30-variables/18-variables-concatenation/en/README.md b/modules/30-variables/18-variables-concatenation/en/README.md
index 8a46efa..0b34320 100644
--- a/modules/30-variables/18-variables-concatenation/en/README.md
+++ b/modules/30-variables/18-variables-concatenation/en/README.md
@@ -27,5 +27,3 @@ var last = "road";
 var what = first + last;
 System.out.print(what); // => "Kingsroad"
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4
diff --git a/modules/30-variables/18-variables-concatenation/es/README.md b/modules/30-variables/18-variables-concatenation/es/README.md
index 0605b37..4e81f17 100644
--- a/modules/30-variables/18-variables-concatenation/es/README.md
+++ b/modules/30-variables/18-variables-concatenation/es/README.md
@@ -21,5 +21,3 @@ var ultimo = "de Reyes";
 var que = primero + ultimo;
 System.out.println(que); // => CaminodeReyes
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4
diff --git a/modules/30-variables/18-variables-concatenation/ru/README.md b/modules/30-variables/18-variables-concatenation/ru/README.md
index 33bf6ac..e646cdb 100644
--- a/modules/30-variables/18-variables-concatenation/ru/README.md
+++ b/modules/30-variables/18-variables-concatenation/ru/README.md
@@ -21,5 +21,3 @@ var last = "road";
 var what = first + last;
 System.out.println(what); //=> Kingsroad
 ```
-
-https://replit.com/@hexlet/java-basics-variables-4
diff --git a/modules/30-variables/23-constants/description.es.yml b/modules/30-variables/23-constants/description.es.yml
index 885a0bb..a31ea0c 100644
--- a/modules/30-variables/23-constants/description.es.yml
+++ b/modules/30-variables/23-constants/description.es.yml
@@ -12,8 +12,6 @@ theory: |
   System.out.println(pi); // 3.14
   ```
 
-  https://replit.com/@hexlet/java-basics-variables-5
-
   A diferencia de las variables, al definir una constante se utiliza la palabra clave `final`. Esto le indica al compilador que no se puede modificar. Cualquier intento de cambiar una constante resultará en un error.
 
   Una constante, al igual que una variable, puede ser utilizada en cualquier expresión. La única restricción es que no se puede modificar una constante, lo cual tiene bastante sentido.
diff --git a/modules/30-variables/23-constants/en/README.md b/modules/30-variables/23-constants/en/README.md
index 3855cc0..dc15ccb 100644
--- a/modules/30-variables/23-constants/en/README.md
+++ b/modules/30-variables/23-constants/en/README.md
@@ -8,6 +8,4 @@ final var pi = 3.14;
 System.out.print(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 A constant, like a variable, can be used in any expression. The only restriction is that the constant cannot be changed, which sounds quite logical.
diff --git a/modules/30-variables/23-constants/es/README.md b/modules/30-variables/23-constants/es/README.md
index 79b4f44..7db0575 100644
--- a/modules/30-variables/23-constants/es/README.md
+++ b/modules/30-variables/23-constants/es/README.md
@@ -7,8 +7,6 @@ final var pi = 3.14;
 System.out.println(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 A diferencia de las variables, al definir una constante se utiliza la palabra clave `final`. Esto le indica al compilador que no se puede modificar. Cualquier intento de cambiar una constante resultará en un error.
 
 Una constante, al igual que una variable, puede ser utilizada en cualquier expresión. La única restricción es que no se puede modificar una constante, lo cual tiene bastante sentido.
diff --git a/modules/30-variables/23-constants/ru/README.md b/modules/30-variables/23-constants/ru/README.md
index 051eed5..ceffe88 100644
--- a/modules/30-variables/23-constants/ru/README.md
+++ b/modules/30-variables/23-constants/ru/README.md
@@ -7,8 +7,6 @@ final var pi = 3.14;
 System.out.println(pi); // 3.14
 ```
 
-https://replit.com/@hexlet/java-basics-variables-5
-
 В отличие от переменных, в начале определения константы используют ключевое слово `final`. Оно сообщает компилятору запрет на изменение. Любая попытка поменять константу приведет к ошибке.
 
 Константа, как и переменная, может использоваться в любом выражении. Единственное ограничение — константу нельзя изменить, что звучит довольно логично.
diff --git a/modules/33-data-types/55-type-casting/description.es.yml b/modules/33-data-types/55-type-casting/description.es.yml
index ba2dd38..71aafd5 100644
--- a/modules/33-data-types/55-type-casting/description.es.yml
+++ b/modules/33-data-types/55-type-casting/description.es.yml
@@ -28,8 +28,6 @@ theory: |
   System.out.println(result); // => 15
   ```
 
-  https://replit.com/@hexlet/java-basics-data-types
-
 instructions: |
 
   Imprime en la pantalla la cadena de texto `2 times`, obtenida a partir del número 2.9 y la cadena de texto `times`, utilizando conversiones de tipos y concatenación.
diff --git a/modules/33-data-types/55-type-casting/en/README.md b/modules/33-data-types/55-type-casting/en/README.md
index 0f6e68a..ca72d04 100644
--- a/modules/33-data-types/55-type-casting/en/README.md
+++ b/modules/33-data-types/55-type-casting/en/README.md
@@ -17,5 +17,3 @@ System.out.print("It's" + ((int) 5.1));
 It's 5
 
 In case above, in spite of the fact, that 5.1 is the number, it has double type not int. Expression above bring this number type to int type, reject fraction part, because int type doesn't keep fraction part.
-
-https://replit.com/@hexlet/java-basics-data-types
diff --git a/modules/33-data-types/55-type-casting/es/README.md b/modules/33-data-types/55-type-casting/es/README.md
index b77f50f..96f906d 100644
--- a/modules/33-data-types/55-type-casting/es/README.md
+++ b/modules/33-data-types/55-type-casting/es/README.md
@@ -22,5 +22,3 @@ La conversión de tipos se puede utilizar dentro de expresiones compuestas:
 var result = 10 + ((int) 5.1);
 System.out.println(result); // => 15
 ```
-
-https://replit.com/@hexlet/java-basics-data-types
diff --git a/modules/33-data-types/55-type-casting/ru/README.md b/modules/33-data-types/55-type-casting/ru/README.md
index b5506cb..7240a33 100644
--- a/modules/33-data-types/55-type-casting/ru/README.md
+++ b/modules/33-data-types/55-type-casting/ru/README.md
@@ -22,5 +22,3 @@ System.out.println(result); // => 5
 var result = 10 + ((int) 5.1);
 System.out.println(result); // => 15
 ```
-
-https://replit.com/@hexlet/java-basics-data-types
diff --git a/modules/35-methods-using/100-methods/description.es.yml b/modules/35-methods-using/100-methods/description.es.yml
index 73006b7..600ad08 100644
--- a/modules/35-methods-using/100-methods/description.es.yml
+++ b/modules/35-methods-using/100-methods/description.es.yml
@@ -36,8 +36,6 @@ theory: |
   company.toUpperCase(); // "HEXLET"
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-calling
-
   Lo más importante en el trabajo con métodos es comprender el concepto de retorno de valor. Los métodos casi nunca muestran datos en la pantalla, sino que los devuelven. Gracias a esta propiedad, podemos dividir nuestro programa en fragmentos que luego se combinan en algo más complejo.
 
   En los ejemplos anteriores, el resultado de llamar a cada método se guarda en variables. Pero esto no es obligatorio, podemos usar los métodos directamente:
diff --git a/modules/35-methods-using/100-methods/es/README.md b/modules/35-methods-using/100-methods/es/README.md
index 69e8196..4202c73 100644
--- a/modules/35-methods-using/100-methods/es/README.md
+++ b/modules/35-methods-using/100-methods/es/README.md
@@ -31,8 +31,6 @@ System.out.println(companyLength); // => 6
 company.toUpperCase(); // "HEXLET"
 ```
 
-https://replit.com/@hexlet/java-basics-methods-calling
-
 Lo más importante en el trabajo con métodos es comprender el concepto de retorno de valor. Los métodos casi nunca muestran datos en la pantalla, sino que los devuelven. Gracias a esta propiedad, podemos dividir nuestro programa en fragmentos que luego se combinan en algo más complejo.
 
 En los ejemplos anteriores, el resultado de llamar a cada método se guarda en variables. Pero esto no es obligatorio, podemos usar los métodos directamente:
diff --git a/modules/35-methods-using/100-methods/ru/README.md b/modules/35-methods-using/100-methods/ru/README.md
index 9734dce..28d48d2 100644
--- a/modules/35-methods-using/100-methods/ru/README.md
+++ b/modules/35-methods-using/100-methods/ru/README.md
@@ -31,8 +31,6 @@ System.out.println(companyLength); // => 6
 company.toUpperCase(); // "HEXLET"
 ```
 
-https://replit.com/@hexlet/java-basics-methods-calling
-
 Основное в работе с методами – понять принцип возврата значения. Методы почти никогда не выводят данные на экран, они их возвращают. Благодаря этому свойству, мы можем разбить нашу программу на кусочки, из которых потом составляется что-то сложное.
 
 В примерах выше результат вызова каждого метода записывается в переменные. Но это не обязательно, мы можем использовать методы напрямую:
diff --git a/modules/35-methods-using/105-methods-parameters/description.es.yml b/modules/35-methods-using/105-methods-parameters/description.es.yml
index d647c28..cd2504d 100644
--- a/modules/35-methods-using/105-methods-parameters/description.es.yml
+++ b/modules/35-methods-using/105-methods-parameters/description.es.yml
@@ -51,8 +51,6 @@ theory: |
   "hexlet".substring(3, 6); // "let"
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-calling-1
-
 instructions: |
 
   Se te han dado tres variables con los apellidos de diferentes personas. Construye y muestra en la pantalla una palabra con los caracteres en el siguiente orden:
diff --git a/modules/35-methods-using/105-methods-parameters/es/README.md b/modules/35-methods-using/105-methods-parameters/es/README.md
index 24f0dbb..36a27c6 100644
--- a/modules/35-methods-using/105-methods-parameters/es/README.md
+++ b/modules/35-methods-using/105-methods-parameters/es/README.md
@@ -45,5 +45,3 @@ Por defecto, se toma la cadena hasta el final:
 "hexlet".substring(1, 3); // "ex"
 "hexlet".substring(3, 6); // "let"
 ```
-
-https://replit.com/@hexlet/java-basics-methods-calling-1
diff --git a/modules/35-methods-using/105-methods-parameters/ru/README.md b/modules/35-methods-using/105-methods-parameters/ru/README.md
index 775a5c7..fea309f 100644
--- a/modules/35-methods-using/105-methods-parameters/ru/README.md
+++ b/modules/35-methods-using/105-methods-parameters/ru/README.md
@@ -45,5 +45,3 @@ searchEngine.replace("go", "mo"); // "moogle"
 "hexlet".substring(1, 3); // "ex"
 "hexlet".substring(3, 6); // "let"
 ```
-
-https://replit.com/@hexlet/java-basics-methods-calling-1
diff --git a/modules/35-methods-using/115-string-immutability/ru/README.md b/modules/35-methods-using/115-string-immutability/ru/README.md
index 05f726c..2bb2ff9 100644
--- a/modules/35-methods-using/115-string-immutability/ru/README.md
+++ b/modules/35-methods-using/115-string-immutability/ru/README.md
@@ -30,6 +30,4 @@ var processedLanguage = language.toLowerCase();
 System.out.println(processedLanguage); // => java
 ```
 
-https://replit.com/@hexlet/java-basics-methods-as-expressions
-
 Такой подход нередко предпочтительнее по соображениям читаемости. Переменные, которые постоянно меняются, сложнее анализировать. В итоге все зависит от задачи. С опытом придет понимание, какой подход лучше.
diff --git a/modules/35-methods-using/120-methods-chain/description.es.yml b/modules/35-methods-using/120-methods-chain/description.es.yml
index 0518e42..16c586e 100644
--- a/modules/35-methods-using/120-methods-chain/description.es.yml
+++ b/modules/35-methods-using/120-methods-chain/description.es.yml
@@ -56,8 +56,6 @@ theory: |
       .toLowerCase();
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-chain
-
   A pesar de la conveniencia de este mecanismo, no se debe abusar de él. Las variables intermedias pueden facilitar la comprensión del código.
 
 instructions: |
diff --git a/modules/35-methods-using/120-methods-chain/es/README.md b/modules/35-methods-using/120-methods-chain/es/README.md
index 13302cb..08f62a1 100644
--- a/modules/35-methods-using/120-methods-chain/es/README.md
+++ b/modules/35-methods-using/120-methods-chain/es/README.md
@@ -51,6 +51,4 @@ name = name.trim()
     .toLowerCase();
 ```
 
-https://replit.com/@hexlet/java-basics-methods-chain
-
 A pesar de la conveniencia de este mecanismo, no se debe abusar de él. Las variables intermedias pueden facilitar la comprensión del código.
diff --git a/modules/35-methods-using/120-methods-chain/ru/README.md b/modules/35-methods-using/120-methods-chain/ru/README.md
index a2d270f..b5f53a1 100644
--- a/modules/35-methods-using/120-methods-chain/ru/README.md
+++ b/modules/35-methods-using/120-methods-chain/ru/README.md
@@ -51,6 +51,4 @@ name = name.trim()
     .toLowerCase();
 ```
 
-https://replit.com/@hexlet/java-basics-methods-chain
-
 Несмотря на удобство этого механизма, им не стоит злоупотреблять. Промежуточные переменные могут упростить понимание кода.
diff --git a/modules/35-methods-using/200-methods-deterministic/description.es.yml b/modules/35-methods-using/200-methods-deterministic/description.es.yml
index a6f6653..1c8a037 100644
--- a/modules/35-methods-using/200-methods-deterministic/description.es.yml
+++ b/modules/35-methods-using/200-methods-deterministic/description.es.yml
@@ -18,8 +18,6 @@ theory: |
   Math.random(); // 0.8839904367241888
   ```
 
-  https://replit.com/@hexlet/java-basics-pure-functions
-
   ¿Por qué es importante saber esto? El determinismo afecta seriamente muchos aspectos. Las funciones deterministas son convenientes para trabajar, son fáciles de optimizar y de probar. Si es posible hacer que una función sea determinista, es mejor hacerlo así.
 
 instructions: |
diff --git a/modules/35-methods-using/200-methods-deterministic/es/README.md b/modules/35-methods-using/200-methods-deterministic/es/README.md
index f78ce65..9075179 100644
--- a/modules/35-methods-using/200-methods-deterministic/es/README.md
+++ b/modules/35-methods-using/200-methods-deterministic/es/README.md
@@ -13,6 +13,4 @@ Math.random(); // 0.09856613113197676
 Math.random(); // 0.8839904367241888
 ```
 
-https://replit.com/@hexlet/java-basics-pure-functions
-
 ¿Por qué es importante saber esto? El determinismo afecta seriamente muchos aspectos. Las funciones deterministas son convenientes para trabajar, son fáciles de optimizar y de probar. Si es posible hacer que una función sea determinista, es mejor hacerlo así.
diff --git a/modules/35-methods-using/200-methods-deterministic/ru/README.md b/modules/35-methods-using/200-methods-deterministic/ru/README.md
index f89ac48..ccd57be 100644
--- a/modules/35-methods-using/200-methods-deterministic/ru/README.md
+++ b/modules/35-methods-using/200-methods-deterministic/ru/README.md
@@ -13,6 +13,4 @@ Math.random(); // 0.09856613113197676
 Math.random(); // 0.8839904367241888
 ```
 
-https://replit.com/@hexlet/java-basics-pure-functions
-
 Зачем это нужно знать? Детерминированность серьезно влияет на многие аспекты. Детерминированные функции удобны в работе, их легко оптимизировать, легко тестировать. Если есть возможность сделать функцию детерминированной, то лучше ее такой и сделать.
diff --git a/modules/40-methods-definition/100-method-definition-static/description.es.yml b/modules/40-methods-definition/100-method-definition-static/description.es.yml
index 274c910..bab2948 100644
--- a/modules/40-methods-definition/100-method-definition-static/description.es.yml
+++ b/modules/40-methods-definition/100-method-definition-static/description.es.yml
@@ -50,8 +50,6 @@ theory: |
   App.showCurrentDate(); // => Hoy es: 2021-10-25
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-definition
-
   La definición de un método en Java implica muchas acciones que iremos viendo gradualmente.
 
   Se pueden dividir en dos grupos:
diff --git a/modules/40-methods-definition/100-method-definition-static/es/README.md b/modules/40-methods-definition/100-method-definition-static/es/README.md
index c0d3035..c458d76 100644
--- a/modules/40-methods-definition/100-method-definition-static/es/README.md
+++ b/modules/40-methods-definition/100-method-definition-static/es/README.md
@@ -45,8 +45,6 @@ public class App {
 App.showCurrentDate(); // => Hoy es: 2021-10-25
 ```
 
-https://replit.com/@hexlet/java-basics-methods-definition
-
 La definición de un método en Java implica muchas acciones que iremos viendo gradualmente.
 
 Se pueden dividir en dos grupos:
diff --git a/modules/40-methods-definition/100-method-definition-static/ru/README.md b/modules/40-methods-definition/100-method-definition-static/ru/README.md
index e404b2b..a0235b4 100644
--- a/modules/40-methods-definition/100-method-definition-static/ru/README.md
+++ b/modules/40-methods-definition/100-method-definition-static/ru/README.md
@@ -45,8 +45,6 @@ public class App {
 App.showCurrentDate(); // => Today is: 2021-10-25
 ```
 
-https://replit.com/@hexlet/java-basics-methods-definition
-
 Определение метода в Java включает в себя много действий, которые мы постепенно разберем.
 
 Их можно разделить на две группы:
diff --git a/modules/40-methods-definition/200-method-definition-return/ru/README.md b/modules/40-methods-definition/200-method-definition-return/ru/README.md
index 57ce061..f68d91d 100644
--- a/modules/40-methods-definition/200-method-definition-return/ru/README.md
+++ b/modules/40-methods-definition/200-method-definition-return/ru/README.md
@@ -119,8 +119,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-return
-
 В этом примере в определении метода использовался `long`, так как возвращается целое число.
 
 Чтобы проверить знания из этого урока, попробуйте ответить на вопрос. Как думаете, что выведет этот код?
diff --git a/modules/40-methods-definition/300-method-definition-parameters/description.es.yml b/modules/40-methods-definition/300-method-definition-parameters/description.es.yml
index 78364e6..611dc3c 100644
--- a/modules/40-methods-definition/300-method-definition-parameters/description.es.yml
+++ b/modules/40-methods-definition/300-method-definition-parameters/description.es.yml
@@ -52,8 +52,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-parameters-1
-
   Analicemos este código en detalle. `char` nos indica el tipo de valor que se devuelve. Luego, entre paréntesis, se especifica el tipo del parámetro `String` y su nombre `str`.
 
   Dentro del método, no sabemos con qué valor específico estamos trabajando, por lo que los parámetros siempre se describen como variables.
@@ -86,8 +84,6 @@ theory: |
   App.average(1, 2); // 1.5
   ```
 
-  https://replit.com/@hexlet/java-basics-methods-parameters-2
-
   Los métodos pueden requerir cualquier cantidad de parámetros que necesiten para funcionar:
 
   ```java
diff --git a/modules/40-methods-definition/300-method-definition-parameters/es/README.md b/modules/40-methods-definition/300-method-definition-parameters/es/README.md
index a2a390b..5d76ba3 100644
--- a/modules/40-methods-definition/300-method-definition-parameters/es/README.md
+++ b/modules/40-methods-definition/300-method-definition-parameters/es/README.md
@@ -47,8 +47,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-methods-parameters-1
-
 Analicemos este código en detalle. `char` nos indica el tipo de valor que se devuelve. Luego, entre paréntesis, se especifica el tipo del parámetro `String` y su nombre `str`.
 
 Dentro del método, no sabemos con qué valor específico estamos trabajando, por lo que los parámetros siempre se describen como variables.
@@ -81,8 +79,6 @@ App.average(1, 5); // 3.0
 App.average(1, 2); // 1.5
 ```
 
-https://replit.com/@hexlet/java-basics-methods-parameters-2
-
 Los métodos pueden requerir cualquier cantidad de parámetros que necesiten para funcionar:
 
 ```java
diff --git a/modules/40-methods-definition/300-method-definition-parameters/ru/README.md b/modules/40-methods-definition/300-method-definition-parameters/ru/README.md
index 7679634..af4339b 100644
--- a/modules/40-methods-definition/300-method-definition-parameters/ru/README.md
+++ b/modules/40-methods-definition/300-method-definition-parameters/ru/README.md
@@ -47,8 +47,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-methods-parameters-1
-
 Разберем этот код подробнее. `char` говорит нам о типе возвращаемого значения. Далее в скобках указывается тип параметра `String` и его имя `str`.
 
 Внутри метода мы не знаем, с каким конкретно значением идет работа, поэтому параметры всегда описываются как переменные.
@@ -81,8 +79,6 @@ App.average(1, 5); // 3.0
 App.average(1, 2); // 1.5
 ```
 
-https://replit.com/@hexlet/java-basics-methods-parameters-2
-
 Методы могут требовать на вход любое количество параметров, которое им нужно для работы:
 
 ```java
diff --git a/modules/40-methods-definition/400-method-definition-default-parameters/description.es.yml b/modules/40-methods-definition/400-method-definition-default-parameters/description.es.yml
index e1975ad..856dee4 100644
--- a/modules/40-methods-definition/400-method-definition-default-parameters/description.es.yml
+++ b/modules/40-methods-definition/400-method-definition-default-parameters/description.es.yml
@@ -92,8 +92,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-default-parameters
-
   En este ejemplo, no hemos reducido el código, pero muestra claramente el principio descrito anteriormente.
 
 instructions: |
diff --git a/modules/40-methods-definition/400-method-definition-default-parameters/es/README.md b/modules/40-methods-definition/400-method-definition-default-parameters/es/README.md
index 0d2e5f1..1f5d35b 100644
--- a/modules/40-methods-definition/400-method-definition-default-parameters/es/README.md
+++ b/modules/40-methods-definition/400-method-definition-default-parameters/es/README.md
@@ -87,6 +87,4 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-default-parameters
-
 En este ejemplo, no hemos reducido el código, pero muestra claramente el principio descrito anteriormente.
diff --git a/modules/40-methods-definition/400-method-definition-default-parameters/ru/README.md b/modules/40-methods-definition/400-method-definition-default-parameters/ru/README.md
index 428a317..326d1e5 100644
--- a/modules/40-methods-definition/400-method-definition-default-parameters/ru/README.md
+++ b/modules/40-methods-definition/400-method-definition-default-parameters/ru/README.md
@@ -87,6 +87,4 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-default-parameters
-
 В этом примере мы не сократили код, но он наглядно показывает принцип, описанный выше.
diff --git a/modules/45-logic/12-string-comparasion/ru/README.md b/modules/45-logic/12-string-comparasion/ru/README.md
index 4934aa1..4650154 100644
--- a/modules/45-logic/12-string-comparasion/ru/README.md
+++ b/modules/45-logic/12-string-comparasion/ru/README.md
@@ -111,8 +111,6 @@ var name2 = "java".toUpperCase(); // "JAVA"
 name1.equals(name2); // true
 ```
 
-https://replit.com/@hexlet/java-basics-logical-operations
-
 Помимо `equals()`, в строки встроен метод `equalsIgnoreCase()`, который выполняет проверку по значению без учета регистра:
 
 ```java
diff --git a/modules/45-logic/20-combine-expressions/description.es.yml b/modules/45-logic/20-combine-expressions/description.es.yml
index 7fbbaeb..35ab63b 100644
--- a/modules/45-logic/20-combine-expressions/description.es.yml
+++ b/modules/45-logic/20-combine-expressions/description.es.yml
@@ -34,8 +34,6 @@ theory: |
   App.esPar(3); // false
   ```
 
-  https://replit.com/@hexlet/java-basics-logical-operations-1
-
   En una sola expresión hemos combinado dos operadores lógicos:
 
   * `==` - verificación de igualdad
diff --git a/modules/45-logic/20-combine-expressions/es/README.md b/modules/45-logic/20-combine-expressions/es/README.md
index dabbd1f..8f5d2fc 100644
--- a/modules/45-logic/20-combine-expressions/es/README.md
+++ b/modules/45-logic/20-combine-expressions/es/README.md
@@ -30,8 +30,6 @@ App.esPar(10); // true
 App.esPar(3); // false
 ```
 
-https://replit.com/@hexlet/java-basics-logical-operations-1
-
 En una sola expresión hemos combinado dos operadores lógicos:
 
 * `==` - verificación de igualdad
diff --git a/modules/45-logic/20-combine-expressions/ru/README.md b/modules/45-logic/20-combine-expressions/ru/README.md
index ae55b28..6cf520d 100644
--- a/modules/45-logic/20-combine-expressions/ru/README.md
+++ b/modules/45-logic/20-combine-expressions/ru/README.md
@@ -30,8 +30,6 @@ App.isEven(10); // true
 App.isEven(3); // false
 ```
 
-https://replit.com/@hexlet/java-basics-logical-operations-1
-
 В одном выражении мы скомбинировали два логических оператора:
 
 * `==` — проверка равенства
diff --git a/modules/45-logic/25-logical-operators/description.es.yml b/modules/45-logic/25-logical-operators/description.es.yml
index 17493fb..bc7738b 100644
--- a/modules/45-logic/25-logical-operators/description.es.yml
+++ b/modules/45-logic/25-logical-operators/description.es.yml
@@ -53,8 +53,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-logical-operators
-
   El área de las matemáticas que estudia los operadores lógicos se llama **álgebra booleana**. A continuación se muestran las "tablas de verdad" que nos permiten determinar el resultado de la aplicación de un operador:
 
   ### Operador Y `&&`
diff --git a/modules/45-logic/25-logical-operators/es/README.md b/modules/45-logic/25-logical-operators/es/README.md
index 7c8ea58..4133fd0 100644
--- a/modules/45-logic/25-logical-operators/es/README.md
+++ b/modules/45-logic/25-logical-operators/es/README.md
@@ -49,8 +49,6 @@ public static boolean esBuenApartamento(int area, String calle) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-logical-operators
-
 El área de las matemáticas que estudia los operadores lógicos se llama **álgebra booleana**. A continuación se muestran las "tablas de verdad" que nos permiten determinar el resultado de la aplicación de un operador:
 
 ### Operador Y `&&`
diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md
index ec998f5..f9b1144 100644
--- a/modules/45-logic/25-logical-operators/ru/README.md
+++ b/modules/45-logic/25-logical-operators/ru/README.md
@@ -49,8 +49,6 @@ public static boolean isGoodApartment(int area, String street) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-logical-operators
-
 Область математики, в которой изучаются логические операторы, называется **булевой алгеброй**. Ниже показаны «таблицы истинности» — по ним можно определить, каким будет результат применения оператора:
 
 ### Оператор И `&&`
diff --git a/modules/80-conditionals/50-else-if/description.es.yml b/modules/80-conditionals/50-else-if/description.es.yml
index 7f3cb1b..00f72d8 100644
--- a/modules/80-conditionals/50-else-if/description.es.yml
+++ b/modules/80-conditionals/50-else-if/description.es.yml
@@ -45,8 +45,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-if-else
-
   Ahora todas las condiciones están organizadas en una única estructura. El operador `else if` significa "si la condición anterior no se cumple, pero la condición actual sí se cumple". La estructura es la siguiente:
 
   - Si el último carácter es `?`, entonces "pregunta"
diff --git a/modules/80-conditionals/50-else-if/es/README.md b/modules/80-conditionals/50-else-if/es/README.md
index 7d3b465..136290e 100644
--- a/modules/80-conditionals/50-else-if/es/README.md
+++ b/modules/80-conditionals/50-else-if/es/README.md
@@ -40,8 +40,6 @@ public static String getTypeOfSentence(String sentence)
 }
 ```
 
-https://replit.com/@hexlet/java-basics-if-else
-
 Ahora todas las condiciones están organizadas en una única estructura. El operador `else if` significa "si la condición anterior no se cumple, pero la condición actual sí se cumple". La estructura es la siguiente:
 
 - Si el último carácter es `?`, entonces "pregunta"
diff --git a/modules/80-conditionals/50-else-if/ru/README.md b/modules/80-conditionals/50-else-if/ru/README.md
index 7867658..83df36b 100644
--- a/modules/80-conditionals/50-else-if/ru/README.md
+++ b/modules/80-conditionals/50-else-if/ru/README.md
@@ -40,8 +40,6 @@ public static String getTypeOfSentence(String sentence)
 }
 ```
 
-https://replit.com/@hexlet/java-basics-if-else
-
 Теперь все условия выстроены в единую конструкцию. Оператор `else if` — это «если не выполнено предыдущее условие, но выполнено текущее». Получается такая схема:
 
 - Если последний символ `?`, то "question"
diff --git a/modules/80-conditionals/80-switch/description.es.yml b/modules/80-conditionals/80-switch/description.es.yml
index c9c1deb..6cf92a0 100644
--- a/modules/80-conditionals/80-switch/description.es.yml
+++ b/modules/80-conditionals/80-switch/description.es.yml
@@ -106,8 +106,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-switch
-
   Aunque `switch` se encuentra en el código, técnicamente siempre se puede prescindir de él.
 
   La utilidad de esta estructura radica en que expresa mejor la intención del programador cuando se necesita comprobar valores específicos de una variable. A diferencia de los bloques `else if`, el código con `switch` es un poco más largo, pero mucho más fácil de leer.
diff --git a/modules/80-conditionals/80-switch/es/README.md b/modules/80-conditionals/80-switch/es/README.md
index cc64e4b..ab22098 100644
--- a/modules/80-conditionals/80-switch/es/README.md
+++ b/modules/80-conditionals/80-switch/es/README.md
@@ -101,8 +101,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-switch
-
 Aunque `switch` se encuentra en el código, técnicamente siempre se puede prescindir de él.
 
 La utilidad de esta estructura radica en que expresa mejor la intención del programador cuando se necesita comprobar valores específicos de una variable. A diferencia de los bloques `else if`, el código con `switch` es un poco más largo, pero mucho más fácil de leer.
diff --git a/modules/80-conditionals/80-switch/ru/README.md b/modules/80-conditionals/80-switch/ru/README.md
index 7b2f35f..197db89 100644
--- a/modules/80-conditionals/80-switch/ru/README.md
+++ b/modules/80-conditionals/80-switch/ru/README.md
@@ -101,8 +101,6 @@ class App {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-switch
-
 `Switch` хоть и встречается в коде, но технически всегда можно обойтись без него.
 
 Польза этой конструкции в том, что она лучше выражает намерение программиста, когда нужно проверять конкретные значения переменной. В отличие от блоков `else if`, код со `switch` становится немного длиннее, но читать его гораздо проще.
diff --git a/modules/90-loops/100-while/description.es.yml b/modules/90-loops/100-while/description.es.yml
index 32bebba..d15e7ec 100644
--- a/modules/90-loops/100-while/description.es.yml
+++ b/modules/90-loops/100-while/description.es.yml
@@ -53,8 +53,6 @@ theory: |
   finished!
   </pre>
 
-  https://replit.com/@hexlet/java-basics-while
-
   En el código del método se utiliza el ciclo `while`. Está compuesto por tres elementos:
 
   * La **palabra clave** `while`. Aunque se parece a una llamada a un método, no lo es.
diff --git a/modules/90-loops/100-while/es/README.md b/modules/90-loops/100-while/es/README.md
index 52ff8e2..371e1eb 100644
--- a/modules/90-loops/100-while/es/README.md
+++ b/modules/90-loops/100-while/es/README.md
@@ -48,8 +48,6 @@ App.printNumbers(3);
 finished!
 </pre>
 
-https://replit.com/@hexlet/java-basics-while
-
 En el código del método se utiliza el ciclo `while`. Está compuesto por tres elementos:
 
 * La **palabra clave** `while`. Aunque se parece a una llamada a un método, no lo es.
diff --git a/modules/90-loops/100-while/ru/README.md b/modules/90-loops/100-while/ru/README.md
index 8bed61b..38796e4 100644
--- a/modules/90-loops/100-while/ru/README.md
+++ b/modules/90-loops/100-while/ru/README.md
@@ -48,8 +48,6 @@ App.printNumbers(3);
 finished!
 </pre>
 
-https://replit.com/@hexlet/java-basics-while
-
 В коде метода использован цикл `while`. Он состоит из трех элементов:
 
 * **Ключевое слово** `while`. Несмотря на схожесть с вызовом методов, это не вызов метода
diff --git a/modules/90-loops/150-aggregation-numbers/description.es.yml b/modules/90-loops/150-aggregation-numbers/description.es.yml
index 7e5ef58..cd7451c 100644
--- a/modules/90-loops/150-aggregation-numbers/description.es.yml
+++ b/modules/90-loops/150-aggregation-numbers/description.es.yml
@@ -57,8 +57,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-loops-using-1
-
   La estructura general del bucle es la siguiente:
 
   * Un contador que se inicializa con el valor inicial del rango
diff --git a/modules/90-loops/150-aggregation-numbers/es/README.md b/modules/90-loops/150-aggregation-numbers/es/README.md
index 14f5c42..18a8968 100644
--- a/modules/90-loops/150-aggregation-numbers/es/README.md
+++ b/modules/90-loops/150-aggregation-numbers/es/README.md
@@ -52,8 +52,6 @@ public static int sumNumbersFromRange(int start, int finish) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-loops-using-1
-
 La estructura general del bucle es la siguiente:
 
 * Un contador que se inicializa con el valor inicial del rango
diff --git a/modules/90-loops/150-aggregation-numbers/ru/README.md b/modules/90-loops/150-aggregation-numbers/ru/README.md
index 0fe39f3..20f5c4c 100644
--- a/modules/90-loops/150-aggregation-numbers/ru/README.md
+++ b/modules/90-loops/150-aggregation-numbers/ru/README.md
@@ -52,8 +52,6 @@ public static int sumNumbersFromRange(int start, int finish) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-loops-using-1
-
 Общая структура цикла здесь стандартна:
 
 * Счетчик, который инициализируется начальным значением диапазона
diff --git a/modules/90-loops/300-conditions-inside-loops/description.es.yml b/modules/90-loops/300-conditions-inside-loops/description.es.yml
index 8b6c9d2..1c53cf5 100644
--- a/modules/90-loops/300-conditions-inside-loops/description.es.yml
+++ b/modules/90-loops/300-conditions-inside-loops/description.es.yml
@@ -37,8 +37,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-conditions-inside-loops
-
   Este problema es una agregación. El método cuenta solo los caracteres deseados, pero aún así es necesario analizar cada carácter para calcular la suma total.
 
   La diferencia clave de este bucle con los que hemos visto anteriormente es que tiene una condición dentro del cuerpo. La variable `count` solo se incrementa cuando el carácter actual coincide con el carácter esperado. De lo contrario, es un método agregado típico que devuelve la cantidad de caracteres deseados al código que lo llama.
diff --git a/modules/90-loops/300-conditions-inside-loops/es/README.md b/modules/90-loops/300-conditions-inside-loops/es/README.md
index 88e8b89..b861d06 100644
--- a/modules/90-loops/300-conditions-inside-loops/es/README.md
+++ b/modules/90-loops/300-conditions-inside-loops/es/README.md
@@ -32,8 +32,6 @@ public static int countChars(String str, char ch) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-conditions-inside-loops
-
 Este problema es una agregación. El método cuenta solo los caracteres deseados, pero aún así es necesario analizar cada carácter para calcular la suma total.
 
 La diferencia clave de este bucle con los que hemos visto anteriormente es que tiene una condición dentro del cuerpo. La variable `count` solo se incrementa cuando el carácter actual coincide con el carácter esperado. De lo contrario, es un método agregado típico que devuelve la cantidad de caracteres deseados al código que lo llama.
diff --git a/modules/90-loops/300-conditions-inside-loops/ru/README.md b/modules/90-loops/300-conditions-inside-loops/ru/README.md
index 221ebaf..050f308 100644
--- a/modules/90-loops/300-conditions-inside-loops/ru/README.md
+++ b/modules/90-loops/300-conditions-inside-loops/ru/README.md
@@ -32,8 +32,6 @@ public static int countChars(String str, char ch) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-conditions-inside-loops
-
 Эта задача является агрегирующей. Метод считает не все символы, но при этом для подсчета самой суммы все равно приходится анализировать каждый символ.
 
 Ключевое отличие этого цикла от рассмотренных в наличии условия внутри тела. Переменная `count` увеличивается только в том случае, когда текущий рассматриваемый символ совпадает с ожидаемым. В остальном — это типичный агрегатный метод, который возвращает количество нужных символов вызываемому коду.
diff --git a/modules/90-loops/350-build-strings/description.es.yml b/modules/90-loops/350-build-strings/description.es.yml
index 536683d..645485f 100644
--- a/modules/90-loops/350-build-strings/description.es.yml
+++ b/modules/90-loops/350-build-strings/description.es.yml
@@ -33,8 +33,6 @@ theory: |
   App.reverse(""); // ""
   ```
 
-  https://replit.com/@hexlet/java-basics-loops-using-2
-
   Es importante comprender cómo se construye la cadena: cada carácter siguiente se une a la cadena resultante por la izquierda, y al final la cadena queda invertida.
 
 instructions: |
diff --git a/modules/90-loops/350-build-strings/es/README.md b/modules/90-loops/350-build-strings/es/README.md
index f4b5e4a..a8929b6 100644
--- a/modules/90-loops/350-build-strings/es/README.md
+++ b/modules/90-loops/350-build-strings/es/README.md
@@ -28,6 +28,4 @@ App.reverse(name); // "narB"
 App.reverse(""); // ""
 ```
 
-https://replit.com/@hexlet/java-basics-loops-using-2
-
 Es importante comprender cómo se construye la cadena: cada carácter siguiente se une a la cadena resultante por la izquierda, y al final la cadena queda invertida.
diff --git a/modules/90-loops/350-build-strings/ru/README.md b/modules/90-loops/350-build-strings/ru/README.md
index 8910514..df4f1da 100644
--- a/modules/90-loops/350-build-strings/ru/README.md
+++ b/modules/90-loops/350-build-strings/ru/README.md
@@ -28,6 +28,4 @@ App.reverse(name); // "narB"
 App.reverse(""); // ""
 ```
 
-https://replit.com/@hexlet/java-basics-loops-using-2
-
 Важно прочувствовать, как собирается сама строка — каждый следующий символ прикрепляется к результирующей строке слева, и в итоге строка оказывается перевернута.
diff --git a/modules/90-loops/550-for/description.es.yml b/modules/90-loops/550-for/description.es.yml
index aa173c2..696503f 100644
--- a/modules/90-loops/550-for/description.es.yml
+++ b/modules/90-loops/550-for/description.es.yml
@@ -20,8 +20,6 @@ theory: |
   }
   ```
 
-  https://replit.com/@hexlet/java-basics-conditions-for
-
   Este código se puede describir de la siguiente manera:
 
   > El ciclo con el índice `i` se repite mientras `i < str.length()`, y después de cada paso, `i` se incrementa en 1.
diff --git a/modules/90-loops/550-for/es/README.md b/modules/90-loops/550-for/es/README.md
index ba34cca..bd7e839 100644
--- a/modules/90-loops/550-for/es/README.md
+++ b/modules/90-loops/550-for/es/README.md
@@ -15,8 +15,6 @@ public static String reverseString(String str) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-conditions-for
-
 Este código se puede describir de la siguiente manera:
 
 > El ciclo con el índice `i` se repite mientras `i < str.length()`, y después de cada paso, `i` se incrementa en 1.
diff --git a/modules/90-loops/550-for/ru/README.md b/modules/90-loops/550-for/ru/README.md
index 8d758fe..ec71522 100644
--- a/modules/90-loops/550-for/ru/README.md
+++ b/modules/90-loops/550-for/ru/README.md
@@ -15,8 +15,6 @@ public static String reverseString(String str) {
 }
 ```
 
-https://replit.com/@hexlet/java-basics-conditions-for
-
 Этот код можно описать так:
 
 > Цикл с индексом `i` повторяется, пока `i < str.length()`, а также после каждого шага увеличивает `i` на 1