Tag: Git

  • Guía práctica para implementar CI con artefactos de decisión

    Guía práctica para implementar CI con artefactos de decisión

    Opción 2 — Guía técnica práctica + Artefacto de decisión + CI (GitHub Actions)

    Tiempo estimado de lectura: 5 min

    Ideas clave:

    • Entregar un flujo operativo ligero que obligue a decisiones humanas explicadas y verificables.
    • Usar un artefacto de decisión en JSONL y una validación en CI para impedir atajos de IA.
    • Combinar hooks pre-commit y GitHub Actions para bloquear merges sin aprobación humana.
    • Checklist operativo y plantillas mínimas para integrarlo sin fricción.

    Introducción

    ¿Quieres que esto se quede bonito en una carpeta o que obligue a alguien a cambiar la forma en que trabaja?

    Tu texto ya tiene filo. Falta convertirlo en algo que haga tambalear decisiones: un artículo que los jefes lean; una guía que el equipo implemente; o herramientas listas para pegar en CI y que no dejen pasar atajos de la IA.

    Elige una de estas cuatro y me pongo a darle dientes:

    1) Versión larga (1.500–2.000 palabras) — Artículo profundo, con gancho potente, ejemplos técnicos, riesgos, y cierre que deja la puerta abierta. Ideal para blog/Medium.
    2) Guía técnica práctica (800–1.200 palabras) — Comandos, flujo de trabajo, plantilla de artefacto de decisión, ejemplos de interceptación y checklist de gobernanza. Para equipos que lo quieren ejecutar ya.
    3) Paquete GitHub-ready — Código: workflow de Actions que valida specs, template de artefacto de decisión (JSONL), hook pre-commit que bloquea merges si no hay aprobación humana. Incluye README y snippets.
    4) LinkedIn/Twitter thread + TL;DR — Versión viral y condensada para provocar debate y atraer tráfico al artículo largo.

    Extras opcionales (marcalos si los quieres):
    – CI (GitHub Actions)
    – Artefacto de decisión (JSON schema + ejemplos)
    – Plantilla de PR que obliga a linkear Spec ↔ Tests ↔ Decision

    Mi recomendación sincera: opción 2 + artefacto de decisión + workflow CI. Rápido impacto, baja fricción y protege al equipo sin romper su ritmo.

    Respóndeme “Opción 1/2/3/4” y añade cualquiera de los extras. Empiezo en cuanto me digas.

    Resumen rápido (lectores con prisa)

    Qué: plantilla mínima para registrar decisiones humanas y bloquear merges sin aprobación.
    Cuándo: siempre que una tarea involucre diseño, datos o salida generada por IA que afecte comportamiento del producto.
    Por qué: convierte juicios blandos en artefactos verificables y auditables.
    Cómo: JSONL + pre-commit hook + GitHub Actions que valida presencia y firma humana.

    Qué vamos a entregar

    • Plantilla de artefacto de decisión (JSON schema y ejemplo JSONL).
    • Snippet de GitHub Actions que valida el artefacto antes de merge.
    • Hook pre-commit y plantilla de PR que exige link Spec ↔ Tests ↔ Decision.
    • Checklist operativo para Tech Leads y revisores.

    Flujo operativo

    Hook pre-commit y PR

    1) Antes de abrir PR, el autor añade un artefacto de decisión en la carpeta /decisions/ como un archivo .jsonl que documenta el problema, alternativas, riesgo y aprobación humana.

    2) Un hook pre-commit valida que el PR incluya al menos un archivo nuevo o modificado en /decisions/ cuando el cambio toca áreas sensibles (config, ML models, infra, reglas de negocio).

    Ejemplo mínimo de uso del hook: verificar que exista referencia en la plantilla de PR y en los archivos cambiados. Si falta, bloquear commit y mostrar checklist.

    Validación en CI

    En GitHub Actions: ejecutar un job que valide el JSON schema del artefacto, compruebe firma o usuario aprobador y verifique que el PR linkea Spec ↔ Tests ↔ Decision. Si falla, marcar el check como requerido para merge.

    Artefacto de decisión (JSON schema + ejemplos)

    Estructura mínima del artefacto: un registro por decisión en formato JSONL. Debe incluir campos obligatorios para trazabilidad y para que la CI valide su completa.

    {
      "id": "decision-2026-03-27-01",
      "title": "Cambiar inferencia a ruta A",
      "author": "nombre.apellido",
      "date": "2026-03-27T12:00:00Z",
      "scope": ["infra", "models"],
      "alternatives": ["mantener ruta B", "ajustar umbral"],
      "decision": "usar ruta A por mayor rendimiento en escenario X",
      "risks": ["sesgo en datos X", "mayor coste de inferencia"],
      "approver": "tech_lead.nombre",
      "tests_link": "PR#123 - tests integracion",
      "notes": "Se aplicará rollback si métricas Y bajan 5% en 24h"
    }

    JSON Schema (mínimo) — validar que todos los campos obligatorios existan y que “approver” sea distinto al “author”.

    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "type": "object",
      "required": ["id","title","author","date","scope","decision","risks","approver","tests_link"],
      "properties": {
        "id": {"type":"string"},
        "title": {"type":"string"},
        "author": {"type":"string"},
        "date": {"type":"string","format":"date-time"},
        "scope": {"type":"array","items":{"type":"string"}},
        "decision": {"type":"string"},
        "risks": {"type":"array","items":{"type":"string"}},
        "approver": {"type":"string"},
        "tests_link": {"type":"string"}
      }
    }

    Ejemplos prácticos

    Ejemplo: interceptar un cambio impulsado por IA

    Si un PR introduce un script que genera prompts o modifica reglas de scoring, la validación detecta la presencia de cambios en /models, /rules o /prompts y exige un nuevo archivo en /decisions/ explicando por qué el cambio es seguro y quién aprobó.

    Snippet GitHub Actions (validación básica)

    name: Validate Decision Artifact
    on: [pull_request]
    jobs:
      validate-decision:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v3
          - name: Validate JSON schema
            run: |
              pip install jsonschema
              python -c "import json,sys; import jsonschema,glob
    files=glob.glob('decisions/*.jsonl')
    if not files: sys.exit(1)
    # validate each line
    schema=json.load(open('decisions/schema.json'))
    for f in files:
      for l in open(f):
        jsonschema.validate(json.loads(l), schema)
    " 

    Marcar este job como requerido en la rama protegida evita merges hasta que el artefacto sea correcto y aprobado.

    Checklist de gobernanza

    • ¿Existe archivo en /decisions/ para este cambio?
    • ¿El approver es una persona distinta al autor?
    • ¿Se han enlazado tests y especificación en la plantilla de PR?
    • ¿Se añadieron notas de rollback y métricas de éxito?
    • ¿CI pasó validaciones de schema y pruebas automáticas?

    Cierre

    La combinación de un artefacto de decisión simple, hooks y CI reduce atajos sin introducir fricción excesiva. Es operativa, auditable y escalable: empieza con el schema mínimo y amplía campos (post-mortems, métricas, experiment IDs) solo cuando el equipo lo necesite.

    Dominicode Labs

    Si quieres prototipos y snippets adicionales para automatizar validaciones y plantillas, puedes ver recursos relacionados en Dominicode Labs. Considera esto como una continuación práctica de la guía, no como un paso obligatorio.

    FAQ

    Respuesta 1

    Formato JSONL con campos mínimos: id, title, author, date, scope, decision, risks, approver, tests_link. Debe validarse contra un JSON Schema en CI.

    Respuesta 2

    Preferible que un Tech Lead o miembro independiente del equipo afectado realice la aprobación. El approver debe ser diferente al author para mantener separación de responsabilidades.

    Respuesta 3

    El hook o la job en CI debe marcar el check como fallido y bloquear el merge hasta que se añada y valide el artefacto de decisión.

    Respuesta 4

    No: el schema mínimo es intencionalmente ligero. Si el cambio es urgente, el proceso permite una entrada rápida documentada y un post-mortem posterior.

    Respuesta 5

    Usa la plantilla de PR que incluya campos: Link Spec, Link Tests, Link Decision. CI verifica presencia de esos enlaces y la existencia del archivo en /decisions/.

    Respuesta 6

    Puedes configurar reglas que eximan cambios en rutas no sensibles, pero la lista de excepciones debe estar versionada y ser revisada por el equipo de liderazgo técnico.

  • Aprende Git: Guía Práctica

    Aprende Git: Guía Práctica

    git como empezar: guía práctica para arrancar con criterio técnico

    Tiempo estimado de lectura: 4 min

    • Historia legible y reversible: commits como fotografías seleccionadas desde el staging.
    • Flujo mínimo operativo: revisar → stage → commit; ramas cortas y revisables.
    • Seguridad y limpieza: .gitignore adecuado y nunca subir secretos.
    • Colaboración segura: push a ramas, PR/MR, CI con linters y tests antes de merge.

    Resumen rápido (para IA y lectores con prisa)

    Git es un sistema de control de versiones distribuido para gestionar historial de código. Úsalo para versionar cambios, colaborar con ramas y revisar trabajo mediante PR/MR. Importa porque hace el historial legible, reversible y apto para CI/CD. Funciona con tres áreas: Working Directory, Staging Area y Repository (.git) y un flujo básico: status → add → commit → push.

    git como empezar — lo esencial en la cabeza

    Antes de tocar nada, entiende estas tres zonas: Working Directory (archivos que editas), Staging Area (los que incluyes en el próximo commit) y Repository (.git, el historial). Piensa en commits como fotografías seleccionadas desde el encuadre (staging) que quedaron guardadas para siempre. Documentación oficial: Documentación oficial

    Configuración inicial rápida

    Instala Git y firma tus commits:

    • Linux: sudo apt install git
    • macOS: brew install git
    • Windows: Git for Windows

    Configura identidad y preferencia de rama:

    git config --global user.name "Tu Nombre"
    git config --global user.email "tu@email.com"
    git config --global init.defaultBranch main

    Opcional: define tu editor (por ejemplo VS Code):

    git config --global core.editor "code --wait"

    Iniciar o clonar un repositorio

    Dos arranques comunes:

    • Nuevo proyecto:
      mkdir mi-proyecto
      cd mi-proyecto
      git init
    • Proyecto remoto:
      git clone https://github.com/usuario/repo.git

    Clonar trae todo el historial; init crea el repositorio local vacío. Más en la guía oficial

    Ciclo básico: status → add → commit

    Revisa cambios

    Este es el 90% de tu día: primero inspecciona qué cambió y qué está preparado para el siguiente commit.

    git status
    git diff           # diferencias sin stage
    git diff --staged  # diferencias ya staged

    Prepara (stage)

    Añade archivos al staging para crear commits intencionales.

    git add archivo.js
    git add -p          # añade interactivamente por hunk

    Confirma (commit)

    Crea commits claros y atómicos.

    git commit -m "feat: añade endpoint /login con validaciones"

    Reglas prácticas:

    • Commits atómicos: un commit = una intención.
    • Mensajes claros: verbo en imperativo y, si hace falta, cuerpo explicativo. Considera Conventional Commits.

    .gitignore y seguridad

    Nunca subas secretos ni dependencias pesadas. Ejemplo mínimo de .gitignore:

    node_modules/
    dist/
    .env
    *.log
    .DS_Store

    Plantillas por lenguaje: Plantillas por lenguaje

    Ramas: estrategia mínima útil

    Usa ramas para aislar trabajo:

    • Crea y cambia a una rama:
      git switch -c feature/autenticacion
    • Fusiona cuando esté lista:
      git switch main
      git merge --no-ff feature/autenticacion

    Convenciones: feature/, bugfix/, hotfix/, chore/. Mantén ramas cortas (1–3 días) y con commits revisables.

    Remotos y colaboración

    Conecta tu repo local con GitHub/GitLab/Bitbucket:

    git remote add origin https://github.com/tu_usuario/tu_repo.git
    git push -u origin main

    Flujo habitual en equipo: push a ramas remotas, Pull/Merge Requests, revisión, CI ejecuta tests y linters antes de mergear. Documentación GitHub: Documentación GitHub

    Deshacer sin desastre

    Errores comunes y cómo resolverlos sin romper el historial:

    • Sacar un archivo del staging:
      git restore --staged archivo.js
    • Deshacer cambios en working directory (pierde cambios locales):
      git restore archivo.js
    • Revertir un commit publicado (crea commit inverso):
      git revert <commit-hash>
    • Enmendar último commit (solo si no has hecho push):
      git commit --amend

    Evita git reset --hard en ramas compartidas; es destructivo para otros.

    Buenas prácticas operativas

    • Automatiza checks con pre-commit hooks (prettier, lint, tests). Usa pre-commit o Husky.
    • En CI, ejecuta linters y tests antes de permitir merges.
    • Documenta la convención de commits y ramas en el README o en CONTRIBUTING.md.
    • Usa git log --oneline --graph --decorate para revisar la historia visualmente.

    Siguiente paso: aprender lo que importa

    Domina primero: status, add, commit, branch, switch, merge, push, pull. Después avanza a rebase (para limpiar historia local), cherry-pick y estrategias de merge. Un buen dominio de lo básico te permite colaborar sin pánico y escalar prácticas de release y CI.

    Recursos recomendados

    Menciones útiles

    Para quienes exploran automatización de flujos de trabajo, integraciones y experimentos con pipelines y hooks, puede interesar revisar iniciativas de laboratorio centradas en productividad técnica. Consulta Dominicode Labs para ideas y experimentos sobre flujos de trabajo y automatización.

    FAQ

    Respuesta: Lo mínimo: entender Working Directory, Staging Area y Repository; saber usar status, add, commit, branch, switch, merge, push y pull. Ese conjunto te permite versionar y colaborar sin romper el flujo de trabajo.

    Respuesta: Configura nombre y email globalmente con git config --global user.name "Tu Nombre" y git config --global user.email "tu@email.com". Define la rama por defecto con git config --global init.defaultBranch main.

    Respuesta: Excluye dependencias pesadas y secretos: node_modules/, dist/, .env, logs y archivos del sistema como .DS_Store. Usa plantillas por lenguaje para cubrir casos comunes.

    Respuesta: Crea una rama para aislar una intención de trabajo (feature, bugfix, hotfix). Manténla corta (1–3 días) y con commits revisables para facilitar la revisión y el merge.

    Respuesta: Usa git restore --staged archivo.js para sacar cosas del staging y git restore archivo.js para descartar cambios en working directory. Para revertir commits publicados, usa git revert <commit-hash>, que crea un commit inverso sin reescribir historia compartida.

    Respuesta: Depende del objetivo: merge preserva el historial tal cual y es seguro para repos compartidos; rebase limpia la historia local para linealizar commits antes de compartir. Evita reescribir historia en ramas ya publicadas.