Moneypit: Andrew Childs creó una contabilidad local por partida doble en la que trabaja su agente de código para presentar sus impuestos

En dos frases

Andrew Childs, fundador de empresas de software en Nueva York, rehízo el programa de contabilidad personal que usaba desde hacía una década y lo convirtió en Moneypit, una herramienta local de contabilidad por partida doble y preparación de impuestos pensada para que un agente de código como Claude Code haga la parte pesada (clasificar movimientos y escribir reglas) a través de una interfaz de línea de comandos y solo después de que él apruebe cada cambio. Es un testimonio de primera mano sin cifras, pero todo el sistema, incluidas las instrucciones del agente y los prompts que la aplicación le envía, está publicado con licencia MIT y funciona en tu propio equipo.

Quién lo hace y por qué importa

Childs, cuyo perfil de GitHub dice que está creando Pennant Sports y que antes cofundó Shortcut (antes Clubhouse), presentó el proyecto en Hacker News el 21 de abril de 2026. Lo hizo, explica, para tener los libros en orden y presentar ese año sus declaraciones personal y de su pequeño negocio. Venía usando un programa que había escrito unos diez años antes y nunca publicó, y vio que «los agentes pueden ayudar bastante en tareas contables», así que construyó esta nueva versión.

Es un caso útil para autónomos y pequeños negocios que llevan su propia contabilidad. No es un chatbot pegado a una hoja de cálculo ni una IA que contabiliza sola: es un libro mayor por partida doble de verdad (cada movimiento tiene una cuenta de cargo y otra de abono) con una puerta deliberadamente estrecha para el agente: una CLI con comandos explícitos, prompts que terminan con «STOP and wait for the user to approve» y un registro de operaciones que permite deshacer lo que haya hecho el agente.

No vende nada asociado. El repositorio tiene un único mantenedor y dos estrellas, y el Show HN no recibió comentarios, así que no hay opiniones de la comunidad que valorar. Desde abril ha crecido mucho: los commits de septiembre de 2026 añaden negocios con su propio Schedule C, hojas de cálculo auxiliares como la deducción por despacho en casa y un borrador de la declaración federal impreso sobre los formularios del IRS. Contrastamos la publicación con el repositorio en el commit 79d330c (18 de septiembre de 2026) y lo ejecutamos nosotros con datos ficticios.

Herramientas y arquitectura

Moneypit es una aplicación web en SvelteKit que se ejecuta en local con Bun y guarda todo en PostgreSQL a través de Prisma. El modelo de datos es pequeño: cuentas con tipo y ruta jerárquica (Business:Hosting), movimientos con cuenta de cargo y de abono (una línea importada deja un lado vacío hasta clasificarla), reglas que asocian un patrón a una cuenta, categorías fiscales del IRS y libros aislados entre sí.

La parte de IA tiene tres piezas:

• La CLI, bin/mp. Un envoltorio en Bash que ejecuta scripts/mp.ts con Bun. Cubre todas las operaciones sobre los datos y, según el README, es también la vía por la que los agentes interactúan con Moneypit.
• El panel lateral. La aplicación abre un terminal real (node-pty y xterm.js) dentro de la página y lanza allí el agente elegido: Claude Code por defecto, Gemini CLI, Codex CLI o un comando propio. El prompt se escribe en un archivo temporal y se redirige a la entrada estándar del agente (a Codex se le pasa como argumento). El agente arranca en la carpeta del proyecto, de modo que puede leer el CLAUDE.md.
• Prompts de tarea generados con datos reales. Los botones de la página Categorize y de cada cuenta montan un prompt con el contexto ya relleno: para clasificar, hasta 200 movimientos pendientes, las reglas y el plan de cuentas; para auditar, los movimientos de la cuenta agrupados por descripción; para la categoría fiscal, ejemplos y la lista de categorías. Delante se añade un prompt de sistema genérico con las convenciones de cuentas, la referencia completa de la CLI y cuatro pautas; la primera, presentar siempre el plan y esperar la aprobación del usuario antes de ejecutar cambios.

El CLAUDE.md sirve a dos públicos. En el modo «Coding Agent (terminal)» el agente desarrolla el propio Moneypit; en el modo «UI-Embedded Agent (sidebar)» solo puede usar bin/mp y no debe tocar el código. Los prompts empiezan con MODE: UI-Embedded Agent para que el agente sepa qué papel tiene.

Paso a paso para replicarlo

1. Instala los requisitos: Bun 1.0 o posterior y PostgreSQL 14 o posterior (nosotros usamos la 17). Deja la aplicación en tu ordenador: el README advierte de que no tiene autenticación.
2. Crea la base de datos y el esquema con scripts/create-local-db.sh y bun run db:push, pon la cadena de conexión en .env y arranca con bun run dev (http://localhost:5180).
3. Crea un libro y un plan de cuentas mínimo: cuenta corriente y tarjetas como activo y pasivo, tus fuentes de ingresos y cuentas de gasto con las rutas que quieras ver en los informes (Business:Hosting, Housing:Rent).
4. Importa un mes de extractos en OFX/QFX o CSV. Usa antes import:preview para ver las cabeceras y después import:csv con un mapeo de columnas en JSON. Las líneas importadas quedan pendientes.
5. Pide al agente que clasifique. En la página Categorize, inicia la sesión y lee su propuesta: reglas que aplicar, reglas y cuentas nuevas con sus comandos exactos y movimientos sueltos. Aprueba solo lo que compartas.
6. Audita cuenta por cuenta con el prompt de auditoría: líneas fuera de lugar, reglas demasiado amplias y pendientes que deberían ir ahí.
7. Revisa y deshaz. Cada importación, regla creada o clasificación es una operación del registro (log:list); log:undo <id> la revierte.
8. Asigna categorías fiscales a las cuentas (el prompt correspondiente sugiere una por cuenta) y, si declaras en EE. UU., revisa la página del ejercicio, los documentos y el borrador de declaración como papel de trabajo para ti o tu asesor.

Cópialo y adáptalo

Todo lo de los apartados 1 a 4 procede del repositorio de Moneypit, Copyright (c) 2026 Andrew Childs, con licencia MIT; conserva ese aviso si lo copias. Los apartados 5 y 6 son plantillas de Agents Finance basadas en Moneypit, no archivos del autor. El código va tal cual, en inglés.

1. Instalar y arrancar la aplicación (README, literal)

Del README. Los comentarios dicen, por orden: instalar dependencias, crear la base de datos, cargar el esquema y arrancar el servidor de desarrollo.

# Install dependencies
bun install

# Create database
./scripts/create-local-db.sh moneypit moneypit

# Push schema to database
bun run db:push

# Start dev server
bun run dev

El archivo .env necesita dos variables (.env.example): la conexión a PostgreSQL y la carpeta de copias de seguridad.

DATABASE_URL="postgresql://user:password@localhost:5432/moneypit"
BACKUP_PATH="/path/to/backups/moneypit"

2. Los dos modos del agente en el CLAUDE.md (extracto)

Del CLAUDE.md, que documenta además el esquema, el orden en que se elige el libro, la CLI completa y el modelo de preparación de impuestos. En el modo de código, el agente trabaja en el programa; en el modo integrado, solo clasifica, crea reglas, audita cuentas y responde preguntas usando bin/mp, sin tocar archivos de código.

## Agent Modes

This file is used in two contexts. The prompt will tell you which mode you're in.

### Coding Agent (terminal)

You're helping develop Moneypit itself. Focus on:

- Code changes, bug fixes, new features
- Schema modifications
- Component development
- Use standard development workflow (edit files, run checks, etc.)

### UI-Embedded Agent (sidebar)

You're helping the user manage their finances through the embedded Claude panel. Focus on:

- Categorizing transactions via `bin/mp` commands
- Creating/updating rules
- Auditing accounts for miscategorization
- Answering questions about their financial data

**Important**: In UI-embedded mode, you should ONLY use the `bin/mp` CLI for database operations. Do not modify code files or run development commands.

3. Qué agentes puede lanzar el panel (extracto)

De src/lib/agents/config.ts. promptMethod: 'stdin' significa que el prompt generado se escribe en un archivo temporal y se redirige al comando; para añadir otro agente de línea de comandos basta con otra entrada aquí.

export const AGENTS: AgentConfig[] = [
	{
		id: 'claude',
		name: 'Claude Code',
		command: 'claude',
		readsClaudeMd: false,
		promptMethod: 'stdin',
		description: 'Anthropic Claude Code CLI'
	},
	{
		id: 'gemini',
		name: 'Gemini CLI',
		command: 'gemini',
		readsClaudeMd: false,
		promptMethod: 'stdin',
		description: 'Google Gemini CLI'
	},
	{
		id: 'codex',
		name: 'Codex CLI',
		command: 'codex',
		readsClaudeMd: false,
		promptMethod: 'arg',
		description: 'OpenAI Codex CLI'
	},
	{
		id: 'custom',
		name: 'Custom',
		command: '',
		readsClaudeMd: false,
		promptMethod: 'none',
		description: 'Run a custom command'
	}
];

4. El prompt de clasificación (extracto)

Es la parte de instrucciones de la plantilla de src/lib/prompts/categorize.ts. Encima, la aplicación inserta el identificador del libro, los movimientos pendientes en una tabla separada por tabuladores, las reglas y las cuentas agrupadas por tipo; ${mp} se sustituye por bin/mp --book <id> y al final se añade la referencia completa de la CLI. Pide buscar patrones, comprobar las reglas existentes, recomendar reglas nuevas y detenerse hasta la aprobación. Sirve como prompt independiente para cualquier contabilidad con reglas si cambias los comandos.

YOUR TASKS:

1. **Analyze the uncategorized transactions**
   Look for patterns in the descriptions that could be captured by rules.
   Group similar transactions mentally and identify:
   - Recurring merchants/payees (e.g., "AMAZON", "SPOTIFY", "SHELL OIL")
   - Common patterns that appear across multiple transactions
   - Transactions that might need amount constraints (same merchant, different categories based on amount)

2. **Check existing rules for coverage**
   - Do any existing rules already match these transactions? If so, running `${mp} rule:apply` may categorize them.
   - Are there patterns in uncategorized transactions that SHOULD be matched by existing rules but aren't? (possible rule refinement)

3. **Recommend new rules**
   For transaction patterns not covered by existing rules:
   - Identify the target account from EXISTING ACCOUNTS above
   - If no suitable account exists, suggest creating one first
   - Prefer substring patterns over regex when possible (simpler, more reliable)
   - Consider amount constraints for merchants that span categories (e.g., "TARGET" could be groceries OR household goods)

4. **Present your recommendations and WAIT for approval**
   Summarize your findings:
   - Rules that should be applied immediately: `${mp} rule:apply` (if existing rules would match)
   - New rules to create (with specific `${mp} rule:create` commands)
   - New accounts needed (with specific `${mp} account:create` commands)
   - Any transactions that need manual categorization (unusual one-offs)

   Then STOP and wait for the user to approve before executing any commands that modify data.
   You may run read-only commands (tx:list, rule:list, account:list, etc.) without approval.

IMPORTANT: Do NOT execute any database mutations (rule:create, account:create, tx:categorize, etc.) until the user explicitly approves your plan. Always present your recommendations first and wait for confirmation.

TIPS:
- Pick the top 6-8 transaction/account categories to resolve first - you don't have to evaluate the entire list, especially if it's very long.
- Use `${mp} rule:test "PATTERN"` to preview which transactions a rule would match before creating it
- Prioritize rules that would categorize the most transactions
- For transfers between accounts, the credit account is the source, debit account is the destination

5. Plantilla de Agents Finance: permisos de Claude Code para el panel

La regla de «esperar la aprobación» es una instrucción al modelo. La documentación de Claude Code deja claro que los permisos los aplica Claude Code, no el modelo, así que conviene añadir un .claude/settings.json en la carpeta de Moneypit que deje pasar las consultas de solo lectura, haga preguntar en cada escritura y bloquee las destructivas y la edición de código. Es nuestra plantilla, basada en la CLI de Moneypit y comprobada con la sintaxis de reglas de permisos; los prompts llaman a bin/mp --book <id> …, por eso cada regla de escritura aparece dos veces. Las consultas con --book también preguntarán, que es el lado seguro.

{
  "permissions": {
    "allow": [
      "Bash(bin/mp help)",
      "Bash(bin/mp tx:list *)",
      "Bash(bin/mp tx:get *)",
      "Bash(bin/mp tx:uncategorized *)",
      "Bash(bin/mp account:list *)",
      "Bash(bin/mp account:tree *)",
      "Bash(bin/mp rule:list)",
      "Bash(bin/mp rule:test *)",
      "Bash(bin/mp log:list *)"
    ],
    "ask": [
      "Bash(bin/mp rule:create *)", "Bash(bin/mp * rule:create *)",
      "Bash(bin/mp rule:update *)", "Bash(bin/mp * rule:update *)",
      "Bash(bin/mp rule:apply *)", "Bash(bin/mp * rule:apply *)",
      "Bash(bin/mp tx:categorize *)", "Bash(bin/mp * tx:categorize *)",
      "Bash(bin/mp tx:update *)", "Bash(bin/mp * tx:update *)",
      "Bash(bin/mp account:create *)", "Bash(bin/mp * account:create *)",
      "Bash(bin/mp account:update *)", "Bash(bin/mp * account:update *)",
      "Bash(bin/mp log:undo *)", "Bash(bin/mp * log:undo *)"
    ],
    "deny": [
      "Bash(bin/mp book:delete *)", "Bash(bin/mp * book:delete *)",
      "Bash(bin/mp tx:delete-imported *)", "Bash(bin/mp * tx:delete-imported *)",
      "Bash(bin/mp account:delete *)", "Bash(bin/mp * account:delete *)",
      "Bash(psql *)",
      "Read(./.env)",
      "Edit(/src/**)",
      "Edit(/prisma/**)",
      "Edit(/scripts/**)"
    ]
  }
}

Si además usas el modo de código de Moneypit para modificar la aplicación, deja este archivo fuera de esa copia o relaja allí las reglas Edit.

6. Plantilla de Agents Finance: convertir un CSV de un banco europeo antes de importarlo

En nuestra prueba, import:csv lee -86,41 como -8641 (su lector de importes elimina las comas) y espera comas entre columnas, mientras que la mayoría de los extractos de bancos españoles y europeos usan punto y coma, DD/MM/AAAA y coma decimal. Este script, nuestro, reescribe el archivo en el formato que entiende Moneypit; lo probamos con un extracto ficticio e importamos el resultado. Los nombres de columna por defecto del ejemplo (Fecha, Concepto, Importe) se cambian con los argumentos.

#!/usr/bin/env python3
"""Agents Finance template: convert a European bank CSV export into a CSV
that Moneypit's import:csv reads correctly.

Moneypit's CSV parser expects comma-separated files and amounts with a dot as
decimal separator (it strips commas, so "-86,41" would become -8641).
This script rewrites: delimiter ; -> ,  ·  DD/MM/YYYY -> YYYY-MM-DD  ·
1.234,56 -> 1234.56. Usage:
  python3 eu_csv_to_moneypit.py input.csv output.csv \
      --date "Fecha" --desc "Concepto" --amount "Importe"
"""
import argparse
import csv
import sys
from datetime import datetime
from decimal import Decimal, InvalidOperation


def eu_amount(value: str) -> str:
    v = value.strip().replace("€", "").replace("\u00a0", "").replace(" ", "")
    v = v.replace(".", "").replace(",", ".")  # 1.234,56 -> 1234.56
    try:
        return str(Decimal(v).quantize(Decimal("0.01")))
    except InvalidOperation:
        sys.exit(f"Unreadable amount: {value!r}")


def main() -> None:
    p = argparse.ArgumentParser()
    p.add_argument("input")
    p.add_argument("output")
    p.add_argument("--date", required=True, help="date column (DD/MM/YYYY)")
    p.add_argument("--desc", required=True, help="description column")
    p.add_argument("--amount", required=True, help="signed amount column")
    p.add_argument("--delimiter", default=";")
    p.add_argument("--encoding", default="utf-8-sig")
    a = p.parse_args()

    with open(a.input, newline="", encoding=a.encoding) as f_in, \
         open(a.output, "w", newline="", encoding="utf-8") as f_out:
        reader = csv.DictReader(f_in, delimiter=a.delimiter)
        writer = csv.writer(f_out)
        writer.writerow(["Date", "Description", "Amount"])
        rows = 0
        for row in reader:
            if not (row.get(a.date) or "").strip():
                continue  # skip blank or footer lines
            day = datetime.strptime(row[a.date].strip(), "%d/%m/%Y")
            writer.writerow([day.strftime("%Y-%m-%d"),
                             " ".join(row[a.desc].split()),
                             eu_amount(row[a.amount])])
            rows += 1
    print(f"{rows} rows written to {a.output}")


if __name__ == "__main__":
    main()

Después se importa el archivo convertido con un mapeo y, si estás al este de UTC, con el ajuste de zona horaria que explicamos más abajo:

python3 eu_csv_to_moneypit.py extracto.csv extracto-moneypit.csv \
  --date Fecha --desc Concepto --amount Importe
TZ=UTC bin/mp import:csv extracto-moneypit.csv --account <checking-id> \
  --mapping '{"dateColumn":"Date","descriptionColumn":"Description","amountColumn":"Amount","dateFormat":"YYYY-MM-DD"}'

Requisitos previos

• Poder instalar Bun y PostgreSQL y soltura básica con el terminal: no hay instalador ni versión alojada.
• Extractos bancarios en OFX/QFX o CSV. No hay conexión con bancos.
• Para el panel del agente, Claude Code, Gemini CLI o Codex CLI instalados y una suscripción o acceso por API. Claude Code no entra en el plan gratuito de Claude; los precios están en la ficha de la herramienta enlazada desde esta entrada.
• Nociones de partida doble: tú decides el plan de cuentas y debes saber distinguir un traspaso de un gasto cuando el agente pregunte.
• Para la parte fiscal, tributar en EE. UU. Los módulos, categorías y formularios son federales (IRS); fuera de allí sirven la contabilidad, las reglas y los informes.

Un ejemplo concreto: un mes de la cuenta de un autónomo

Reprodujimos el ciclo en un libro ficticio. Tras crear una cuenta corriente y cinco cuentas de ingresos, gastos y patrimonio, importamos un CSV de siete líneas de septiembre de 2026 (hosting, supermercado, el cobro de un cliente y suscripciones de software). Las siete entraron como pendientes. Después hicimos a mano lo que propondría el agente: probar un patrón, crear reglas, aplicarlas, clasificar lo que quedó y revisar el registro. En la salida, abreviada, los identificadores se sustituyen por marcadores.

# Output abridged; IDs replaced with placeholders
$ bin/mp rule:test "DIGITALOCEAN"          # preview matches before creating the rule
$ bin/mp rule:create "DIGITALOCEAN" --account <Business:Hosting-id>
$ bin/mp rule:create "TRADER JOE" --account <Groceries-id>
$ bin/mp rule:create "ACME CORP" --account <Consulting-id>
$ bin/mp rule:apply
Applied 3 rule(s) to 5 transaction(s)
$ bin/mp tx:uncategorized --condensed
…	2026-09-20	FIGMA MONTHLY	$15.00	Checking	(pending)
…	2026-09-08	GITHUB INC	$4.00	Checking	(pending)
$ bin/mp tx:categorize <id1> <id2> --debit <Business:Software-id>
Categorized 2 transactions
$ bin/mp log:list --limit 5
…  CATEGORIZE  5 change(s)   Applied 3 rules to 5 transactions
…  CREATE      1 change(s)   Created rule: ACME CORP
…  IMPORT      7 change(s)   Imported 7 transactions from checking-2026-09.csv
$ bin/mp log:undo <categorize-operation-id>
Undone: 5 change(s), skipped: 0

Al deshacer la aplicación de reglas, los cinco movimientos volvieron a pendientes, y al lanzar otra vez rule:apply se clasificaron de nuevo. Esa red de seguridad es la que hace razonable dejar que un agente proponga cambios masivos. Aparecieron además dos detalles. Al importar desde un equipo con la hora de Canarias (UTC+1), todas las fechas quedaron un día antes (09/20/2026 pasó a ser el 19 de septiembre); el mismo archivo importado con TZ=America/New_York o TZ=UTC conservó las fechas correctas. Y el comando demo:create que mencionan el CLAUDE.md y el README no existe en la CLI actual; creamos nuestro propio libro.

Resultados declarados por la fuente

No hay cifras: ni horas ahorradas, ni número de movimientos, ni tasa de acierto. Lo que declara el autor es cualitativo: lo construyó para presentar sus declaraciones de ese año, los agentes ayudan bastante en tareas contables, la aplicación importa bien desde muchas fuentes y no hay telemetría salvo lo que se envíe a un agente. El historial de commits encaja con esa motivación de campaña de la renta: la mayor parte del trabajo en el borrador de declaración llega en septiembre de 2026. Nuestras comprobaciones se limitan a los tests unitarios y al ciclo de la CLI descrito arriba.

Limitaciones y riesgos

• Datos enviados al proveedor de IA. El README avisa de que lo que aparece en el hilo del agente va al proveedor elegido. El prompt de clasificación incluye hasta 200 movimientos pendientes con descripción e importe, además del plan de cuentas. Si no es aceptable, el autor aconseja no usar el panel o configurar un modelo local.
• La aprobación es una instrucción, no un candado. Los prompts piden al agente que se detenga y espere, y el agente se ejecuta en la carpeta del proyecto con los permisos de tu usuario. Lo que de verdad lo impone son los avisos de permisos de Claude Code y un archivo de configuración como la plantilla anterior.
• Sin autenticación. No la expongas a ninguna red.
• Supuestos de formato estadounidense. Fechas e importes de EE. UU., dólares en los prompts, el problema de la coma decimal y el desfase de un día al este de UTC que observamos. Fuera de EE. UU., convierte antes los archivos e importa con TZ=UTC.
• La parte fiscal es un borrador. El aviso legal deja claro que no sustituye al asesoramiento profesional. El borrador cubre una larga lista de formularios federales, pero avisa cuando harían falta otros que no genera (como el 5329 o el 6198); las declaraciones estatales quedan fuera de lo que revisamos.
• Proyecto de un solo mantenedor. Sin versiones publicadas, sin colaboradores externos y sin debate todavía. Fija un commit, haz copias de la base de datos (bun run db:backup) y exporta los libros a JSON.

Errores comunes

• Aprobar reglas masivas sin rule:test. Una subcadena como AMAZON puede arrastrar compras de varias cuentas; usa rangos de importe.
• Tratar los traspasos como ingresos o gastos. Mover dinero entre tus cuentas debe cargar y abonar dos cuentas de activo o pasivo; la detección de duplicados y tx:merge existen porque el mismo traspaso suele aparecer en los dos extractos.
• Mezclar libros. Si tienes varios, comprueba book:current antes de dejar escribir al agente.
• Importar los archivos europeos tal cual. La coma decimal y el punto y coma producen importes erróneos sin avisar; conviértelos antes.
• Lanzar el agente en la copia en la que desarrollas. Guarda tus libros reales en otra carpeta.

Conclusiones

Moneypit es un ejemplo claro del patrón que se repite en los mejores casos de finanzas personales con agentes: el modelo hace el trabajo difuso de leer descripciones y proponer reglas, y los libros, la aritmética y la pista de auditoría se quedan en software determinista con una interfaz estrecha. Lo que merece la pena copiar no es tanto la aplicación como sus decisiones de diseño: una CLI como única puerta del agente, prompts generados con datos reales que terminan en una parada explícita y un registro de operaciones que se puede deshacer. Si tributas en EE. UU. y te manejas con el terminal, puedes usarlo tal cual. En otros países, el CLAUDE.md, los prompts y la plantilla de permisos son un buen punto de partida para poner un agente delante de la contabilidad que ya lleves.