diff --git a/sessions/docs-kahoot/session-01.md b/sessions/docs-kahoot/session-01.md
new file mode 100644
index 00000000..5f077340
--- /dev/null
+++ b/sessions/docs-kahoot/session-01.md
@@ -0,0 +1,60 @@
+# Session 1 Docs Kahoot
+
+## Link
+
+[https://create.kahoot.it/details/8fdc1e3e-6efb-4b16-8848-8b4fc8915f93](https://create.kahoot.it/details/8fdc1e3e-6efb-4b16-8848-8b4fc8915f93)
+
+## Temario
+
+- [Método REACTO](#metodo-REACTO)
+
+## Método REACTO
+
+📺 [Video](https://www.youtube.com/watch?v=AoD3hLFxI5I)
+
+### Qué es REACTO ?
+
+[**R**]eleer el enunciado
+
+[**E**]jemplos
+
+[**A**]proximación
+
+[**C**]odear
+
+[**T**]estear
+
+[**O**]ptimizar
+
+## **R**eleer el enunciado
+
+Hacemos varias lecturas del ejercicio con el fin de comprender su propósito,
+es decir, identificar lo que se nos está solicitando y lo que estamos
+recibiendo.
+
+## **E**jemplos
+
+Realizamos (o leemos) ejemplos con distintas entradas y analizamos cual es el
+resultado cambios estas entradas. También se validan si tiene caso especiales.
+
+# **A**proximacion
+
+Se describe una posible solución en voz alta, lo cual da como resultado una
+serie de pasos que se escriben como comentario.
+
+## **C**odear
+
+Se transcriben los comentarios del paso anterior a código, en este paso
+investigan y resuelven detalles más técnicos.
+
+
+## **T**estear
+
+Se prueba el código, y se comprueba si el resultado es el esperado.
+Si no es el resultado esperado regresamos a cualquiera de los pasos anteriores,
+si es necesario comenzar desde el principio esta bien!
+
+### Notas
+
+En el GYM nos será muy útil seguir el método REACTO, los ejercicios nos ayudaran
+a fortalecer todo lo que hemos aprendido y también a aprender cosas nuevas.
diff --git a/sessions/docs-kahoot/session-14.md b/sessions/docs-kahoot/session-14.md
new file mode 100644
index 00000000..92011e01
--- /dev/null
+++ b/sessions/docs-kahoot/session-14.md
@@ -0,0 +1,120 @@
+# Session 14 Docs Kahoot
+
+## Link
+
+[https://create.kahoot.it/share/kahoot-14-el-terror-de-javascript/f429c2f2-abab-4928-8373-f716b9350b31](https://create.kahoot.it/share/kahoot-14-el-terror-de-javascript/f429c2f2-abab-4928-8373-f716b9350b31)
+
+## Temario
+
+- [Sincrónico](#sincronico)
+- [Promesas](#promesas)
+- [Loop While](#loop-while)
+- [Do While](#do-while)
+- [Try…catch](#try…catch)
+- [await](#await)
+- [throw](#throw)
+
+----
+
+### Sincrónico
+
+Sincrónico se refiere a la comunicación en tiempo real donde cada lado recibe
+(y si es necesario, procesa y responde) mensajes instantáneamente (o lo más
+cerca posible a instantáneamente).
+
+----
+
+### Promesas
+
+Una promesa en JavaScript es un objeto que representa la terminación o el
+fracaso de una operación asíncrona. Esencialmente, una promesa es un objeto
+devuelto al cual se adjuntan funciones callback, en lugar de pasar callbacks
+a una función.
+
+[Documentación](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+
+#### Promise.all()
+
+El método Promise.all(iterable) devuelve una promesa que termina correctamente
+cuando todas las promesas en el argumento iterable han sido concluídas con
+éxito, o bien rechaza la petición con el motivo pasado por la primera promesa
+que es rechazada.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise/all)
+
+#### Promise.prototype.catch()
+
+El método catch() retorna una Promise y solo se ejecuta en los casos en los
+que la promesa se marca como Reject. Se comporta igual que al llamar
+Promise.prototype.then(undefined, onRejected) (de hecho, al llamar
+obj.catch(onRejected) internamente llama a obj.then(undefined, onRejected)).
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch#especificaciones)
+
+
+#### Promise.race()
+
+El método Promise.race(iterable) retorna una promesa que se cumplirá o no tan
+pronto como una de las promesas del argumento iterable se cumpla o se rechace,
+con el valor o razón de rechazo de ésta.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise/race)
+
+----
+
+### Loop While
+
+Crea un bucle que ejecuta una sentencia especificada mientras cierta condición
+se evalúe como verdadera. Dicha condición es evaluada antes de ejecutar
+la sentencia.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/while)
+
+----
+
+### Do While
+
+La sentencia (hacer mientras) crea un bucle que ejecuta una sentencia
+especificada, hasta que la condición de comprobación se evalúa como falsa.
+La condición se evalúa después de ejecutar la sentencia, dando como resultado
+que la sentencia especificada se ejecute al menos una vez.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/do...while)
+
+----
+
+### Try…catch
+
+La declaración try...catch señala un bloque de instrucciones a intentar (try),
+y especifica una respuesta si se produce una excepción (catch).
+
+#### La cláusula finally
+
+La cláusula finally contiene sentencias a ejecutarse después de que las
+cláusulas try y catch se ejecuten, pero antes de las sentencias que le
+siguen al bloque try..catch..finally. Note que la cláusula finally se ejecuta
+sin importar si una excepción es o no lanzada. Si una excepción es lanzada,
+las instrucciones en la cláusula finally se ejecutan incluso si ninguna
+cláusula catch maneja la excepción.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/try...catch#la_cl%C3%A1usula_finally)
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/try...catch)
+
+----
+
+### await
+
+El operador await es usado para esperar a una Promise. Sólo puede ser usado
+dentro de una función async function.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/async_function)
+
+----
+
+### throw
+
+Utilice la sentencia throw para lanzar una excepción. Cuando lanza una excepción,
+expresion especifica el valor de la excepción.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/throw)
diff --git a/sessions/docs-kahoot/session-15.md b/sessions/docs-kahoot/session-15.md
new file mode 100644
index 00000000..6816791b
--- /dev/null
+++ b/sessions/docs-kahoot/session-15.md
@@ -0,0 +1,133 @@
+# Session 15 Docs Kahoot
+
+## Link
+
+[https://create.kahoot.it/share/gym-session-15/96edea29-d3f4-41b7-8f82-e1e875bd0e3a](https://create.kahoot.it/share/gym-session-15/96edea29-d3f4-41b7-8f82-e1e875bd0e3a)
+
+## Temario
+
+- [Display CSS - Flex direction](#display-CSS-Flex-direction)
+- [Comparadores de igualdad e identidad - Igualdad Estricta](#comparadores-de-igualdad-e-identidad-igualdad-estricta)
+- [Filter Array](#filter-array)
+- [Sentencia y Expresiones](#sentencia-ye-xpresiones)
+- [Estados promesas](#estados-promesas)
+- [Tipo de dato undefined](#tipo-de-dato-undefined)
+- [spread](#spread)
+- [Push Array](#push-array)
+- [For each](#for-each)
+
+----
+
+### Display CSS - Flex direction
+
+La propiedad CSS display especifica si un elemento es tratado como un bloque o
+un elemento en línea y el diseño utilizado para sus hijos, como el diseño de
+flujo (flow layout), cuadrícula (grid) o flexible (flex). Formalmente, la
+propiedad display establece los tipos de visualización interna y externa
+de un elemento.
+
+[Documentación Display](https://developer.mozilla.org/es/docs/Web/CSS/display)
+
+[Documentación Flex Direction](https://developer.mozilla.org/es/docs/Web/CSS/flex-direction)
+
+[Juego Flex Direction](https://flexboxfroggy.com/)
+
+----
+
+### Comparadores de igualdad e identidad - Igualdad Estricta
+
+El operador de estricta igualdad (===) revisa si dos operandos son iguales
+y produce un resultado Booleano.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Equality_comparisons_and_sameness)
+
+[Documentación igualdad estricta](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+
+----
+
+### Filter Array
+
+El método filter() crea un nuevo array con todos los elementos que cumplan
+la condición implementada por la función dada.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
+
+----
+
+### Sentencia y Expresiones
+
+En JavaScript, una expresión es cualquier unidad válida de código que se
+resuelve en un valor. Por ejemplo, 2+2 es una expresión, ya que se resuelve
+en el valor 4. Otra expresión podría ser a = 2, que tiene un valor (2) y
+también asigna un valor a una variable.
+
+Por otro lado, una sentencia es una instrucción que realiza una acción. Las
+sentencias incluyen cosas como declaraciones de variables (var a;), bucles
+(for, while), condicionales (if) y más.
+Por ejemplo, if (a > 0) { console.log(a); } es una sentencia.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements)
+
+----
+
+### Estados promesas
+
+Una promesa en JavaScript es un objeto que representa un valor que puede estar
+disponible ahora, en el futuro o nunca. Las promesas son especialmente útiles
+para manejar funciones asíncronas, como peticiones a servidores, ya que te
+permiten controlar el flujo de ejecución de tu programa de una manera más
+elegante y sencilla.
+Una Promise recibe una "función ejecutora" que acepta dos argumentos:
+resolve y reject.
+El objeto Promise representa la eventual finalización (o falla) de una
+operación asincrónica y su valor resultante.
+Un Promise está en uno de estos estados:
+• pending (pendiente): estado inicial, ni cumplido ni rechazado
+• fulfilled (cumplida): lo que significa que la operación se completó con éxito
+• rejected (rechazada): lo que significa que la operación falló
+Una promesa pendiente puede cumplirse con un valor o rechazarse con
+un motivo (error).
+Cuando ocurre cualquiera de estas opciones, se llama a los controladores
+asociados en cola por el método then de una promesa.
+
+[Documentación Promesas](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+
+----
+
+### Tipo de dato undefined
+
+En JavaScript, un primitive (valor primitivo, tipo de dato primitivo)
+son datos que no son un objeto y no tienen métodos.
+
+[Documentación Primitivo](https://developer.mozilla.org/es/docs/Glossary/Primitive)
+
+[Documentación Undefined](https://developer.mozilla.org/es/docs/Glossary/Undefined)
+
+----
+
+### spread
+
+La sintaxis extendida o spread syntax permite a un elemento iterable tal como
+un arreglo o cadena ser expandido en lugares donde cero o más argumentos
+(para llamadas de función) o elementos (para Array literales) son esperados,
+o a un objeto ser expandido en lugares donde cero o más pares de valores clave
+(para literales Tipo Objeto) son esperados.
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Spread_syntax)
+
+----
+
+### Push Array
+
+El método Array.prototype.push() en JavaScript se utiliza para agregar uno o
+más elementos al final de un array y devuelve la nueva longitud del array.
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/push)
+
+----
+
+### For each
+
+El método forEach() ejecuta la función indicada una vez por
+cada elemento del array
+
+[Documentación](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)