diff --git a/packages/quiz/questions/are-you-familiar-with-styling-svg/pt-BR.mdx b/packages/quiz/questions/are-you-familiar-with-styling-svg/pt-BR.mdx
index ea438f981..c1ea43107 100644
--- a/packages/quiz/questions/are-you-familiar-with-styling-svg/pt-BR.mdx
+++ b/packages/quiz/questions/are-you-familiar-with-styling-svg/pt-BR.mdx
@@ -18,4 +18,4 @@ A coloração básica pode ser feita definindo dois atributos no nó: `fill` e `
   stroke-opacity="0.8" />
 ```
 
-O `fill="purple"` acima é um exemplo de um _atributo apresentacional_. Curiosamente, e ao contrário de estilos embutidos como `style="fill: purple"` que também é um atributo, os atributos de apresentação podem ser [sobrescritos pelo CSS]\(https://css-tricks. estilos de om/presentation-attributes-vs-inline-styles/) definidos em uma folha de estilos. Daí se você fez algo como `svg { fill: blue; }` ele irá substituir o preenchimento roxo que foi definido.
+O `fill="purple"` acima é um exemplo de um _atributo apresentacional_. Curiosamente, e ao contrário de estilos embutidos como `style="fill: purple"` que também é um atributo, os atributos de apresentação podem ser [sobrescritos pelo CSS](https://css-tricks.com/presentation-attributes-vs-inline-styles/) definidos em uma folha de estilos. Daí se você fez algo como `svg { fill: blue; }` ele irá substituir o preenchimento roxo que foi definido.
diff --git a/packages/quiz/questions/can-you-describe-the-main-difference-between-a-foreach-loop-and-a-map-loop-and-why-you-would-pick-one-versus-the-other/pt-BR.mdx b/packages/quiz/questions/can-you-describe-the-main-difference-between-a-foreach-loop-and-a-map-loop-and-why-you-would-pick-one-versus-the-other/pt-BR.mdx
index 64d689a19..31b5a900f 100644
--- a/packages/quiz/questions/can-you-describe-the-main-difference-between-a-foreach-loop-and-a-map-loop-and-why-you-would-pick-one-versus-the-other/pt-BR.mdx
+++ b/packages/quiz/questions/can-you-describe-the-main-difference-between-a-foreach-loop-and-a-map-loop-and-why-you-would-pick-one-versus-the-other/pt-BR.mdx
@@ -13,11 +13,11 @@ Para entender as diferenças entre os dois, vamos ver o que cada função faz.
 
 ```js
 const a = [1, 2, 3];
-const doubled = a. orEach((num, index) => {
+const doubled = a.forEach((num, index) => {
   // Faça algo com num e/ou índice.
 });
 
-// doubled = indefinido
+// doubled = undefined
 ```
 
 ## `map`
@@ -27,7 +27,7 @@ const doubled = a. orEach((num, index) => {
 
 ```js
 const a = [1, 2, 3];
-const doubled = a. ap((num) => {
+const doubled = a.map((num) => {
   return num * 2;
 });
 
diff --git a/packages/quiz/questions/can-you-offer-a-use-case-for-the-new-arrow-greater-function-syntax-how-does-this-new-syntax-differ-from-other-functions/pt-BR.mdx b/packages/quiz/questions/can-you-offer-a-use-case-for-the-new-arrow-greater-function-syntax-how-does-this-new-syntax-differ-from-other-functions/pt-BR.mdx
index dce691c9a..8c343d5a6 100644
--- a/packages/quiz/questions/can-you-offer-a-use-case-for-the-new-arrow-greater-function-syntax-how-does-this-new-syntax-differ-from-other-functions/pt-BR.mdx
+++ b/packages/quiz/questions/can-you-offer-a-use-case-for-the-new-arrow-greater-function-syntax-how-does-this-new-syntax-differ-from-other-functions/pt-BR.mdx
@@ -3,4 +3,4 @@ title: Você pode oferecer um caso de uso para a nova sintaxe de arrow function
 subtitle: Como essa nova sintaxe difere de outras funções?
 ---
 
-Um benefício óbvio das arrow functions é simplificar a sintaxe necessária para criar funções, sem a necessidade da palavra-chave `função`. O `isto` dentro das arrow functions também está ligado ao escopo que é diferente comparado a funções regulares onde o `isto` é determinado pelo objeto que o chama. `this` com escopo léxico é útil ao invocar callbacks, especialmente em componentes React.
+Um benefício óbvio das arrow functions é simplificar a sintaxe necessária para criar funções, sem a necessidade da palavra-chave `function`. O `this` dentro das arrow functions também está ligado ao escopo que é diferente comparado a funções regulares onde o `this` é determinado pelo objeto que o chama. `this` com escopo léxico é útil ao invocar callbacks, especialmente em componentes React.
diff --git a/packages/quiz/questions/create-a-for-loop-that-iterates-up-to-100-while-outputting-fizz-at-multiples-of-3-buzz-at-multiples-of-5-and-fizzbuzz-at-multiples-of-3-and-5/pt-BR.mdx b/packages/quiz/questions/create-a-for-loop-that-iterates-up-to-100-while-outputting-fizz-at-multiples-of-3-buzz-at-multiples-of-5-and-fizzbuzz-at-multiples-of-3-and-5/pt-BR.mdx
index 8ecc35115..6351cfeb2 100644
--- a/packages/quiz/questions/create-a-for-loop-that-iterates-up-to-100-while-outputting-fizz-at-multiples-of-3-buzz-at-multiples-of-5-and-fizzbuzz-at-multiples-of-3-and-5/pt-BR.mdx
+++ b/packages/quiz/questions/create-a-for-loop-that-iterates-up-to-100-while-outputting-fizz-at-multiples-of-3-buzz-at-multiples-of-5-and-fizzbuzz-at-multiples-of-3-and-5/pt-BR.mdx
@@ -8,7 +8,7 @@ Confira esta versão de FizzBuzz por [Paul Irish](https://gist.github.com/jayson
 for (let i = 1; i <= 100; i++) {
   let f = i % 3 == 0,
     b = i % 5 == 0;
-  console. og(f ? (b ? 'FizzBuzz' : 'Fizz') : b ? 'Buzz' : i);
+  console.log(f ? (b ? 'FizzBuzz' : 'Fizz') : b ? 'Buzz' : i);
 }
 ```
 
diff --git a/packages/quiz/questions/describe-block-formatting-context-bfc-and-how-it-works/pt-BR.mdx b/packages/quiz/questions/describe-block-formatting-context-bfc-and-how-it-works/pt-BR.mdx
index 403b2e73e..73af2f343 100644
--- a/packages/quiz/questions/describe-block-formatting-context-bfc-and-how-it-works/pt-BR.mdx
+++ b/packages/quiz/questions/describe-block-formatting-context-bfc-and-how-it-works/pt-BR.mdx
@@ -4,7 +4,7 @@ title: Descrever o contexto de formatação de bloco (BFC) e como ele funciona.
 
 Um Contexto de Formatação de Bloco (BFC) é parte da renderização visual do CSS em uma página da web, no qual os blocos são organizados. Elementos flutuantes, posicionados absolutamente, `inline-blocks`, `table-cells`, `table-captions` e elementos com `overflow` diferente de `visible` (exceto quando esse valor foi propagado para a área visível) estabelecem novos contextos de formatação de bloco.
 
-Saber estabelecer um contexto de formatação de blocos é importante, porque sem fazer isso, a caixa de contenção não conterá [contém filhos flutuados](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Block_formatting_context#Make_float_content_and_alongside_content_the_same_height). Isso é semelhante ao colapso das margens, mas mais insidioso, pois você encontrará caixas inteiras colapsando de maneiras estranhas.
+Saber estabelecer um contexto de formatação de blocos é importante, porque sem fazer isso, a caixa de contenção não [conterá filhos floated](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Block_formatting_context#Make_float_content_and_alongside_content_the_same_height). Isso é semelhante ao colapso das margens, mas mais insidioso, pois você encontrará caixas inteiras colapsando de maneiras estranhas.
 
 Um BFC é uma caixa HTML que atende pelo menos uma das seguintes condições:
 
diff --git a/packages/quiz/questions/describe-pseudo-elements-and-discuss-what-they-are-used-for/pt-BR.mdx b/packages/quiz/questions/describe-pseudo-elements-and-discuss-what-they-are-used-for/pt-BR.mdx
index 7d2b4b2e5..1a724a953 100644
--- a/packages/quiz/questions/describe-pseudo-elements-and-discuss-what-they-are-used-for/pt-BR.mdx
+++ b/packages/quiz/questions/describe-pseudo-elements-and-discuss-what-they-are-used-for/pt-BR.mdx
@@ -15,4 +15,4 @@ Um CSS [pseudo-element](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-
 
 ## Referências
 
--   [Pseudo-elements - CSS ├MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements)
+-   [Pseudo-elements - CSS | MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements)
diff --git a/packages/quiz/questions/describe-the-difference-between-script-async-and-script-defer/pt-BR.mdx b/packages/quiz/questions/describe-the-difference-between-script-async-and-script-defer/pt-BR.mdx
index 907b9f92e..7862cd2a3 100644
--- a/packages/quiz/questions/describe-the-difference-between-script-async-and-script-defer/pt-BR.mdx
+++ b/packages/quiz/questions/describe-the-difference-between-script-async-and-script-defer/pt-BR.mdx
@@ -22,7 +22,7 @@ Se um script depende de um DOM totalmente analisado, o atributo `defer` será ú
 
 -   Geralmente, o atributo `async` deve ser usado para scripts que não são críticos para a renderização inicial da página e não dependem um do outro. enquanto o atributo `defer` deve ser usado para scripts que dependem de / é dependente de outro script.
 -   Os atributos `async` e `defer` são ignorados para scripts que não têm o atributo `src`.
--   `<script>`s com `defer` ou `async` que contêm `document.write()` serão ignorados com uma mensagem como "Uma chamada para o documento.write() de um script externo carregado de forma assíncrona foi ignorado.
+-   `<script>`s com `defer` ou `async` que contêm `document.write()` serão ignorados com uma mensagem como "Uma chamada para o documento.write() de um script externo carregado de forma assíncrona foi ignorada".
 
 ## Referências
 
diff --git a/packages/quiz/questions/describe-z-index-and-how-stacking-context-is-formed/pt-BR.mdx b/packages/quiz/questions/describe-z-index-and-how-stacking-context-is-formed/pt-BR.mdx
index 75bc8485b..32426d818 100644
--- a/packages/quiz/questions/describe-z-index-and-how-stacking-context-is-formed/pt-BR.mdx
+++ b/packages/quiz/questions/describe-z-index-and-how-stacking-context-is-formed/pt-BR.mdx
@@ -10,4 +10,4 @@ Um contexto de empilhamento é um elemento que contém um conjunto de camadas. D
 
 Cada contexto de empilhamento é auto-contido - após o conteúdo do elemento ser empilhado, todo o elemento é considerado na ordem de empilhamento do contexto de empilhamento do pai. Algumas propriedades CSS desencadeiam um novo contexto de empilhamento, como `opacity` menor que 1, `filter` que não é `none`, e `transform` que não é `none`.
 
-_**Nota**: O que exatamente se qualifica um elemento para criar um contexto de empilhamento está listado neste longo conjunto de [rules](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context#The_stacking_context)._
+_**Nota**: O que exatamente qualifica-se como um elemento para criar um contexto de empilhamento está listado neste longo conjunto de [rules](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context#The_stacking_context)._
diff --git a/packages/quiz/questions/es6-template-literals-offer-a-lot-of-flexibility-in-generating-strings-can-you-give-an-example/pt-BR.mdx b/packages/quiz/questions/es6-template-literals-offer-a-lot-of-flexibility-in-generating-strings-can-you-give-an-example/pt-BR.mdx
index 35e1284ba..dd8d99d95 100644
--- a/packages/quiz/questions/es6-template-literals-offer-a-lot-of-flexibility-in-generating-strings-can-you-give-an-example/pt-BR.mdx
+++ b/packages/quiz/questions/es6-template-literals-offer-a-lot-of-flexibility-in-generating-strings-can-you-give-an-example/pt-BR.mdx
@@ -16,7 +16,7 @@ Com os template literals, agora você pode criar a mesma saída assim:
 
 ```js
 const person = {name: 'Tyler', age: 28};
-console.log(`Oi, meu nome é ${person.name} e tenho ${person.age} anos!);
+console.log(`Oi, meu nome é ${person.name} e tenho ${person.age} anos!`);
 // 'Oi, meu nome é Tyler e eu tenho 28 anos!'
 ```
 
@@ -33,7 +33,7 @@ console.log('Esta é a linha um.\nEsta é a linha dois.');
 Ou se você quisesse dividi-lo em várias linhas no seu código, para que você não tenha que rolar até a direita no seu editor de texto para ler uma longa string, você também poderia escrever assim:
 
 ```js
-console.log('Esta é a linha um.\nEsta é a linha dois.');
+console.log('Esta é a linha um.\n' + 'Esta é a linha dois.');
 // Esta é a linha um.
 // Esta é a linha dois.
 ```
diff --git a/packages/quiz/questions/explain-css-sprites-and-how-you-would-implement-them-on-a-page-or-site/pt-BR.mdx b/packages/quiz/questions/explain-css-sprites-and-how-you-would-implement-them-on-a-page-or-site/pt-BR.mdx
index 7cf589c46..42e997939 100644
--- a/packages/quiz/questions/explain-css-sprites-and-how-you-would-implement-them-on-a-page-or-site/pt-BR.mdx
+++ b/packages/quiz/questions/explain-css-sprites-and-how-you-would-implement-them-on-a-page-or-site/pt-BR.mdx
@@ -45,4 +45,4 @@ E pode ser usado no HTML como tal:
 
 ## Referências
 
--   [Implementando sprites de imagem em CSS - CSS: Cascading Style Sheets ├MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Images/Implementing_image_sprites_in_CSS)
+-   [Implementando sprites de imagem em CSS - CSS: Cascading Style Sheets | MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Images/Implementing_image_sprites_in_CSS)
diff --git a/packages/quiz/questions/explain-function-prototype-bind/pt-BR.mdx b/packages/quiz/questions/explain-function-prototype-bind/pt-BR.mdx
index 462abbfc9..22eac7547 100644
--- a/packages/quiz/questions/explain-function-prototype-bind/pt-BR.mdx
+++ b/packages/quiz/questions/explain-function-prototype-bind/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: Explique `Function.prototype.bind`
 ---
 
-> O método `bind()` cria uma nova função que, quando chamada, tem sua palavra-chave this definida para o valor fornecido, com uma determinada sequência de argumentos precedendo qualquer um fornecido quando a nova função é chamada.
+> O método `bind()` cria uma nova função que, quando chamada, tem sua palavra-chave `this` definida para o valor fornecido, com uma determinada sequência de argumentos precedendo qualquer um fornecido quando a nova função é chamada.
 
 _Source: [Function.prototype.bind() - JavaScript | MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Function/bind)_
 
@@ -29,9 +29,9 @@ const boundGetAgeMary = john.getAge.bind(mary);
 console.log(boundGetAgeMary()); // 21
 ```
 
-No exemplo acima, quando o método `getAge` é chamado sem um objeto chamado (como `unboundGetAge`), o valor é 'indefinido' porque o valor 'this' dentro de 'getAge()' se torna o objeto global. `boundGetAge()` tem seu `this` ligado a `john`, portanto pode obter o `idade` de `john`.
+No exemplo acima, quando o método `getAge` é chamado sem um objeto chamado (como `unboundGetAge`), o valor é 'indefinido' porque o valor 'this' dentro de `getAge()` se torna o objeto global. `boundGetAge()` tem seu `this` ligado a `john`, portanto pode obter o `idade` de `john`.
 
-Podemos até usar `getAge` em outro objeto que não é `john`! `boundGetAgeMary` retorna a `idade` de `mary`.
+Podemos até usar `getAge` em outro objeto que não é `john`! `boundGetAgeMary` retorna o `age` (idade) de `mary`.
 
 ## Prática
 
diff --git a/packages/quiz/questions/explain-how-prototypal-inheritance-works/pt-BR.mdx b/packages/quiz/questions/explain-how-prototypal-inheritance-works/pt-BR.mdx
index 4bd03e2b3..dc2f03a16 100644
--- a/packages/quiz/questions/explain-how-prototypal-inheritance-works/pt-BR.mdx
+++ b/packages/quiz/questions/explain-how-prototypal-inheritance-works/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: Explique como funciona a herança de protótipos
 ---
 
-Essa é uma pergunta extremamente comum em entrevistas de JavaScript. Todos os objetos JavaScript têm uma propriedade `__proto__` com exceção de objetos criados com `object.create(null)`, ou seja, uma referência a outro objeto, que é chamado de "protótipo" do objeto. Quando uma propriedade é acessada em um objeto e se a propriedade não é encontrada nesse objeto, o motor de JavaScript olha para o objeto `__proto__`, e o `__proto__` do **proto**`e assim por diante, até que encontre a propriedade definida em um dos`**proto**\`s ou até chegar ao final da cadeia de protótipos. Este comportamento simula a herança clássica, mas é realmente mais de [delegação do que herança](https://davidwalsh.name/javascript-objects).
+Essa é uma pergunta extremamente comum em entrevistas de JavaScript. Todos os objetos JavaScript têm uma propriedade `__proto__` com exceção de objetos criados com `object.create(null)`, ou seja, uma referência a outro objeto, que é chamado de "protótipo" do objeto. Quando uma propriedade é acessada em um objeto e se a propriedade não é encontrada nesse objeto, o motor de JavaScript olha para o objeto `__proto__`, e o `__proto__` do `__proto__` e assim por diante, até que encontre a propriedade definida em um dos `__proto__`s ou até chegar ao final da cadeia de protótipos. Este comportamento simula a herança clássica, mas é realmente mais de [delegação do que herança](https://davidwalsh.name/javascript-objects).
 
 ## Exemplo de Herança de Protótipos
 
diff --git a/packages/quiz/questions/explain-the-difference-between-mutable-and-immutable-objects/pt-BR.mdx b/packages/quiz/questions/explain-the-difference-between-mutable-and-immutable-objects/pt-BR.mdx
index fcffe8c5d..6b3faf504 100644
--- a/packages/quiz/questions/explain-the-difference-between-mutable-and-immutable-objects/pt-BR.mdx
+++ b/packages/quiz/questions/explain-the-difference-between-mutable-and-immutable-objects/pt-BR.mdx
@@ -30,7 +30,7 @@ console.log(myObject.number); // 42
 
 ### Evitar Extensões
 
-Se você quiser evitar que um objeto tenha novas propriedades adicionadas, mas deixando o resto das propriedades do objeto sozinhas, chame `Object. reventExtensões(...)`:
+Se você quiser evitar que um objeto tenha novas propriedades adicionadas, mas deixando o resto das propriedades do objeto sozinhas, chame `Object.preventExtensions(...)`:
 
 ```js
 let myObject = {
diff --git a/packages/quiz/questions/explain-why-the-following-doesnt-work-as-an-iife-function-foo--what-needs-to-be-changed-to-properly-make-it-an-iife/pt-BR.mdx b/packages/quiz/questions/explain-why-the-following-doesnt-work-as-an-iife-function-foo--what-needs-to-be-changed-to-properly-make-it-an-iife/pt-BR.mdx
index 165b6b427..ede31b4f8 100644
--- a/packages/quiz/questions/explain-why-the-following-doesnt-work-as-an-iife-function-foo--what-needs-to-be-changed-to-properly-make-it-an-iife/pt-BR.mdx
+++ b/packages/quiz/questions/explain-why-the-following-doesnt-work-as-an-iife-function-foo--what-needs-to-be-changed-to-properly-make-it-an-iife/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: "Explique porque o seguinte não funciona como um IIFE: `function foo(){ }();`. O que precisa ser alterado para torná-lo corretamente um IIFE?"
 ---
 
-IIFE significa expressões de função imediatamente invocadas. O interpretador JavaScript lê `function foo(){ }(); como `function foo(){ }` e ();`, onde o primeiro é uma declaração de função e o último (um par de parênteses) é uma tentativa de chamar uma função, mas não há nome especificado, portanto, ele retorna `Uncaught SyntaxError: Unexpected token )`.
+IIFE significa expressões de função imediatamente invocadas. O interpretador JavaScript lê `function foo(){ }();` como `function foo(){ }` e `();`, onde o primeiro é uma declaração de função e o último (um par de parênteses) é uma tentativa de chamar uma função, mas não há nome especificado, portanto, ele retorna `Uncaught SyntaxError: Unexpected token )`.
 
 Aqui estão duas maneiras de corrigir que envolve a adição de mais parênteses: `(function foo(){ })()` e `(function foo(){ }())`. Declarações que começam com `function` são consideradas como _function declarations_ ao envolver essa função dentro de `()`, ela se torna uma _function expression_ que pode ser executada com o `()` subsequente. Essas funções não são expostas no escopo global e você pode até omitir o nome delas se não precisar fazer referência a si mesmas dentro do corpo.
 
diff --git a/packages/quiz/questions/explain-your-understanding-of-the-box-model-and-how-you-would-tell-the-browser-in-css-to-render-your-layout-in-different-box-models/pt-BR.mdx b/packages/quiz/questions/explain-your-understanding-of-the-box-model-and-how-you-would-tell-the-browser-in-css-to-render-your-layout-in-different-box-models/pt-BR.mdx
index 06576a709..b815a3960 100644
--- a/packages/quiz/questions/explain-your-understanding-of-the-box-model-and-how-you-would-tell-the-browser-in-css-to-render-your-layout-in-different-box-models/pt-BR.mdx
+++ b/packages/quiz/questions/explain-your-understanding-of-the-box-model-and-how-you-would-tell-the-browser-in-css-to-render-your-layout-in-different-box-models/pt-BR.mdx
@@ -32,4 +32,4 @@ A propriedade box-sizing, que define como as dimensões totais largura e altura
 
 ## Referências
 
--   [O modelo de caixa ct, MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model#the_standard_css_box_model)
+-   [O modelo de caixa | MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model#the_standard_css_box_model)
diff --git a/packages/quiz/questions/how-do-you-serve-your-pages-for-feature-constrained-browsers-what-techniques-processes-do-you-use/pt-BR.mdx b/packages/quiz/questions/how-do-you-serve-your-pages-for-feature-constrained-browsers-what-techniques-processes-do-you-use/pt-BR.mdx
index 2ca52aa84..b1e72274c 100644
--- a/packages/quiz/questions/how-do-you-serve-your-pages-for-feature-constrained-browsers-what-techniques-processes-do-you-use/pt-BR.mdx
+++ b/packages/quiz/questions/how-do-you-serve-your-pages-for-feature-constrained-browsers-what-techniques-processes-do-you-use/pt-BR.mdx
@@ -8,6 +8,6 @@ subtitle: Quais técnicas/processos você usa?
 -   Degradação graciosa: A prática de construir uma aplicação para navegadores modernos, garantindo que ela permaneça funcional em navegadores mais antigos.
 -   Aprimoramento progressivo: A prática de construir uma aplicação para um nível base de experiência do usuário, mas adicionar aprimoramentos funcionais quando um navegador a suporta.
 -   Use [caniuse.com](https://caniuse.com/) para verificar o suporte de recursos.
--   Autoprefixer para inserção automática de prefixo do fornecedor.
+-   Autoprefixer para inserção automática de prefixo do fornecedor (vendor).
 -   Detecção de recursos usando [Modernizr](https://modernizr.com/).
 -   Use as consultas CSS de recursos via [\`@support\`\`](https://developer.mozilla.org/en-US/docs/Web/CSS/@supports)
diff --git a/packages/quiz/questions/how-would-you-approach-fixing-browser-specific-styling-issues/pt-BR.mdx b/packages/quiz/questions/how-would-you-approach-fixing-browser-specific-styling-issues/pt-BR.mdx
index 80505b583..2a2bbcaaa 100644
--- a/packages/quiz/questions/how-would-you-approach-fixing-browser-specific-styling-issues/pt-BR.mdx
+++ b/packages/quiz/questions/how-would-you-approach-fixing-browser-specific-styling-issues/pt-BR.mdx
@@ -4,6 +4,6 @@ title: Como você abordaria a correção de problemas de estilo específicos de
 
 -   Depois de identificar o problema e o navegador problemático, use uma folha de estilo separada que só é carregada quando aquele navegador específico está sendo usado. Essa técnica requer renderização do lado do servidor.
 -   Use bibliotecas como Bootstrap que já lidam com esses problemas de estilo para você.
--   Use o `autoprefixer` para adicionar automaticamente prefixos de fornecedores ao seu código.
+-   Use o `autoprefixer` para adicionar automaticamente prefixos de vendors ao seu código.
 -   Use Reset CSS or Normalize.css.
 -   Se você estiver usando o PostCSS (ou uma biblioteca semelhante de transpilação CSS), pode haver plugins que permitam que você opte por usar a sintaxe CSS moderna (e até mesmo as propostas W3C) que transformará aquelas seções do seu código em código compatível com versões anteriores que funcionarão nos destinos que você definiu.
diff --git a/packages/quiz/questions/what-advantage-is-there-for-using-the-arrow-syntax-for-a-method-in-a-constructor/pt-BR.mdx b/packages/quiz/questions/what-advantage-is-there-for-using-the-arrow-syntax-for-a-method-in-a-constructor/pt-BR.mdx
index 3d6753b42..fb47904d5 100644
--- a/packages/quiz/questions/what-advantage-is-there-for-using-the-arrow-syntax-for-a-method-in-a-constructor/pt-BR.mdx
+++ b/packages/quiz/questions/what-advantage-is-there-for-using-the-arrow-syntax-for-a-method-in-a-constructor/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: Qual é a vantagem de usar a sintaxe de seta para um método em um constructor?
 ---
 
-A principal vantagem de usar uma arrow function como um método dentro de um construtor é que o valor de `this` é definido no momento da criação da função e não pode mudar depois disso. Então, quando o construtor é usado para criar um novo objeto, `this` sempre irá referir-se ao objeto. Por exemplo, digamos que temos um construtor `Person` que toma o primeiro nome como um argumento tem dois métodos para `console.log` esse nome, um como uma função normal e um como uma função de seta:
+A principal vantagem de usar uma arrow function como um método dentro de um construtor é que o valor de `this` é definido no momento da criação da função e não pode mudar depois disso. Então, quando o construtor é usado para criar um novo objeto, `this` sempre irá referir-se ao objeto. Por exemplo, digamos que temos um construtor `Person` que toma o primeiro nome como um argumento tem dois métodos para dar um `console.log` nesse nome, um como uma função normal e um como uma função de seta:
 
 ```js
 const Person = function (firstName) {
diff --git a/packages/quiz/questions/what-are-data-attributes-good-for/pt-BR.mdx b/packages/quiz/questions/what-are-data-attributes-good-for/pt-BR.mdx
index 0e70dfc4d..167d3ca44 100644
--- a/packages/quiz/questions/what-are-data-attributes-good-for/pt-BR.mdx
+++ b/packages/quiz/questions/what-are-data-attributes-good-for/pt-BR.mdx
@@ -4,7 +4,7 @@ title: Para que servem os atributos `data-`?
 
 Antes de os frameworks JavaScript se tornarem populares, os desenvolvedores usavam atributos data- para armazenar dados extras dentro do próprio DOM, sem outros hacks, como atributos não padrão e propriedades extras no DOM. São destinados a armazenar dados personalizados privados para a página ou aplicação, quando não há mais atributos ou elementos apropriados para isso.
 
-Outro caso comum de uso dos atributos `data-` é armazenar informações usadas por bibliotecas ou frameworks de terceiros. Por exemplo, a biblioteca Bootstrap usa atributos de dados para causar `<button>`s executar ações em um modal em outro lugar na página ([example]\(https://getbootstrap. om/docs/5.2/components/modal/#via-data-attributes)).
+Outro caso comum de uso dos atributos `data-` é armazenar informações usadas por bibliotecas ou frameworks de terceiros. Por exemplo, a biblioteca Bootstrap usa atributos de dados para causar `<button>`s executar ações em um modal em outro lugar na página ([example](https://getbootstrap.com/docs/5.2/components/modal/#via-data-attributes)).
 
 ```html
 <button type="button" data-bs-toggle="modal" data-bs-target="#myModal">
diff --git a/packages/quiz/questions/what-are-the-advantages-disadvantages-of-using-css-preprocessors/pt-BR.mdx b/packages/quiz/questions/what-are-the-advantages-disadvantages-of-using-css-preprocessors/pt-BR.mdx
index dd1ef32e4..d7f683d96 100644
--- a/packages/quiz/questions/what-are-the-advantages-disadvantages-of-using-css-preprocessors/pt-BR.mdx
+++ b/packages/quiz/questions/what-are-the-advantages-disadvantages-of-using-css-preprocessors/pt-BR.mdx
@@ -4,7 +4,7 @@ title: Quais são as vantagens / desvantagens de usar pré-processadores CSS?
 
 ## Vantagens
 
--   O CSS é tornando mais fácil de ser mantido.
+-   O CSS é fica mais fácil de ser mantido.
 -   Mais fácil escrever seletores aninhados.
 -   Variáveis para temas consistentes. Pode-se compartilhar arquivos de tema entre diferentes projetos. Isso não é necessariamente útil com propriedades personalizadas CSS (frequentemente chamadas de variáveis CSS).
 -   Mixins para gerar CSS repetido.
diff --git a/packages/quiz/questions/what-are-the-differences-between-variables-created-using-let-var-or-const/pt-BR.mdx b/packages/quiz/questions/what-are-the-differences-between-variables-created-using-let-var-or-const/pt-BR.mdx
index 76f8cebce..208526984 100644
--- a/packages/quiz/questions/what-are-the-differences-between-variables-created-using-let-var-or-const/pt-BR.mdx
+++ b/packages/quiz/questions/what-are-the-differences-between-variables-created-using-let-var-or-const/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: Quais são as diferenças entre as variáveis criadas usando `let`, `var` ou `const`?
 ---
 
-Variáveis declaradas usando a palavra-chave `var` têm escopo à função na qual foram criadas, ou se criadas fora de qualquer função, ao objeto global. `let` and `const` são _block scoped_, o que significa que eles só são acessíveis dentro do conjunto mais próximo de chaves (função, if-else bloco ou for-loop).
+Variáveis declaradas usando a palavra-chave `var` têm escopo à função na qual foram criadas, ou se criadas fora de qualquer função, ao objeto global. `let` and `const` são _block scoped_, o que significa que eles só são acessíveis dentro do conjunto mais próximo de chaves (função, bloco if-else ou for-loop).
 
 ```js
 function foo() {
diff --git a/packages/quiz/questions/what-does-a-doctype-do/pt-BR.mdx b/packages/quiz/questions/what-does-a-doctype-do/pt-BR.mdx
index f608b0cce..4a9774ecc 100644
--- a/packages/quiz/questions/what-does-a-doctype-do/pt-BR.mdx
+++ b/packages/quiz/questions/what-does-a-doctype-do/pt-BR.mdx
@@ -6,6 +6,6 @@ title: O que um `DOCTYPE` faz?
 
 Um DTD define como documentos de um determinado tipo devem ser estruturados (por exemplo, um `button` pode conter um `span` mas não um `div`), ao passo que um DOCTYPE declara o que DTD um documento _supostamente_ respeita (ex.: este documento respeita o HTML DTD).
 
-Para páginas web, a declaração DOCTYPE é necessária. É usado para dizer aos agentes do usuário qual versão das especificações HTML o seu documento respeita. Uma vez que um agente de usuário tenha reconhecido um DOCTYPE correto, ele acionará o **modo no-quirk** correspondente a este DOCTYPE para ler o documento. Se um agente de usuário não reconhecer um DOCTYPE correto, ele ativará o **modo de peculiaridade**.
+Para páginas web, a declaração DOCTYPE é necessária. É usado para dizer aos agentes do usuário qual versão das especificações HTML o seu documento respeita. Uma vez que um agente de usuário tenha reconhecido um DOCTYPE correto, ele acionará o **modo no-quirk** correspondente a este DOCTYPE para ler o documento. Se um agente de usuário não reconhecer um DOCTYPE correto, ele ativará o **modo de peculiaridade** (quirks mode).
 
 A declaração DOCTYPE para os padrões HTML5 é `<!DOCTYPE html>`.
diff --git a/packages/quiz/questions/what-does-box-sizing-border-box-do-what-are-its-advantages/pt-BR.mdx b/packages/quiz/questions/what-does-box-sizing-border-box-do-what-are-its-advantages/pt-BR.mdx
index b75bf4251..64dcf2a1f 100644
--- a/packages/quiz/questions/what-does-box-sizing-border-box-do-what-are-its-advantages/pt-BR.mdx
+++ b/packages/quiz/questions/what-does-box-sizing-border-box-do-what-are-its-advantages/pt-BR.mdx
@@ -7,7 +7,7 @@ subtitle: Quais as vantagens?
 
 ## Qual é a diferença?
 
-Por padrão, os elementos têm `box-sizing: content-box` aplicado, e apenas o tamanho do conteúdo está sendo contabilizado se um elemento tem `height` e `width` especificados. `box-sizing: border-box` altera como a `width` e `height` dos elementos estão sendo calculadas, a `border` e o `padding` também são incluídos no cálculo. O `height` de um elemento é agora calculado pelo conteúdo `height` + vertical `padding` + `border` horizontal. A `width` de um elemento é agora calculada pela `width` do conteúdo + `padding` horizontal + largura da horizontal `border`.
+Por padrão, os elementos têm `box-sizing: content-box` aplicado, e apenas o tamanho do conteúdo está sendo contabilizado se um elemento tem `height` e `width` especificados. `box-sizing: border-box` altera como a `width` e `height` dos elementos estão sendo calculadas, a `border` e o `padding` também são incluídos no cálculo. O `height` de um elemento é agora calculado pelo conteúdo `height` + `padding` vertical + `border` horizontal. A `width` de um elemento é agora calculada pela `width` do conteúdo + `padding` horizontal + largura da horizontal `border`.
 
 A tabela a seguir indica se a propriedade é incluída ou não no cálculo da altura e largura do elemento quando ele tem o respectivo `box-sizing`:
 
diff --git a/packages/quiz/questions/what-existing-css-frameworks-have-you-used-locally-or-in-production-how-would-you-changeimprove-them/pt-BR.mdx b/packages/quiz/questions/what-existing-css-frameworks-have-you-used-locally-or-in-production-how-would-you-changeimprove-them/pt-BR.mdx
index 199ce4227..273b67b20 100644
--- a/packages/quiz/questions/what-existing-css-frameworks-have-you-used-locally-or-in-production-how-would-you-changeimprove-them/pt-BR.mdx
+++ b/packages/quiz/questions/what-existing-css-frameworks-have-you-used-locally-or-in-production-how-would-you-changeimprove-them/pt-BR.mdx
@@ -4,5 +4,5 @@ subtitle: Como você mudaria/melhoraria eles?
 ---
 
 -   **Bootstrap**: Ciclo de lançamento lento. Bootstrap 4 está em alfa há quase 2 anos. As versões futuras do Bootstrap deveriam incluir um componente de botão spinner, já que ele é amplamente utilizado.
--   **Semantic UI**:: A estrutura do Código Fonte torna a personalização do tema extremamente difícil de entender. Seu sistema de theming não convencional é difícil de personalizar. Caminho de configuração hardcoded dentro da biblioteca do fornecedor. Não é bem projetado para substituir variáveis, ao contrário do Bootstrap.
+-   **Semantic UI**:: A estrutura do Código Fonte torna a personalização do tema extremamente difícil de entender. Seu sistema de theming não convencional é difícil de personalizar. Caminho de configuração hardcoded dentro da biblioteca do fornecedor (vendor). Não é bem projetado para substituir variáveis, ao contrário do Bootstrap.
 -   **Bulma**: Muitas classes e marcações não semânticas e supérfluas são necessárias. Não é compatível com versões anteriores. Atualizar as versões do Bulma pode quebrar o aplicativo de maneiras sutis.
diff --git a/packages/quiz/questions/what-is-a-closure-and-how-why-would-you-use-one/pt-BR.mdx b/packages/quiz/questions/what-is-a-closure-and-how-why-would-you-use-one/pt-BR.mdx
index 2b5bf7808..0f677db96 100644
--- a/packages/quiz/questions/what-is-a-closure-and-how-why-would-you-use-one/pt-BR.mdx
+++ b/packages/quiz/questions/what-is-a-closure-and-how-why-would-you-use-one/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: O que é um closure e como/por que você usaria um?
 ---
 
-Uma closure é a combinação de uma função e o ambiente léxico dentro do qual essa função foi declarada. A palavra "léxico" refere-se ao fato de que o escopo léxico usa o local onde uma variável é declarada dentro do código fonte para determinar onde essa variável está disponível. Cllosures são funções que têm acesso às variáveis—do—escopo da função externa (envolvente) mesmo após a função externa ter retornado.
+Uma closure é a combinação de uma função e o ambiente léxico dentro do qual essa função foi declarada. A palavra "léxico" refere-se ao fato de que o escopo léxico usa o local onde uma variável é declarada dentro do código fonte para determinar onde essa variável está disponível. Closures são funções que têm acesso às variáveis—do—escopo da função externa (envolvente) mesmo após a função externa ter retornado.
 
 ## Por que você usaria um?
 
diff --git a/packages/quiz/questions/what-is-css-selector-specificity-and-how-does-it-work/pt-BR.mdx b/packages/quiz/questions/what-is-css-selector-specificity-and-how-does-it-work/pt-BR.mdx
index 3817b42d2..a46f00d24 100644
--- a/packages/quiz/questions/what-is-css-selector-specificity-and-how-does-it-work/pt-BR.mdx
+++ b/packages/quiz/questions/what-is-css-selector-specificity-and-how-does-it-work/pt-BR.mdx
@@ -7,7 +7,7 @@ O navegador determina quais estilos mostrar em um elemento, dependendo da especi
 1.  `a` é se estilos inline estão sendo usados. Se a declaração de propriedade é um estilo embutido no elemento, `a` é 1, senão 0.
 2.  `b` é o número de seletores de ID.
 3.  `c` é o número de classes, atributos e seletores de pseudo-classes.
-4.  'd' é o número de tags e seletores de pseudo-elementos.
+4.  `d` é o número de tags e seletores de pseudo-elementos.
 
 A especificidade resultante não é uma única pontuação numérica, mas uma matriz de valores que podem ser comparados por coluna. Ao comparar seletores para determinar qual tem a especificidade mais alta, olhar da esquerda para a direita e comparar o maior valor em cada coluna. Portanto, um valor na coluna 'b' irá substituir valores em colunas 'c' e 'd', não importa o que eles possam ser. Como tal, especificidade de `0, 1, 0, 0` seria maior que um de `0, 0, 10, 10`.
 
diff --git a/packages/quiz/questions/what-is-the-css-display-property-and-can-you-give-a-few-examples-of-its-use/pt-BR.mdx b/packages/quiz/questions/what-is-the-css-display-property-and-can-you-give-a-few-examples-of-its-use/pt-BR.mdx
index 8546798d5..bfe717c90 100644
--- a/packages/quiz/questions/what-is-the-css-display-property-and-can-you-give-a-few-examples-of-its-use/pt-BR.mdx
+++ b/packages/quiz/questions/what-is-the-css-display-property-and-can-you-give-a-few-examples-of-its-use/pt-BR.mdx
@@ -17,8 +17,8 @@ Os valores comuns para a propriedade `display`: `none`, `block`, `inline`, `inli
 | `table-cell`    | Comporta-se como o elemento `<td>`.                                                                                                                                                                                 |
 | `list-item`     | Comporta-se como um elemento `<li>` que lhe permite definir `list-style-type` e `list-style-position`.                                                                                                              |
 
-Para uma lista completa de valores para a propriedade `display`, consulte [CSS Display ├MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/display).
+Para uma lista completa de valores para a propriedade `display`, consulte [CSS Display | MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/display).
 
 ## Referências
 
--   [CSS Display ├MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/display)
+-   [CSS Display | MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/display)
diff --git a/packages/quiz/questions/what-is-the-definition-of-a-higher-order-function/pt-BR.mdx b/packages/quiz/questions/what-is-the-definition-of-a-higher-order-function/pt-BR.mdx
index 3d746f703..498b53729 100644
--- a/packages/quiz/questions/what-is-the-definition-of-a-higher-order-function/pt-BR.mdx
+++ b/packages/quiz/questions/what-is-the-definition-of-a-higher-order-function/pt-BR.mdx
@@ -2,7 +2,7 @@
 title: Qual é a definição de uma função de ordem superior?
 ---
 
-Uma função de ordem superior é qualquer função que recebe uma ou mais funções como argumentos, que ela usa para operar em algum dado e/ou retorna uma função como resultado. As funções de ordem superior têm como objetivo abstrair alguma operação que é realizada repetidamente. O exemplo clássico disso é o map, que recebe como argumentos um array e uma função. O map então usa essa função para transformar cada item no array, retornando um novo array com os dados transformados. Outros exemplos populares em JavaScript são `forEach, `filter`e`reduce`. Uma função de ordem superior não precisa apenas manipular arrays, pois há muitos casos de uso para retornar uma função de outra função. `Function.prototype.bind\` é um exemplo desse tipo em JavaScript.
+Uma função de ordem superior é qualquer função que recebe uma ou mais funções como argumentos, que ela usa para operar em algum dado e/ou retorna uma função como resultado. As funções de ordem superior têm como objetivo abstrair alguma operação que é realizada repetidamente. O exemplo clássico disso é o map, que recebe como argumentos um array e uma função. O map então usa essa função para transformar cada item no array, retornando um novo array com os dados transformados. Outros exemplos populares em JavaScript são `forEach`, `filter` e `reduce`. Uma função de ordem superior não precisa apenas manipular arrays, pois há muitos casos de uso para retornar uma função de outra função. `Function.prototype.bind` é um exemplo desse tipo em JavaScript.
 
 ## Map
 
diff --git a/packages/quiz/questions/what-is-use-strict-what-are-the-advantages-and-disadvantages-to-using-it/pt-BR.mdx b/packages/quiz/questions/what-is-use-strict-what-are-the-advantages-and-disadvantages-to-using-it/pt-BR.mdx
index 6c1eef7ee..16d06bafc 100644
--- a/packages/quiz/questions/what-is-use-strict-what-are-the-advantages-and-disadvantages-to-using-it/pt-BR.mdx
+++ b/packages/quiz/questions/what-is-use-strict-what-are-the-advantages-and-disadvantages-to-using-it/pt-BR.mdx
@@ -1,6 +1,6 @@
 ---
 title: O que é `"use strict";`?
-subtitle: Quais são as vantagens e desvantagens de usar o Ajax?
+subtitle: Quais são as vantagens e desvantagens de usa-lo?
 ---
 
 `'use strict'` é uma declaração usada para habilitar o modo estrito em scripts inteiros ou funções individuais. O modo estrito é uma maneira de optar por uma variante restrita do JavaScript.
diff --git a/packages/quiz/questions/what-language-constructions-do-you-use-for-iterating-over-object-properties-and-array-items/pt-BR.mdx b/packages/quiz/questions/what-language-constructions-do-you-use-for-iterating-over-object-properties-and-array-items/pt-BR.mdx
index f910bceda..0a5c358a0 100644
--- a/packages/quiz/questions/what-language-constructions-do-you-use-for-iterating-over-object-properties-and-array-items/pt-BR.mdx
+++ b/packages/quiz/questions/what-language-constructions-do-you-use-for-iterating-over-object-properties-and-array-items/pt-BR.mdx
@@ -28,13 +28,13 @@ Observe que `obj.hasOwnProperty()` não é recomendado porque não funciona para
 
 ```js
 Object.keys(obj).forEach((property) => {
-  console.log(propriedade);
+  console.log(property);
 });
 ```
 
 `Object.keys()` é um método estático que retornará um array com todos os nomes de propriedade enumerados do objeto que você passa. Uma vez que `Object.keys()` retorna um array, você também pode usar as abordagens de iteração de matriz listadas abaixo para iterar através dele.
 
-_Referência: [Object.keys() - JavaScript ├MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)_
+_Referência: [Object.keys() - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)_
 
 ### `Object.getOwnPropertyNames()`
 
@@ -46,7 +46,7 @@ Object.getOwnPropertyNames(obj).forEach((property) => {
 
 `Object.getOwnPropertyNames()` é um método estático que listará todas as propriedades enumeradas e não-enumeráveis do objeto que você passou. Uma vez que `Object.getOwnPropertyNames()` retorna uma matriz, você também pode usar as abordagens de iteração de matriz listadas abaixo para percorrer a matriz.
 
-_Referência: [Object.keys() - JavaScript ├MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames)_
+_Referência: [Object.keys() - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames)_
 
 ## Arrays
 
@@ -76,17 +76,17 @@ arr.forEach((element, index) => {
 
 O método `Array.prototype.forEach()` pode ser mais conveniente em algumas situações se você não precisar usar o índice e só precisar dos elementos individuais do array. No entanto, o lado negativo é que não se pode parar a iteração a meio do caminho e a função fornecida será executada uma vez nos elementos. Um laço `for` ou uma declaração `for...of` são mais relevantes quando é necessário um controle mais preciso sobre a iteração.
 
-_Referência: [Object.keys() - JavaScript ├MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)_
+_Referência: [Object.keys() - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)_
 
 ### declaração `for...of`
 
 ```js
-for (let elemento of arr) {
+for (let element of arr) {
   console.log(element);
 }
 ```
 
-ES2015 introduz uma nova forma de iterar, o laço `para`, que permite repetir o loop sobre objetos que estejam em conformidade com o [protocolo iterável](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) como `String`, `Array`, `Set`, etc. Ele combina as vantagens do loop `for` e do método `forEach()`. A vantagem do laço `para` é que você pode parar dele, e a vantagem de `forEach()` é que ele é mais conciso que o laço `for` porque você não precisa de uma variável contadora. Com a declaração `para...of`, você obtém a capacidade de quebrar de um laço e uma sintaxe mais concisa.
+ES2015 introduz uma nova forma de iterar, o laço `para`, que permite repetir o loop sobre objetos que estejam em conformidade com o [protocolo iterável](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) como `String`, `Array`, `Set`, etc. Ele combina as vantagens do loop `for` e do método `forEach()`. A vantagem do laço `para` é que você pode parar dele, e a vantagem de `forEach()` é que ele é mais conciso que o laço `for` porque você não precisa de uma variável contadora. Com a declaração `for...of`, você obtém a capacidade de quebrar de um laço e uma sintaxe mais concisa.
 
 A maioria das vezes, prefira o método `.forEach`, mas realmente depende do que você está tentando fazer. Antes do ES2015, usamos laços `for` quando precisávamos encerrar prematuramente o laço usando `break`. Mas agora com ES2015, podemos fazer isso com a declaração `for...of`. Use laços `for` quando você precisar de mais flexibilidade, como incrementar o iterador mais de uma vez por laço.
 
diff --git a/packages/quiz/questions/whats-the-difference-between-a-relative-fixed-absolute-and-statically-positioned-element/pt-BR.mdx b/packages/quiz/questions/whats-the-difference-between-a-relative-fixed-absolute-and-statically-positioned-element/pt-BR.mdx
index f0685305a..f97da0b39 100644
--- a/packages/quiz/questions/whats-the-difference-between-a-relative-fixed-absolute-and-statically-positioned-element/pt-BR.mdx
+++ b/packages/quiz/questions/whats-the-difference-between-a-relative-fixed-absolute-and-statically-positioned-element/pt-BR.mdx
@@ -1,5 +1,5 @@
 ---
-title: Qual é a diferença entre um elemento `relative`, `fixed`, `absolute` e `static`-ally posicionado?
+title: Qual é a diferença entre um elemento com posicionamento `relative`, `fixed`, `absolute` e `static`?
 ---
 
 Um elemento posicionado é um elemento cuja propriedade `position` calculada é `relative`, `absolute`, `fixed` ou `sticky` calculada.
diff --git a/packages/quiz/questions/whats-the-difference-between-host-objects-and-native-objects/pt-BR.mdx b/packages/quiz/questions/whats-the-difference-between-host-objects-and-native-objects/pt-BR.mdx
index d62375ead..6ae4b37d0 100644
--- a/packages/quiz/questions/whats-the-difference-between-host-objects-and-native-objects/pt-BR.mdx
+++ b/packages/quiz/questions/whats-the-difference-between-host-objects-and-native-objects/pt-BR.mdx
@@ -1,5 +1,5 @@
 ---
-title: Qual é a diferença entre objetos hospedeiros e objetos nativos?
+title: Qual é a diferença entre objetos do host e objetos nativos?
 ---
 
 Objetos nativos são objetos que são parte do idioma JavaScript definido pela especificação ECMAScript como `String`, `Math`, `RegExp`, `Object`, `Function`, etc.
diff --git a/packages/quiz/questions/when-would-you-use-document-write/pt-BR.mdx b/packages/quiz/questions/when-would-you-use-document-write/pt-BR.mdx
index 429d368d8..1bd767f4a 100644
--- a/packages/quiz/questions/when-would-you-use-document-write/pt-BR.mdx
+++ b/packages/quiz/questions/when-would-you-use-document-write/pt-BR.mdx
@@ -4,4 +4,4 @@ title: Quando você usaria `document.write()`?
 
 `document.write()` escreve uma string de texto em um fluxo de documento aberto por `document.open()`. Quando o `document.write()` é executado após o carregamento da página, ele chamará o `document.open`, o que limpará todo o documento (`<head>` e `<body>` removidos!) e substitui o conteúdo pelo valor do parâmetro dado. Portanto, geralmente é considerado perigoso e propenso a uso indevido.
 
-Existem algumas respostas online que explicam `documento.write()` está sendo usado no código analítico ou [quando deseja incluir estilos que só devem funcionar se o JavaScript estiver ativado]\(https://www. uirksmode.org/blog/archives/2005/06/three_javascrip_1.html). Ele está até sendo usado em boilerplate HTML5 para [carregar scripts em paralelo e preservar a ordem de execução](https://github.com/paulirish/html5-boilerplate/wiki/Script-Loading-Techniques#documentwrite-script-tag)! No entanto, esses motivos podem estar desatualizados e, atualmente, podem ser alcançados sem o uso do `document.write()`.
+Existem algumas respostas online que explicam `documento.write()` está sendo usado no código analítico ou [quando deseja incluir estilos que só devem funcionar se o JavaScript estiver ativado](https://www.quirksmode.org/blog/archives/2005/06/three_javascrip_1.html). Ele está até sendo usado em boilerplate HTML5 para [carregar scripts em paralelo e preservar a ordem de execução](https://github.com/paulirish/html5-boilerplate/wiki/Script-Loading-Techniques#documentwrite-script-tag)! No entanto, esses motivos podem estar desatualizados e, atualmente, podem ser alcançados sem o uso do `document.write()`.
diff --git a/packages/quiz/questions/why-you-might-want-to-create-static-class-members/pt-BR.mdx b/packages/quiz/questions/why-you-might-want-to-create-static-class-members/pt-BR.mdx
index 7b49066d1..e92778e66 100644
--- a/packages/quiz/questions/why-you-might-want-to-create-static-class-members/pt-BR.mdx
+++ b/packages/quiz/questions/why-you-might-want-to-create-static-class-members/pt-BR.mdx
@@ -1,5 +1,5 @@
 ---
-title: Por que você pode querer criar alunos estáticos?
+title: Por que você pode querer criar membros de classe estáticos?
 ---
 
 Os membros estáticos de classe (propriedades/métodos) não estão ligados a uma instância específica de uma classe e têm o mesmo valor independentemente da instância que está se referindo a ele. Propriedades estáticas geralmente são variáveis de configuração e métodos estáticos são normalmente funções utilitárias puras que não dependem do estado da instância.