Nivel inicial11 min de lectura · Publicado el

Regla del Boy Scout en el código limpio, con ejemplo

Regla del Boy Scout: en una cocina compartida, cada taza sucia es un nombre confuso o un if de más, y cada persona que pasa lava una taza más. Un poco mejor en cada commitrubentejera.com nombre confusoif de másuna taza másen su propio commit
Cada taza sucia es un nombre confuso, un if de más o un duplicado. Si cada persona que pasa lava una taza más, una mejora pequeña en su propio commit y con los tests en verde, la cocina no llega a ensuciarse.

No basta con escribir código correctamente. El código debe limpiarse con el tiempo.

La frase de los Boy Scouts «déjalo mejor de como lo encontraste» es una regla que se puede aplicar a nuestro código.

Si todos los días entregamos el código un poco más limpio de como lo hemos recibido, el proyecto irá mejorando con el tiempo. Es uno de los principios del código limpio (clean code), que se resumen con un ejemplo cada uno en su guía.

Déjalo un poco mejor de como lo encontraste.

Qué es la regla del Boy Scout

Piensa en una cocina compartida en una oficina. Nadie la ensucia a propósito, pero cada uno deja una taza «para luego». En un mes, no hay quien entre. Si cada persona que pasa lava una taza más de las suyas, la cocina se mantiene limpia sin que nadie dedique una tarde entera a ello.

Con el código pasa lo mismo. Cada cambio con prisas deja algo un poco peor: un nombre confuso, un if dentro de otro, un trozo copiado y pegado. Ninguno es grave por sí solo, pero se acumulan. La regla del Boy Scout propone lo contrario: cada vez que toques un fichero, déjalo algo mejor de lo que estaba.

No pide dejarlo perfecto. Pide una mejora, por pequeña que sea, en cada visita. Es una forma de pagar la deuda técnica poco a poco, sin parar el proyecto para una gran limpieza.

De dónde viene

  • La versión para programadores la popularizó Robert C. Martin. En el capítulo 1 de Clean Code (2008) dedica una sección a «The Boy Scout Rule». Allí dice que no basta con escribir bien el código, que hay que mantenerlo limpio con el tiempo, y presenta como regla de los Boy Scouts de Estados Unidos la de dejar el campamento más limpio de como lo encontraste. La frase de arriba, «No basta con escribir código correctamente», resume esa misma idea.
  • Martin la desarrolló en 97 Things Every Programmer Should Know (O’Reilly, 2010), en un ensayo con el mismo título. Allí la traduce al código: subir siempre un módulo más limpio de como lo descargaste, lo haya escrito quien lo haya escrito.
  • El origen es una frase de Robert Baden-Powell, fundador del escultismo. En ese ensayo, Martin explica que la forma original de la regla es «Intenta dejar este mundo un poco mejor de como lo encontraste». La frase pertenece al último mensaje de Baden-Powell a los scouts, que se dio a conocer tras su muerte en 1941. El texto original completo no se ha localizado; la frase la reproduce la Organización Mundial del Movimiento Scout en su web.
  • Martin Fowler la llama camp site rule (la regla del campamento) en su artículo sobre el refactor oportunista, de 2011.

Que los Boy Scouts de Estados Unidos tengan esa regla con esas palabras lo afirma Martin; no se ha comprobado en un documento de la organización.

Otras frases de programación con su origen comprobado están en frases célebres de programación.

Qué cuenta como «un poco mejor»

En Clean Code, Martin pone ejemplos muy pequeños, y es justo lo que hace que la regla funcione:

  • Cambiar un nombre de variable o de función por otro que diga lo que hace.
  • Partir una función que se ha hecho demasiado larga. Tienes las reglas en Funciones en código limpio.
  • Quitar un duplicado pequeño.
  • Simplificar una condición con varios && y || que cuesta leer.

Si la mejora no cabe en unos minutos, ya no es una limpieza de paso: es un refactor con entidad propia, que conviene planificar. Cómo hacerlo paso a paso, en refactorizar código sin romper nada. Un caso típico es la clase que lo hace todo; para esa tienes God Object: qué es y cómo evitarlo.

Un ejemplo: limpiar antes de cambiar

Te piden añadir una tarifa de envío para Portugal. Abres el fichero y te encuentras esto:

// envio.js (antes)
export function gastosDeEnvio(p) {
  let r = 0;
  if (p.pais === 'ES') {
    if (p.total >= 50) {
      r = 0;
    } else {
      r = 4.95;
    }
  } else {
    if (p.total >= 50) {
      r = 9.95;
    } else {
      r = 14.95;
    }
  }
  return r;
}

Funciona, pero p, r y ese 50 sin nombre obligan a pensar. Y si metes Portugal aquí, el anidamiento crece. Es buen momento para aplicar la regla, en tres pasos y tres commits.

  1. Asegura el comportamiento actual con tests.
  2. Limpia sin cambiar lo que hace, con los tests en verde.
  3. Añade la funcionalidad nueva, con su test primero.

1. Tests que fijan lo que ya hace

Antes de tocar nada, necesitas una red: tests que digan qué hace hoy la función. Si no existen, escríbelos tú. Aquí se usa el test runner que trae Node, sin instalar nada:

// envio.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { gastosDeEnvio } from './envio.js';

test('España: gratis a partir de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'ES', total: 50 }), 0);
});

test('España: 4,95 € por debajo de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'ES', total: 49.99 }), 4.95);
});

test('Resto de países: 9,95 € a partir de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'FR', total: 50 }), 9.95);
});

test('Resto de países: 14,95 € por debajo de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'FR', total: 10 }), 14.95);
});

Con "type": "module" en el package.json, lánzalos con:

node --test
✔ España: gratis a partir de 50 €
✔ España: 4,95 € por debajo de 50 €
✔ Resto de países: 9,95 € a partir de 50 €
✔ Resto de países: 14,95 € por debajo de 50 €
ℹ tests 4
ℹ pass 4
ℹ fail 0

Commit: test: fija el comportamiento actual de gastosDeEnvio.

2. El refactor, y nada más

Ahora limpias. Nombres que se explican solos, el 50 con nombre y sin if dentro de otro if:

// envio.js (después del refactor)
const PEDIDO_MINIMO_ENVIO_REDUCIDO = 50;

export function gastosDeEnvio(pedido) {
  const superaElMinimo = pedido.total >= PEDIDO_MINIMO_ENVIO_REDUCIDO;

  if (pedido.pais === 'ES') {
    return superaElMinimo ? 0 : 4.95;
  }
  return superaElMinimo ? 9.95 : 14.95;
}

Los cuatro tests siguen en verde y no has cambiado ni uno: la función hace exactamente lo mismo, pero se lee mejor. El nombre de la función lo dejas igual porque ya dice lo que hace y otros ficheros la usan.

Commit: refactor: aclara nombres y quita anidamiento en gastosDeEnvio.

3. Ahora sí, la funcionalidad

Primero los dos tests nuevos, que fallan:

test('Portugal: 6,95 € por debajo de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'PT', total: 30 }), 6.95);
});

test('Portugal: gratis a partir de 50 €', () => {
  assert.equal(gastosDeEnvio({ pais: 'PT', total: 50 }), 0);
});

Y después el cambio, que en el código limpio es una rama más fácil de leer:

  if (pedido.pais === 'PT') {
    return superaElMinimo ? 0 : 6.95;
  }

Con los seis tests en verde, commit: feat: tarifa de envío para Portugal.

La regla del Boy Scout en tres pasos y tres commits. 1, tests: fijan lo que ya hace gastosDeEnvio, 4 tests en verde; commit «test: fija el comportamiento actual de gastosDeEnvio». 2, refactor: limpia sin cambiar lo que hace, con los mismos 4 tests en verde; commit «refactor: aclara nombres y quita anidamiento en gastosDeEnvio». 3, funcionalidad: Portugal, con sus tests primero: los dos tests nuevos fallan, y después 6 tests en verde; commit «feat: tarifa de envío para Portugal».
Los tres pasos del ejemplo, de arriba abajo. Cada uno termina en su propio commit, los puntos de la línea de la izquierda, y ninguno empieza hasta que los tests del anterior están en verde.

Sus límites

No mezcles limpieza y cambio en el mismo commit

Es el error más común al aplicar la regla. Un commit que renombra veinte variables y además cambia un cálculo es casi imposible de revisar: el cambio importante se esconde entre los cosméticos.

Kent Beck llama tidyings a estas limpiezas pequeñas y lo trata en su boletín Tidy First?: cuando se han mezclado con un cambio de comportamiento, una de sus opciones es separarlas en pull requests distintas o, al menos, en commits distintos. Martin Fowler añade otra condición: refactoriza solo con los tests en verde.

Pide permiso en código ajeno

Martin plantea la regla sin importar quién escribió el módulo, y dentro de tu equipo tiene sentido: el código es de todos. Fuera de ese círculo, conviene ser más prudente:

  • Código de otro equipo, una librería o un proyecto de código abierto: propón la mejora en un issue o en una pull request aparte. No la cueles dentro de tu cambio.
  • Código que alguien está tocando ahora mismo: avisa antes. Dos personas reordenando el mismo fichero acaban en un conflicto de merge.
  • Código sin tests: primero los tests. Limpiar sin red es cambiar a ciegas. Para fijar lo que ya hace, escribe tests de caracterización.

No lo conviertas en una reescritura

«Un poco mejor» no es «como tú lo habrías hecho». Si cada visita reescribe medio módulo, la regla deja de ser barata y empieza a romper cosas.

La regla del Boy Scout cuando el código lo escribe una IA

Esta sección es criterio propio del enfoque IA Limpia, no algo que haya escrito Martin. La regla se pensó para personas que tocan un fichero de vez en cuando. Con un agente de IA, el código cambia mucho más deprisa, y eso vale en los dos sentidos: puede ensuciar más rápido o limpiar más rápido.

  • Lo que entrega la IA también se limpia. Que el código venga de un agente no lo deja fuera de la regla. Antes de hacer commit, revisa lo que ha generado y mejora lo que no se entienda, igual que harías con el de un compañero.
  • Pídele la limpieza como un paso aparte. Primero «mejora los nombres de esta función sin cambiar su comportamiento; los tests deben seguir pasando»; después, en otro paso, el cambio de funcionalidad. Así cada diff se puede revisar.
  • Ponle límites de tamaño. Un agente al que le pides «déjalo mejor» puede reescribir el módulo entero. La regla pide una mejora pequeña, y un cambio pequeño es lo único que una persona puede revisar con calma. Un ejemplo en Java, paso a paso: refactorizar con IA.
  • Los tests mandan. Si el agente tiene que cambiar un test para que su refactor pase, no era un refactor: ha cambiado el comportamiento.
  • Escríbelo en sus instrucciones. Si usas un fichero de instrucciones para el agente, como AGENTS.md o CLAUDE.md (qué poner en ellos), la regla cabe en una línea: limpieza pequeña, tests en verde y commit separado del cambio funcional.

Tu siguiente paso

La próxima vez que abras un fichero para cambiar algo, antes de irte, elige una cosa: un nombre, una condición, un duplicado. Comprueba que los tests siguen en verde y súbela en su propio commit. Mañana, otra.

Fuentes

El ejemplo se ha ejecutado con Node.js 24.21.0 (node --test) y Git 2.53.0, en Linux, el 7 de noviembre de 2026.