1. Skip to content

1. Estrategia de IA y Automatización

Estrategia de adopción de IA en workflows reales: cuándo usar, límites, integración en procesos.

1.1 🤖 Introducción

Qué: Estrategia para integrar IA en workflows de desarrollo sin perder control ni calidad.

Por qué: IA bien usada amplifica productividad 10x. Mal usada genera código frágil, inseguro y difícil de mantener.

Cómo: Definir casos de uso, límites claros, validación rigurosa e integración en procesos existentes.

1.1.1 Filosofía: IA como Amplificador, No Reemplazo

  • IA amplifica: Un senior con IA es 10x más productivo. Un junior con IA sigue siendo junior.
  • Garbage in, garbage out: Prompts vagos → código mediocre
  • Validación crítica: NUNCA confiar ciegamente en código generado por IA
  • Conceptos > Código: IA genera código, pero tú debés entender qué hace y por qué

1.2 🎯 Casos de Uso Prácticos

1.2.1 Code Review Automatizado

Qué hace:

  • Detectar code smells (duplicación, complejidad ciclomática alta)
  • Identificar vulnerabilidades (SQL injection, XSS, secrets expuestos)
  • Sugerir refactorings (extract method, rename variable)

Herramientas:

  • SonarQube + IA: Análisis estático con sugerencias contextuales
  • GitHub Copilot en PRs: Sugerencias de mejoras
  • Custom agents: Agentes especializados en tu stack

Integración:

# .github/workflows/ai-code-review.yml
- name: AI Code Review
  run: |
    # Analizar diff del PR
    git diff origin/main...HEAD > changes.diff
    # Enviar a agente de code review
    ai-agent code-reviewer --input changes.diff --output review.md

Límites:

  • ✅ Detectar patterns obvios (duplicación, complejidad)
  • ❌ Entender contexto de negocio (por qué se tomó una decisión)

1.2.2 Generación de Tests

Qué hace:

  • Generar unit tests para funciones puras
  • Generar test cases (happy path, edge cases, error handling)
  • Generar mocks y fixtures

Ejemplo de prompt:

Genera unit tests con pytest para esta función:

[código]

Incluye:
- Happy path
- Edge cases (input vacío, null, valores extremos)
- Error handling (excepciones esperadas)
- Mocks para dependencias externas

Validación:

  • ✅ Ejecutar tests generados y verificar que pasen
  • ✅ Revisar coverage (debe ser >80%)
  • ❌ Aceptar tests que solo testean implementación (no comportamiento)

1.2.3 Documentación Auto-Generada

Qué hace:

  • Generar docstrings a partir de código
  • Generar README a partir de estructura de proyecto
  • Generar API documentation (OpenAPI) a partir de código

Ejemplo:

# Antes (sin docstring)
def calculate_discount(price, customer_type):
    if customer_type == "premium":
        return price * 0.8
    return price * 0.9

# Después (con IA)
def calculate_discount(price: float, customer_type: str) -> float:
    """
    Calculate discounted price based on customer type.

    Args:
        price: Original price before discount
        customer_type: Type of customer ("premium" or "regular")

    Returns:
        Discounted price

    Raises:
        ValueError: If price is negative or customer_type is invalid

    Examples:
        >>> calculate_discount(100, "premium")
        80.0
        >>> calculate_discount(100, "regular")
        90.0
    """
    if price < 0:
        raise ValueError("Price cannot be negative")
    if customer_type not in ["premium", "regular"]:
        raise ValueError(f"Invalid customer type: {customer_type}")

    if customer_type == "premium":
        return price * 0.8
    return price * 0.9

1.2.4 Refactoring Asistido

Qué hace:

  • Detectar código duplicado y sugerir extracción
  • Renombrar variables/funciones con nombres más descriptivos
  • Aplicar design patterns (Strategy, Factory, etc.)

Ejemplo de prompt:

Refactoriza este código aplicando el patrón Strategy para eliminar el switch statement:

[código]

Requisitos:
- Mantener misma interfaz pública
- Agregar tests para cada estrategia
- Documentar el patrón aplicado

1.2.5 Migración de Código

Qué hace:

  • Migrar de un lenguaje a otro (JS → TS, Python 2 → 3)
  • Migrar de un framework a otro (AngularJS → Angular, Class components → Hooks)
  • Actualizar a nuevas APIs (deprecated → current)

Validación crítica:

  • 🔴 NUNCA migrar sin tests existentes
  • 🔴 SIEMPRE revisar código migrado línea por línea
  • 🔴 EJECUTAR tests antes y después de migración

1.3 🚫 Límites de la IA

1.3.1 ❌ Qué NO Delegar a IA

Tarea Por qué NO
Decisiones arquitectónicas críticas IA no entiende trade-offs de negocio, escalabilidad futura, constraints organizacionales
Compliance y regulaciones IA puede generar código que viola GDPR, HIPAA, SOC2 sin saberlo
Ethical decisions IA no tiene moral ni contexto social (ej: features que pueden ser usadas para discriminación)
Security-critical code IA puede generar código con vulnerabilidades sutiles (timing attacks, race conditions)
Performance-critical code IA no optimiza para latency/throughput sin contexto específico

1.3.2 ⚠️ Qué Delegar CON Validación Rigurosa

Tarea Validación Requerida
Boilerplate code Revisar que siga convenciones del proyecto
Tests unitarios Ejecutar tests, revisar coverage, verificar que testean comportamiento (no implementación)
Documentación Revisar precisión técnica, claridad, ejemplos correctos
Refactoring Ejecutar tests, revisar que no cambie comportamiento

1.4 📝 Prompt Engineering Avanzado

1.4.1 Chain-of-Thought (CoT)

Hacer que la IA "piense en voz alta" antes de generar código.

Ejemplo:

Antes de generar código, explica paso a paso:
1. Qué problema estamos resolviendo
2. Qué alternativas consideraste
3. Por qué elegiste esta solución
4. Qué trade-offs tiene

Luego genera el código.

Resultado: Código más pensado, con mejor contexto.

1.4.2 Few-Shot Learning

Dar ejemplos de lo que querés antes de pedir la tarea.

Ejemplo:

Genera unit tests siguiendo este estilo:

# Ejemplo 1:
def test_calculate_discount_premium_customer():
    # Given
    price = 100
    customer_type = "premium"

    # When
    result = calculate_discount(price, customer_type)

    # Then
    assert result == 80.0

# Ejemplo 2:
def test_calculate_discount_invalid_customer_type():
    # Given
    price = 100
    customer_type = "invalid"

    # When / Then
    with pytest.raises(ValueError, match="Invalid customer type"):
        calculate_discount(price, customer_type)

Ahora genera tests para esta función:
[código]

1.4.3 Retrieval-Augmented Generation (RAG)

Proveer contexto relevante antes de generar código.

Ejemplo:

Contexto del proyecto:
- Stack: FastAPI + PostgreSQL + SQLAlchemy
- Convenciones: 
  - Usar Pydantic para validación
  - Usar dependency injection para DB session
  - Tests con pytest + pytest-asyncio

Genera un endpoint CRUD para la entidad Product siguiendo estas convenciones.

1.5 ✅ Evaluación de Outputs

1.5.1 AI Output Validation Rubric

Criterio ✅ Pasa ❌ Falla
Correctness Código compila/ejecuta sin errores Syntax errors, runtime errors
Security No vulnerabilidades (OWASP Top 10) SQL injection, XSS, secrets expuestos
Performance No bottlenecks obvios (N+1 queries, loops innecesarios) Complejidad O(n²) donde O(n) es posible
Maintainability Código legible, nombres descriptivos, funciones pequeñas Funciones >50 líneas, nombres crípticos
Testing Tests incluidos, coverage >80% Sin tests o tests que no testean comportamiento
Documentation Docstrings claros, ejemplos correctos Sin docs o docs incorrectos

1.5.2 Checklist de Validación

Antes de aceptar código generado por IA:

  • [ ] Compilar/ejecutar: ¿El código corre sin errores?
  • [ ] Tests: ¿Hay tests? ¿Pasan? ¿Coverage >80%?
  • [ ] Security scan: ¿Pasó SAST/DAST? ¿No hay secrets expuestos?
  • [ ] Code review: ¿Un humano revisó el código?
  • [ ] Performance: ¿No hay bottlenecks obvios?
  • [ ] Convenciones: ¿Sigue el style guide del proyecto?
  • [ ] Documentación: ¿Está documentado? ¿Es preciso?

1.6 🔄 Integración en CI/CD

1.6.1 Pre-Commit Hooks con IA

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: ai-code-review
        name: AI Code Review
        entry: ai-agent code-reviewer
        language: system
        pass_filenames: true

      - id: ai-test-generation
        name: AI Test Generation
        entry: ai-agent test-generator --check-coverage
        language: system
        files: \.py$

1.6.2 Code Suggestions en PRs

# .github/workflows/pr-review.yml
name: AI PR Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: AI Code Review
        run: |
          # Obtener diff del PR
          git diff origin/${{ github.base_ref }}...HEAD > pr.diff

          # Enviar a agente de code review
          ai-agent code-reviewer --input pr.diff --output review.md

      - name: Post Review Comment
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

1.6.3 Automated Refactoring

# .github/workflows/auto-refactor.yml
name: Auto Refactor

on:
  schedule:
    - cron: '0 2 * * 1'  # Lunes a las 2am

jobs:
  refactor:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Detect Code Smells
        run: |
          ai-agent refactorer --detect-smells --output smells.json

      - name: Apply Refactorings
        run: |
          ai-agent refactorer --apply-fixes --input smells.json

      - name: Run Tests
        run: pytest

      - name: Create PR
        if: success()
        uses: peter-evans/create-pull-request@v5
        with:
          title: "🤖 Automated Refactoring"
          body: "AI-suggested refactorings. Review carefully before merging."
          branch: auto-refactor

1.7 📋 Artefactos

1.7.1 AI Adoption Checklist

Decidir si usar IA para una tarea:

Criterio Usar IA NO usar IA
Repetitividad Tarea repetitiva (boilerplate, tests) Tarea única, creativa
Riesgo Bajo riesgo (código no crítico) Alto riesgo (security, compliance)
Complejidad Complejidad baja-media Complejidad alta (arquitectura)
Contexto Contexto claro, bien definido Contexto ambiguo, muchas variables
Validación Fácil de validar (tests, linters) Difícil de validar (ethical decisions)

Ejemplo:

  • ✅ Usar IA: Generar unit tests para función pura
  • ❌ NO usar IA: Decidir arquitectura de microservices vs monolito

1.7.2 Prompt Template Library

1.7.2.1 Template: Code Review

Revisa este código y proporciona feedback organizado por prioridad:

[código]

Checklist:
- Correctness (lógica, edge cases)
- Security (OWASP Top 10)
- Performance (bottlenecks, complejidad)
- Maintainability (legibilidad, nombres, funciones pequeñas)
- Testing (coverage, calidad de tests)

Formato de salida:
## Critical Issues (must fix)
- [issue 1]

## Warnings (should fix)
- [issue 1]

## Suggestions (consider improving)
- [issue 1]

1.7.2.2 Template: Test Generation

Genera unit tests para esta función:

[código]

Requisitos:
- Framework: [pytest/jest/junit]
- Incluir:
  - Happy path
  - Edge cases (input vacío, null, valores extremos)
  - Error handling (excepciones esperadas)
  - Mocks para dependencias externas
- Estilo: Given-When-Then
- Coverage objetivo: >80%

1.7.2.3 Template: Documentation

Genera documentación para este código:

[código]

Formato:
- Docstring con descripción clara
- Args con tipos y descripciones
- Returns con tipo y descripción
- Raises con excepciones posibles
- Examples con casos de uso reales

Audiencia: [junior/senior/stakeholders]

1.7.2.4 Template: Refactoring

Refactoriza este código:

[código]

Objetivos:
- Aplicar [patrón de diseño específico]
- Reducir complejidad ciclomática
- Eliminar duplicación
- Mejorar nombres (variables, funciones)

Constraints:
- Mantener misma interfaz pública
- No cambiar comportamiento (tests deben seguir pasando)
- Agregar tests si no existen

1.8 📚 Recursos