agentleFS
Carlososuna11Carlososuna11/claude-skills/skills/careful-destructive-ops/SKILL.md

careful-destructive-ops

Skill0 starsChanged 5 months agoMITView on GitHub

Usar antes de ejecutar comandos difíciles o imposibles de revertir — borrado de archivos/branches/tablas, sobreescritura sin leer, force-push, reset --hard, flags --no-verify/--skip-checks. También al recibir una recomendación de reviewer que contradice una decisión ya acordada con el usuario.

  • Deletes or force-pushes
  • Commits and pushes

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    DELETE de filas, archivos sobreescritos).

    line 23
  2. Distinctive:

    No aplica a: typos, bug fixes, refactors locales, tests — esos van sin preguntar.

    line 152

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Careful Destructive Ops

Overview

Las operaciones destructivas se ejecutan con confirmación explícita, preview cuando aplique, y diagnóstico antes que bypass. Nunca usar un shortcut destructivo para "hacer desaparecer" un obstáculo.

Principio: investigar el root cause antes que rodear el síntoma.

Anunciar al inicio: "Operación destructiva detectada (<comando>). Aplicando careful-destructive-ops."

Step 0: ¿La operación es realmente destructiva?

Esta skill aplica a comandos cuyo undo es: imposible, costoso, o visible para otros (commits en main, force-push a branch protegida, DELETE de filas, archivos sobreescritos).

Destructivo siempre:                  NO destructivo:
- rm / rm -rf                         - git reset --soft, git stash
- git reset --hard                    - git push (sin --force)
- git push --force / -f               - git branch -d (refuses if unmerged)
- git branch -D                       - SELECT, UPDATE WHERE específico
- git checkout -- / git restore .     - Append >>
- DROP TABLE / TRUNCATE / DELETE all  - kill (SIGTERM)
- Sobreescribir con > out             - flags estándar
- killall, kill -9                    - gh repo archive
- --no-verify, --no-gpg-sign
- gh repo delete

Destructivo si el destino YA EXISTE o hay cambios sin commitear:
- mv / cp (sobreescriben sin avisar)
- git checkout <archivo>              (descarta cambios locales del archivo)
- git restore <archivo>               (mismo riesgo)
- Write sobre archivo existente sin Read previo
- > archivo existente

Si la operación cae en cualquier bloque destructivo, seguir los steps. Si está en "NO destructivo", no aplica.

Step 1: Confirmar con el usuario antes de ejecutar

Salvo que el usuario haya autorizado explícitamente este tipo de operación en la conversación actual, detenerse y preguntar. Mostrar:

  1. El comando exacto que se va a ejecutar.
  2. Qué se va a perder/cambiar (archivos, branches, registros).
  3. Por qué hace falta esa operación destructiva específicamente — no un equivalente más seguro.
  4. Si existe alternativa reversible, mencionarla.

"Voy a ejecutar git reset --hard origin/main — esto descarta los 3 commits locales en <branch> (X, Y, Z). Alternativa reversible: git reset --keep que mantiene los archivos no commiteados. ¿Confirmás --hard?"

Si la respuesta no es un sí explícito, no ejecutar.

Step 2: Investigar antes que bypass

Cuando aparece un blocker (hook que falla, test que no pasa, lock file, permission denied), la primera reacción no puede ser un flag que lo evite (--no-verify, --force, rm <lockfile>). El blocker suele señalar un problema real.

Antes de cualquier bypass:

  1. Leer el output completo del error. No skimear.
  2. Reproducir manualmente lo que falló (correr el hook a mano, ejecutar el test individual).
  3. Documentar el mecanismo: qué hace, con qué input, qué output produce vs. el esperado.
  4. Solo si el mecanismo está confirmado y el bypass es realmente inevitable, proceder con confirmación explícita (Step 1).

Confundir recencia con causalidad es el error más común. "Mi cambio X coincide con que falla Y" no prueba que X cause Y — puede solo haberlo expuesto.

Step 3: Manejo de force-push de otros sobre tu branch

Si un git push falla con "rejected (non-fast-forward)" después de que otro contribuidor empujó cambios sobre la misma branch (review absorbing, rebase, squash):

  1. NO hacer git push --force ciego ni rebase ciego.
  2. git fetch origin <branch> — traer su HEAD nuevo.
  3. Inspeccionar:
    git log <local-base>..origin/<branch> --oneline
    git show <each-sha> --stat
  4. Para cada commit nuevo: ¿toca los mismos archivos que tú? ¿cambia signaturas que asumiste? ¿resuelve algo que ya tenías?
  5. Si todo OK: ejecutar git reset --hard origin/<branch> siguiendo Step 1 (mostrar comando + qué se pierde + pedir confirmación) + git cherry-pick <tus-shas>. Resolver conflictos puntuales.
  6. Re-correr tests para confirmar que tus cambios siguen aplicables al HEAD nuevo.
  7. Mencionar en el PR qué cherry-pickeaste para que el otro contribuidor tenga contexto.

Step 4: Verificar branch antes de commit en checkout compartido

Si el repo tiene un checkout principal que comparten varios procesos o agentes (típico en monorepos con scripts concurrentes), antes de cada git add / git commit:

git rev-parse --abbrev-ref HEAD

Confirmar que el branch actual es el esperado. Un proceso paralelo puede haber cambiado el HEAD entre tus edits y tu commit. Recovery si el commit cayó en branch ajeno:

git reflog                              # reconstruir secuencia
git branch -f <mi-branch> <mi-SHA>     # llevar commit a mi branch
git checkout <mi-branch>                # liberar el branch ajeno
git branch -f <branch-ajeno> <SHA-original>  # restaurar el ajeno

Para evitarlo de raíz: usar un git worktree aislado (ver skill use-worktrees).

Step 5: No revertir decisiones del usuario por recomendación de un reviewer

Si un reviewer (Codex, otra Claude, externo) recomienda revertir algo que ya fue acordado explícitamente con el usuario en brainstorming o spec, flagear el conflicto antes de aplicar:

"El reviewer recomienda X (config A), pero acordamos Y (config B) porque <razón documentada>. ¿Cambiamos o mantenemos Y?"

Reviewers operan sobre código aislado, sin contexto de las decisiones previas. Aplicar a ciegas revierte trabajo.

Esto aplica a: config de DataSource/migrations, env behavior, deployment strategy, integration patterns, cualquier decisión arquitectónica del design doc.

No aplica a: typos, bug fixes, refactors locales, tests — esos van sin preguntar.

Quick Reference

SituaciónAcción
rm -rf / git reset --hard / git push --forceStep 1 (confirmar)
Hook falla → tentación de --no-verifyStep 2 (investigar root cause)
Test rojo → tentación de --skip-checksStep 2 (reproducir manual)
Push rechazado "non-fast-forward"Step 3 (fetch + inspect, NO force)
Commit cayó en branch ajenoStep 4 (reflog + branch -f)
Reviewer pide revertir decisión acordadaStep 5 (flagear, no aplicar)
gh repo delete / DROP DATABASEConfirmar 2 veces, backup primero
Sobreescribir archivo (> o Write sin Read previo)Read primero, después Write

Common Mistakes

  • --no-verify por defecto. Los hooks pre-commit existen por razón — ejecutarlos manualmente revela el problema real.
  • git push --force en branches compartidas. Reescribe historia que otros ya pulled. Usar --force-with-lease solo si entendiste qué prevee y por qué.
  • git reset --hard "para empezar de cero". Pierde cambios no commiteados sin recovery. Usar git stash o git reset --keep.
  • Diagnosticar por correlación temporal. "Mi commit fue antes del fallo → es mi causa." Pedirle el mecanismo a tu yo del futuro.
  • Aplicar fix de reviewer sin contextualizar. Si contradice un acuerdo previo, frenar y consultar (Step 5).

Red Flags

Nunca:

  • Ejecutar rm -rf, git reset --hard, git push --force, DROP TABLE sin confirmación explícita del usuario en la conversación actual.
  • Usar --no-verify, --no-gpg-sign, --skip-checks para "hacer pasar" un commit. Si el hook falla, hay un problema real.
  • Asumir que un reviewer tiene contexto que tú sí tienes. Si la recomendación contradice un acuerdo previo, frenar.
  • Hacer un segundo hotfix si el primero falló sin entender por qué falló el primero.
  • Pushear a main directamente si el repo tiene staging — verificar el base branch siempre antes de mergear.

Siempre:

  • Reproducir el problema localmente antes de hotfix a prod.
  • Verificar el branch con git rev-parse --abbrev-ref HEAD antes de commit cuando el checkout es compartido.
  • Mostrar el comando exacto + qué se pierde + alternativa reversible antes de pedir confirmación.
  • Investigar el mecanismo del error antes de cualquier bypass.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.