Tutorial: un agente de Excel depura 59.157 líneas del mayor y las cuadra con sumas y saldos con una skill de auditoría y un plan aprobado

En dos frases

Dos profesores de contabilidad usaron ChatGPT para Excel, guiado por una «skill» que escribieron ellos, para convertir una exportación desordenada de 59.157 líneas del libro mayor en datos limpios y documentados y cuadrarla con el balance de sumas y saldos en unos 10 minutos, con un plan que el auditor aprueba antes de que se toque nada y un registro de cada modificación. Lo hicieron con datos simulados y la skill no es pública, así que explicamos el método y añadimos una skill, fórmulas, un archivo de control y un script de recomprobación independiente que puedes usar hoy mismo.

Quién lo hizo y por qué importa

El artículo salió en el número de octubre de 2026 del Journal of Accountancy, la revista del AICPA, el colegio de auditores y contables de Estados Unidos. Lo firman Gang (Ernest) Pan, profesor ayudante de contabilidad, y Li Wang, CPA/ABV y catedrática de contabilidad, los dos de la George W. Daverio School of Accountancy de la Universidad de Akron. No venden nada: eligieron ChatGPT para Excel como «ejemplo representativo» y avisan de que lo aprendido sirve en herramientas parecidas, como Claude para Excel, o en productos de auditoría como DataSnipper.

El problema que eligen lo conoce cualquier auditor, controller o asesoría que lleve contabilidades. Antes de probar asientos, hacer analítica o conciliar nada, el mayor del cliente tiene que ser utilizable, y casi nunca lo es: texto mezclado con números, fechas en varios formatos, cabeceras de informe y filas vacías en mitad de los datos. Lo difícil no es limpiar, sino demostrar después que la población depurada sigue representando la original. Por eso el artículo es útil: habla menos de la IA que de los controles que la rodean.

Herramientas y arquitectura

ChatGPT para Excel es el complemento de OpenAI para Excel. Salió en beta el 5 de marzo de 2026 y quedó disponible en todos los planes de ChatGPT el 5 de mayo; las skills y las apps llegaron el 22 de abril. Según el centro de ayuda de OpenAI, trabaja con libros grandes de muchas pestañas, pide permiso antes de modificar el libro y enlaza sus respuestas con las celdas que usa. Los planes Free y Go tienen un uso limitado, Plus y Pro consumen su límite de uso agéntico y los planes de empresa gastan créditos.

La pieza que marca la diferencia es la skill. Una skill es una carpeta con un archivo SKILL.md: una cabecera breve con el nombre y una descripción de cuándo debe usarse, y debajo las instrucciones en lenguaje normal. En ChatGPT se puede crear conversando, escribirla en un editor o subirla, y ChatGPT analiza las skills subidas antes de dejarlas usar. Copilot en Excel lee el mismo formato abierto desde una carpeta de OneDrive, de modo que una firma puede mantener un único procedimiento y usarlo en más de una herramienta.

Los autores construyeron su skill dándole al agente material docente de análisis de datos y normas de auditoría, pidiéndole un borrador y revisándolo después. Sus siete principios son sencillos: conservar los datos originales y trabajar sobre una copia; revisar antes de actuar; preparar un plan de limpieza y pedir que se apruebe; usar solo herramientas nativas de Excel (fórmulas, filtros, tablas y tablas dinámicas); documentar cada cambio en un registro de modificaciones; validar la integridad y la exactitud con totales de control, como el balance de sumas y saldos; y no exagerar el cumplimiento, porque el juicio de auditoría sigue siendo de la persona.

Las capturas de las dos figuras muestran el libro resultante: una hoja Cleaning_Plan (plan de limpieza), Working_Data (datos de trabajo), Modifications_Log (registro de modificaciones), Reconciliation (conciliación), FY_Variance_Bridge (puente de variaciones por ejercicio) y Final_Summary (resumen final), junto a las pestañas originales. El diagrama resume el flujo.

Paso a paso

1. Enseñar al agente con una skill. ChatGPT para Excel trae algunas skills de serie para modelos financieros y finanzas corporativas, pero ninguna para limpiar datos de auditoría, así que los autores escribieron la suya. Antes de compartirla con el equipo del encargo recomiendan una prueba estructurada: un responsable técnico la ejecuta sobre un conjunto de control pequeño, con defectos conocidos y la salida limpia ya calculada; comprueba que las fórmulas que escribe el agente son correctas y apuntan a las celdas de origen; y ajusta las instrucciones hasta que el resultado sea correcto al 100 % en ese archivo. Después, el equipo avisa de cualquier fallo con archivos reales para mejorarla.

2. Planificar antes de ejecutar. La skill obliga al agente a analizar los datos y escribir el método que propone en una hoja aparte antes de tocar nada, y a pedir aprobación. En la captura, la petición del usuario es breve: limpiar el mayor de la hoja original, usar la hoja «Report Contents» como guía del libro y cuadrar el resultado con las hojas de saldos de 2019 y 2020. El plan enumera los problemas que encontró y cómo propone tratarlos: códigos de debe y haber («S» para el debe y «H» para el haber) que hay que convertir en importes con signo, claves de cuenta de control con un formato distinto al del mayor y celdas de debe o haber vacías cuando el saldo es cero.

3. Limpiar y normalizar. Con el plan aprobado, el agente trabaja con fórmulas normales que se pueden revisar. Quita las filas vacías y las cabeceras repetidas, construye una clave de conciliación combinando los campos necesarios para que el mayor encaje con la estructura de las tablas de saldos y normaliza las fechas, incluido el valor de relleno «00/00/0000». El registro de la segunda figura muestra el detalle que quiere un auditor: un identificador de la fila de origen como primera columna para la trazabilidad, columnas auxiliares de debe, haber e importe con signo en las 59.157 filas y una nota por cada cambio.

4. Validar con la conciliación. El agente suma el mayor depurado por cuenta y compara los totales con los saldos finales del balance de sumas y saldos del cliente, señalando cualquier diferencia distinta de cero. En las capturas usa una clave de cuenta más centro de coste solo cuando esa clave existe en las tablas de saldos y, si no, la cuenta sola, e informa de que las conciliaciones de 2019, de 2020 y de todo el periodo cuadran con una tolerancia de 0,01 $.

5. Documentar para el revisor. Una última pestaña explica en lenguaje llano qué se hizo y por qué, y los controles de calidad aparecen como superados («Pass») en conservación y aprobación, documentación, calidad de datos, conciliación y comunicación; el último aclara que no se afirma ninguna conclusión de cumplimiento de auditoría. La revisión humana de los autores tiene tres partes: comprobar que todas las cuentas del balance de sumas y saldos cuadran con el mayor agregado; rastrear hasta el origen las fórmulas de las cuentas con más volumen; y resolver las cuestiones de juicio profesional, como el redondeo, dando instrucciones explícitas al agente.

Cópialo y adáptalo

Requisitos previos: Excel con ChatGPT para Excel y una cuenta de trabajo autorizada, permiso para crear o subir skills (o Copilot en Excel con una carpeta de skills en OneDrive, que lee el mismo formato), y Python 3.10 o posterior con pandas para la recomprobación. Los autores no han publicado su skill, sus datos ni sus prompts, así que todo lo que sigue es una plantilla de Agents Finance basada en el artículo del Journal of Accountancy. El código va en inglés, igual que en la versión inglesa. Empieza con datos ficticios y no subas nunca datos de un cliente a una cuenta personal.

1. La skill (plantilla de Agents Finance)

Guárdala como gl-clean-reconcile-tb/SKILL.md y sube la carpeta, o pégala en el editor de skills de ChatGPT. Recoge los siete principios del artículo y añade dos cosas: un control de integridad (filas leídas = filas conservadas + filas excluidas, con motivo) y una lista de prohibiciones, entre ellas cambiar signos, redondear o quitar filas para forzar el cuadre.

---
name: gl-clean-reconcile-tb
description: Use when I ask to clean a general ledger or journal export and reconcile it to a trial balance or other control totals for audit or month-end use.
---

# Clean a general ledger export and reconcile it to the trial balance

## Principles (never skip)
1. Never edit the source sheet. Copy it to `Working_Data` and add `Source_Row_ID` as the first column, pointing to the original row.
2. Inspect before acting: list every data-quality issue you find (blank rows, report headers or footers, text in number columns, mixed date formats, placeholder dates, debit/credit codes, key formats that differ from the control totals, currency fields).
3. Write the plan in a `Cleaning_Plan` sheet (issue, evidence with a cell reference, proposed treatment) and STOP. Ask me to approve or change it. Do nothing else until I approve.
4. Use only native Excel: formulas, filters, tables and PivotTables. No macros, no VBA, no hard-coded values pasted over formulas.
5. Log every change in `Modifications_Log` with: Step, Timestamp, Sheet, Column or range, Issue found, Approved action, Excel method or formula, Rows affected, Validation performed, Notes.
6. Reconcile: sum the cleaned amounts by account (and by the extra dimension only where the control totals carry it) and by period, compare with the control totals in a `Reconciliation` sheet, compute the difference and flag anything above the tolerance I give you (default 0.01).
7. Completeness: show rows in the source = rows kept + rows excluded, with the reason for each exclusion.
8. Finish with a `Final_Summary` sheet: what you did, what you could not resolve and the open questions. Do not state or imply that the data complies with any auditing standard: that judgement is mine.

## Never
- Delete or overwrite the source data.
- Change signs, round, or drop rows to force a reconciliation to tie.
- Guess the meaning of a code: ask me.

2. El prompt para empezar (plantilla de Agents Finance)

Sustituye las variables entre llaves por los nombres de tus hojas, la tolerancia y la dimensión adicional (por ejemplo, el centro de coste). La última línea es la importante: en el primer paso solo se pide el plan.

@gl-clean-reconcile-tb
Source sheet: "{{SOURCE_SHEET}}". Workbook guide: "{{GUIDE_SHEET}}" (column meanings, currency, debit/credit codes).
Control totals: "{{TB_SHEET_1}}" and "{{TB_SHEET_2}}" (one per fiscal year).
Tolerance: {{TOLERANCE}}. Reconciliation grain: account, plus {{EXTRA_DIMENSION}} only where the control totals have it.
First step only: build Cleaning_Plan and ask me to approve. Do not change any data yet.

3. Fórmulas para las hojas de trabajo (plantilla de Agents Finance)

Las letras de columna siguen nuestro archivo de control: A cuenta, B centro de coste, C fecha contable, D ejercicio, E código de debe/haber, F importe, y una hoja TB (el balance de sumas y saldos) con la clave en la columna E. Adáptalas a tu archivo. Si tu Excel está en español, los nombres de las funciones cambian (SI, O, ESPACIOS, SUSTITUIR, MAYUSC, CONTAR.SI.CONJUNTO, SUMAR.SI.CONJUNTO, REDONDEAR, NOD) y el separador de argumentos suele ser el punto y coma.

Clean_Date (G2):      =IF(OR(TRIM(C2)="",TRIM(C2)="00/00/0000"),"",C2)
dd.mm.yyyy to date:   =DATE(RIGHT(C2,4),MID(C2,4,2),LEFT(C2,2))
Signed_Amount (H2):   =IF(E2="S",F2,IF(E2="H",-F2,NA()))
Acct_Key (I2):        =UPPER(SUBSTITUTE(TRIM(A2),"-",""))
Recon_Key (J2):       =IF(COUNTIFS(TB!$E:$E,I2&"|"&UPPER(TRIM(B2)))>0,I2&"|"&UPPER(TRIM(B2)),I2)
TB_Key (TB!E2):       =UPPER(SUBSTITUTE(TRIM(B2),"-",""))&IF(TRIM(C2)="","","|"&UPPER(TRIM(C2)))
GL total (Rec!C2):    =SUMIFS(Working_Data!$H:$H,Working_Data!$J:$J,B2,Working_Data!$D:$D,A2)
Difference (Rec!E2):  =ROUND(C2-D2,2)
Status (Rec!F2):      =IF(ABS(E2)<=0.01,"OK","INVESTIGATE")

El NA() del importe con signo es deliberado: un código de debe/haber desconocido debe romper el total, no desaparecer.

4. Archivo de control con defectos conocidos (plantilla de Agents Finance)

Dos CSV pequeños con datos ficticios: un mayor con una cabecera de informe, una fila vacía, un pie de página, decimales con coma y con punto, un negativo entre paréntesis, una fecha de relleno y guiones finales en los códigos de cuenta, y el balance de sumas y saldos con el que debe cuadrar. La respuesta correcta es: 11 filas leídas, 8 conservadas, 3 excluidas, 7 claves conciliadas y ninguna diferencia.

account,cost_center,posting_date,fiscal_year,debit_credit,amount,text
Report: GL line items,,,,,,
,,,,,,
INT-1000-,,2020-01-31,2020,S,"18,584.00",Cash receipt
INT-1000-,,02/03/2020,2020,H,"1.200,50",Bank fee reversal
INT-2111-,CC10,00/00/0000,2020,H,950.00,Accrual
INT-2111-,CC20,15.06.2020,2020,H,"(50.00)",Accrual correction
INT-4000-,,2020-12-31,2020,H,"25,000.00",Revenue
INT-6100-,,2020-11-30,2020,S,7266.50,Expenses
Page 2 of 2,,,,,,
INT-1000-,,2019-12-31,2019,S,"5,000.00",Opening
INT-4000-,,2019-12-31,2019,H,5000,Revenue 2019

fiscal_year,account,cost_center,balance
2020,INT-1000,,17383.50
2020,INT-2111,CC10,-950.00
2020,INT-2111,CC20,50.00
2020,INT-4000,,-25000.00
2020,INT-6100,,7266.50
2019,INT-1000,,5000.00
2019,INT-4000,,-5000.00

5. Recomprobación independiente en Python (plantilla de Agents Finance)

Reconstruye el resultado desde la exportación original sin leer las fórmulas del agente, de modo que el revisor tiene un segundo total independiente. Con el archivo de control de arriba imprime Rows read: 11 | kept: 8 | dropped: 3 y differences above 0.01: 0; si cambias una cifra del balance en 0,50, marca esa clave y termina con el código 1.

#!/usr/bin/env python3
"""Independent re-check of an Excel agent's GL clean-up and GL-to-TB reconciliation.

Agents Finance template based on the procedure described by Pan and Wang
(Journal of Accountancy, October 2026). It does not read the agent's workbook
formulas: it rebuilds the result from the raw export so you can compare totals.

Usage:
  python gl_tb_recheck.py raw_gl.csv trial_balance.csv --year-col fiscal_year
Outputs: recheck_reconciliation.csv and recheck_rows.csv in the current folder.
"""
import argparse
import re
import sys
from datetime import datetime
from decimal import Decimal, InvalidOperation

import pandas as pd

TOLERANCE = Decimal("0.01")
DATE_FORMATS = ("%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y", "%d.%m.%Y", "%Y%m%d")
PLACEHOLDER_DATES = {"", "00/00/0000", "00.00.0000", "0000-00-00", "00000000"}


def parse_amount(text):
    """'1.234,50' / '1,234.50' / '(500.00)' / '500-' -> Decimal, or None."""
    s = str(text).strip().replace(" ", "").replace("\u00a0", "")
    if not s or s.lower() == "nan":
        return None
    negative = s.startswith("(") and s.endswith(")") or s.endswith("-")
    s = s.strip("()").rstrip("-").lstrip("+")
    if s.startswith("-"):
        negative, s = True, s[1:]
    if "," in s and "." in s:
        # the right-most separator is the decimal one
        if s.rfind(",") > s.rfind("."):
            s = s.replace(".", "").replace(",", ".")
        else:
            s = s.replace(",", "")
    elif "," in s:
        s = s.replace(",", ".") if len(s.split(",")[-1]) == 2 else s.replace(",", "")
    try:
        value = Decimal(s)
    except InvalidOperation:
        return None
    return -value if negative else value


def parse_date(text):
    s = str(text).strip()
    if s in PLACEHOLDER_DATES or s.lower() == "nan":
        return None
    for fmt in DATE_FORMATS:
        try:
            return datetime.strptime(s, fmt).date()
        except ValueError:
            continue
    return "UNPARSED"


def norm_key(text):
    """Same idea as =UPPER(TRIM(SUBSTITUTE(x,"-",""))) in the workbook."""
    return str(text).strip().upper().replace("-", "").replace(" ", "")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("raw_gl")
    ap.add_argument("trial_balance")
    ap.add_argument("--account-col", default="account")
    ap.add_argument("--costcenter-col", default="cost_center")
    ap.add_argument("--amount-col", default="amount")
    ap.add_argument("--dc-col", default="debit_credit")
    ap.add_argument("--debit-code", default="S")   # S/H = Soll/Haben in many SAP exports
    ap.add_argument("--credit-code", default="H")
    ap.add_argument("--date-col", default="posting_date")
    ap.add_argument("--year-col", default="fiscal_year")
    ap.add_argument("--account-regex", default=r"^[A-Z]{0,4}-?\d",
                    help="what a real account looks like; other rows are treated as headers/text")
    args = ap.parse_args()

    raw = pd.read_csv(args.raw_gl, dtype=str, keep_default_na=False)
    tb = pd.read_csv(args.trial_balance, dtype=str, keep_default_na=False)

    rows, kept = [], []
    for i, r in raw.iterrows():
        source_row = i + 2  # header is row 1 in the CSV
        account = r.get(args.account_col, "").strip()
        amount = parse_amount(r.get(args.amount_col, ""))
        dc = r.get(args.dc_col, "").strip().upper()
        reason = None
        if not account and amount is None:
            reason = "blank row"
        elif not re.match(args.account_regex, account.upper()):
            reason = "header or text row"
        elif amount is None:
            reason = "amount not numeric"
        elif dc not in (args.debit_code, args.credit_code):
            reason = f"unknown debit/credit code '{dc}'"
        date = parse_date(r.get(args.date_col, ""))
        if reason is None and date == "UNPARSED":
            reason = "date not parseable"
        rows.append({"source_row": source_row, "account": account, "reason_dropped": reason or ""})
        if reason:
            continue
        signed = amount if dc == args.debit_code else -amount
        kept.append({
            "source_row": source_row,
            "year": r.get(args.year_col, "").strip(),
            "acct_key": norm_key(account),
            "acct_cc_key": norm_key(account) + "|" + norm_key(r.get(args.costcenter_col, "")),
            "signed_amount": signed,
            "date_blank": date is None,
        })

    gl = pd.DataFrame(kept)
    tb["acct_key"] = tb["account"].map(norm_key)
    tb["acct_cc_key"] = tb["acct_key"] + "|" + tb.get("cost_center", "").map(norm_key)
    tb["balance_dec"] = tb["balance"].map(parse_amount)
    tb_cc_keys = set(tb.loc[tb["cost_center"].str.strip() != "", "acct_cc_key"]) if "cost_center" in tb else set()

    # Use the account+cost-centre key only when the TB carries that grain (as in the JofA plan).
    gl["recon_key"] = [cc if cc in tb_cc_keys else a for cc, a in zip(gl["acct_cc_key"], gl["acct_key"])]
    tb["recon_key"] = [cc if cc in tb_cc_keys else a for cc, a in zip(tb["acct_cc_key"], tb["acct_key"])]

    gl_sum = gl.groupby(["year", "recon_key"])["signed_amount"].apply(lambda s: sum(s, Decimal("0")))
    tb_sum = tb.groupby(["fiscal_year", "recon_key"])["balance_dec"].apply(lambda s: sum(s, Decimal("0")))
    tb_sum.index = tb_sum.index.set_names(["year", "recon_key"])

    rec = pd.concat([gl_sum.rename("gl"), tb_sum.rename("tb")], axis=1).fillna(Decimal("0")).reset_index()
    rec["difference"] = rec["gl"] - rec["tb"]
    rec["status"] = ["OK" if abs(d) <= TOLERANCE else "INVESTIGATE" for d in rec["difference"]]
    rec.to_csv("recheck_reconciliation.csv", index=False)
    pd.DataFrame(rows).to_csv("recheck_rows.csv", index=False)

    dropped = sum(1 for r in rows if r["reason_dropped"])
    print(f"Rows read: {len(rows)} | kept: {len(kept)} | dropped: {dropped} | blank dates kept: {int(gl['date_blank'].sum())}")
    print(f"Completeness check: {len(rows)} = {len(kept)} + {dropped} -> {'OK' if len(rows) == len(kept) + dropped else 'FAIL'}")
    bad = rec[rec["status"] != "OK"]
    print(f"Keys reconciled: {len(rec)} | differences above {TOLERANCE}: {len(bad)}")
    if len(bad):
        print(bad.to_string(index=False))
    return 1 if len(bad) else 0


if __name__ == "__main__":
    sys.exit(main())

Instálalo con pip install pandas y ejecútalo con python gl_tb_recheck.py raw_gl.csv trial_balance.csv. El patrón de cuenta por defecto y los códigos S/H corresponden al archivo de control; cambia --account-regex, --debit-code y --credit-code según tu exportación.

6. Lista de control del revisor (plantilla de Agents Finance)

Ocho comprobaciones antes de usar los datos, de la hoja de origen intacta al resumen sin conclusiones de cumplimiento.

- [ ] The source sheet is untouched and every Working_Data row has a Source_Row_ID.
- [ ] I approved Cleaning_Plan before any change, and the log matches the plan.
- [ ] Rows read = rows kept + rows excluded, and each exclusion has a reason.
- [ ] Every trial balance account and period appears in Reconciliation.
- [ ] I traced the formulas of the five largest accounts back to the source rows.
- [ ] The independent re-check gives the same totals and no difference above tolerance.
- [ ] Rounding and any other judgement call was decided by me, not by the agent.
- [ ] Final_Summary makes no claim of compliance with auditing standards.

Un ejemplo concreto

Toma el archivo de control de arriba. El plan del agente debería recoger cinco problemas: dos filas que no son datos (el título del informe y el pie de página) y una fila vacía; importes en dos formatos («18,584.00» y «1.200,50») y un negativo entre paréntesis; una fecha de relleno y tres formatos de fecha; los códigos de debe y haber «S» y «H»; y códigos de cuenta con un guion final («INT-1000-») que no coinciden con los del balance («INT-1000»). Tras la aprobación, Working_Data conserva ocho filas, Modifications_Log anota cada columna auxiliar con su fórmula y Reconciliation muestra siete claves: la cuenta 2111 se concilia por centro de coste (CC10 y CC20) porque el balance tiene ese desglose, y el resto por cuenta. La cuenta 1000 de 2020 cuadra en 17.383,50: 18.584,00 al debe menos 1.200,50 al haber. Si cambias en el balance la cuenta 6100 de 7.266,50 a 7.266,00, tanto el libro como el script deben señalar una diferencia de 0,50 en lugar de redondearla.

Resultados que declara la fuente

Los autores dicen que limpiar, validar y conciliar 59.157 líneas con el balance de sumas y saldos les llevó unos 10 minutos de media en su simulación, frente a «muchas horas» con los métodos tradicionales, y sus capturas muestran que las conciliaciones de 2019, de 2020 y de todo el periodo cuadran con 0,01 $ de tolerancia. No hay más cifras. Los datos se simularon a partir de un caso docente, no hubo cliente ni una comparación cronometrada con el trabajo manual, y no cuentan cuántas veces se equivocó el agente antes de afinar la skill. Toma esos 10 minutos como lo que es posible cuando ya existe una skill probada, no como lo que tardará tu primera ejecución.

Limitaciones y riesgos

• Protección de datos. OpenAI advierte de que, según las condiciones del marketplace de complementos de Microsoft, Microsoft podría leer el contenido del libro y los prompts, y de que algunos registros pueden guardarse 30 días. Los autores exigen licencias de empresa para auditoría. En España y el resto de la UE, revisa además el RGPD, la política de tu firma y las condiciones del encargo antes de subir un mayor.
• La herramienta cambia. Las capturas son de julio de 2026; desde entonces han cambiado menús, skills de serie y límites de uso, y seguirán cambiando.
• Un plan no es un control. Aprobar el plan reduce el riesgo de cambios no deseados, pero no lo elimina, como reconocen los propios autores. Los controles son la conciliación y tu propio rastreo.
• Fórmulas, no valores. El método depende de que el agente escriba fórmulas visibles. Si pega valores, se pierde la pista: prohíbelo en la skill, como hace la nuestra.
• Macros y archivos muy grandes. OpenAI indica que VBA y las macros no tienen soporte completo, y los libros más grandes consumen más límite de uso.

Errores comunes

• Dejar que el agente trabaje sobre la única copia de la exportación. Duplica antes el archivo, como también recomienda OpenAI.
• Aprobar el plan sin leerlo, sobre todo el tratamiento de los códigos de debe y haber y de las filas que propone excluir.
• Dar por buena la palabra «conciliado» sin comprobar que están todas las cuentas del balance: una cuenta que falta no puede mostrar diferencia.
• Pedir al agente que «arregle» una diferencia. Las diferencias son evidencia que hay que investigar, no algo que hacer desaparecer.
• Compartir una skill con el equipo antes de que supere un archivo de control cuya respuesta ya conoces.

Conclusiones

Lo más valioso de este tutorial no son los 10 minutos, sino la forma de trabajar: un procedimiento escrito que el agente tiene que seguir, un plan que aprueba una persona, fórmulas en lugar de valores pegados, un registro de cada cambio y una conciliación con un total de control externo. Son los mismos controles que un gerente de auditoría exigiría a un asistente júnior, y caben en un SKILL.md corto que funciona en ChatGPT para Excel y, con el mismo formato, en Copilot en Excel. Empieza con un archivo de control, añade una recomprobación independiente como el script de arriba y solo entonces deja que el agente trabaje con el mayor de un cliente real.