PowerRustCOBOL AI + Claude Code: de la especificación a la aplicación terminada
PowerRustCOBOL AI se integra ahora con
Claude Code, el agente de programación de Anthropic. Claude Code ya no "adivina" cómo se construye una aplicación PowerRustCOBOL: trabaja con las herramientas del propio IDE, consulta su referencia oficial, genera y compila el código, comprueba los formularios y los mira antes de dar el trabajo por terminado.
Esta integración convierte a PowerRustCOBOL AI en una
plataforma de entrega. El desarrollador COBOL decide qué hay que construir y revisa el resultado; Claude Code hace el trabajo pesado dentro de las reglas del producto. El resultado es una aplicación de escritorio en COBOL, con formularios, ficheros indexados, IA integrada y un único binario sin runtime que instalar.
--------------------------------------------------
1. Por qué esto importa
Quien mantiene aplicaciones COBOL conoce el problema: el negocio pide pantallas nuevas, informes, integraciones e IA, y el equipo es pequeño. Un agente de programación genérico ayuda poco en COBOL: no conoce nuestros controles, inventa propiedades y produce código que no compila.
Con la integración, Claude Code:
- usa las herramientas del IDE, no suposiciones: crea el proyecto, añade ficheros, regenera el COBOL de cada formulario y ejecuta Check hasta que no queda ningún error;
- consulta la referencia del producto (controles, propiedades, métodos, eventos, built-ins) antes de escribir un nombre, así que no inventa propiedades;
- mira lo que construye: render_form le devuelve una imagen del formulario dibujado por el mismo motor que la aplicación real, y run_form ejecuta el programa sin pantalla, pulsa botones, escribe en campos y lee resultados;
- sigue las reglas de oro de las aplicaciones PowerRustCOBOL (más abajo);
- pasa por un revisor: el agente powerrustcobol-reviewer contrasta cada cambio con la referencia y las reglas antes de darlo por bueno, sin modificar nada por sí mismo;
- informa de lo que falta: si una petición necesita algo que el producto no tiene, no lo improvisa; escribe un gap report en el proyecto, visible en el árbol como "Compiler requests".
El objetivo: entregar aplicaciones nuevas
con rapidez y con calidad, y que el código siga siendo COBOL que el equipo entiende y mantiene.
--------------------------------------------------
2. Qué incluye la integración
Un
plugin de Claude Code llamado
powerrustcobol, generado e instalado por el propio IDE una sola vez por máquina. No se escribe nada en las carpetas de los proyectos.
- 13 herramientas: create_project, open_project, list_files, add_to_project, regenerate, check, validate, build, render_form, run_form, kb_lookup, kb_search, add_powerchat.
- 10 habilidades (skills) que enseñan a Claude a: crear un formulario, añadir un control y su evento, definir un fichero indexado, añadir recursos (imágenes, fuentes), escribir procedimientos comunes, comprobar y corregir, construir una aplicación completa de varios formularios, montar el shell de navegación, maquetar con temas, y redactar un informe de carencias.
- Referencia y patrones del producto, servidos al agente como recursos.
- Dos servidores de herramientas: el del IDE (local, en 127.0.0.1, protegido por un token) cuando el IDE está abierto, y el de rcrun cuando está cerrado.
Las reglas de oro que Claude aplica a toda aplicación que construye:
- Responsiva: todo formulario se adapta a cualquier resolución.
- Spatial: el IDE y los formularios usan el tema Spatial (vidrio translúcido, el escritorio desenfocado detrás de la ventana).
- Shell: un SideMenu en el formulario principal, y cada pantalla se carga dentro de su ContentPane, salvo que el desarrollador pida otra cosa.
- Limpia: pocos controles por pantalla, rejilla de 8 puntos, un solo color de acento; cada pantalla se revisa con render_form.
- Controles incorporados primero: DataGrid, TreeView, DateTimePicker, gráficos, Snackbar, IndexedFile, RestClient, SqlDatabase, AgentObject... antes que nada hecho a mano.
- Localizada: todo texto visible en inglés, portugués, español, francés, japonés y chino, conmutable en ejecución.
- GitHub: se ofrece un repositorio privado; la aplicación funciona sin él y nunca se suben claves.
- PowerChat solo cuando se pide, y entonces con una sola herramienta.
--------------------------------------------------
3. PowerRustCOBOL AI como plataforma: lo que Claude puede entregar
Aplicaciones completas de varios formularios. Menú lateral, migas de pan, pantallas cargadas en el panel de contenido, DataGrid, gráficos (barras, líneas, tarta, donut, área, dispersión), ficheros indexados con COMMIT/ROLLBACK, SQL (SQLite, PostgreSQL, MySQL) y servicios REST.
Chat con RAG sobre los documentos y los datos de la empresa. Basta pedir "añade PowerChat": la herramienta
add_powerchat copia en el proyecto un chatbot multiagente completo (14 formularios, temas, documentos, plantillas de informe, orquestador y base de conocimiento) que hereda el tema, el nombre y el icono de la aplicación, y añade una entrada "Assistant" al menú lateral. El control
KnowledgeBase guarda colecciones de documentos (Office, PDF, HTML, Markdown importados como texto) y un
AgentObject puede responder apoyado en ellas. Además, un modelo puede consultar los
ficheros indexados de la aplicación a través de su descripción
.cidx.
IA en el propio COBOL. El control
AgentObject llama a un modelo desde un manejador COBOL y devuelve la respuesta en un evento (
onResponse, o por partes con
onPartialReply). Hay 17 proveedores: OpenAI, Anthropic, Google Gemini, Mistral, Groq, OpenRouter, DeepSeek, xAI, Ollama (local y nube) y otros. Las claves nunca se guardan en el formulario.
Rust de verdad, incrustado en el formulario. Un bloque
EXEC RUST dentro de un manejador se compila dentro de la aplicación. Puede usar crates de crates.io registrados en el proyecto ("Project's Crates"), que quedan copiados y fijados en el proyecto. Así Claude puede escribir código Rust tan complejo como haga falta (cálculo, protocolos, criptografía, formatos de fichero) sin salir del formulario, mientras el resto de la aplicación sigue en COBOL.
Documentación. Claude Code puede redactar la documentación de la aplicación (manual de usuario, guía de operación, descripción de ficheros) directamente en la categoría "Knowledge Base" del proyecto. Y dentro del IDE, el asistente Grace tiene un agente de documentación que crea, actualiza e indexa esos documentos para que PowerChat y los agentes los usen.
Un binario. Build produce un único ejecutable autónomo, sin runtime que instalar.
--------------------------------------------------
4. Una introducción suave al Desarrollo Guiado por Especificaciones (Spec Driven Development)
Pedirle a un agente "hazme una aplicación de campañas" da un resultado distinto cada vez. La solución es la misma que en cualquier proyecto serio:
escribir primero qué hay que construir, y después construirlo. Eso es el Desarrollo Guiado por Especificaciones, en cuatro pasos:
- Especificar (spec.md): qué y por qué. Objetivos, lo que queda fuera, historias de usuario, requisitos numerados (R1, R2...) y criterios de aceptación que se puedan comprobar. Nada de cómo.
- Aclarar: el agente lee la especificación y pregunta todo lo ambiguo antes de empezar. Cada respuesta se anota en la propia especificación.
- Planificar (plan.md) y dividir en tareas (tasks.md): el cómo. Formularios, ficheros, procedimientos, el orden de construcción, y una lista de tareas pequeñas, cada una con su forma de verificarla.
- Implementar: el agente ejecuta las tareas una a una, ejecuta Check y las pruebas en cada paso, y marca cada tarea como hecha.
La especificación es un
contrato: el desarrollador la revisa y la aprueba; el agente la cumple. Si algo cambia, se cambia primero la especificación. Así el trabajo es repetible, revisable y auditable, que es exactamente lo que un equipo COBOL espera.
Cómo hacerlo con Claude Code + PowerRustCOBOL AI. No hace falta ninguna herramienta extra: basta una carpeta
specs/ en el proyecto y estas instrucciones a Claude Code:
Código:
1) "Lee specs/001-campaign-manager/spec.md. Antes de planificar,
hazme todas las preguntas necesarias y anota mis respuestas en el spec."
2) "Escribe specs/001-campaign-manager/plan.md y tasks.md a partir del
spec aprobado. Cada tarea indica cómo se verifica. No escribas código."
3) "Implementa tasks.md tarea por tarea. Después de cada una: regenerate,
check, render_form en las pantallas tocadas y marca la tarea como hecha.
Para si algo del spec no se puede cumplir y dime por qué."
Un consejo: aprueba cada documento antes de pasar al siguiente. Leer una página de especificación cuesta minutos; deshacer una aplicación mal entendida cuesta días.
--------------------------------------------------
5. Paso a paso: instalar y conectar
a) Instalar PowerRustCOBOL AI. Desde el código fuente (Rust 1.92 o superior):
Código:
git clone https://github.com/CloudLandBeta/PowerRustCOBOL.git
cd PowerRustCOBOL
cargo build --release -p cobolt-ide -p cobolt-cli
El toolchain de Rust también hace falta para
Build y para los bloques
EXEC RUST.
b) Instalar Claude Code (necesita una cuenta de Claude con suscripción, o una cuenta de la consola de Anthropic):
Código:
macOS / Linux: curl -fsSL https://claude.ai/install.sh | bash
Windows: irm https://claude.ai/install.ps1 | iex
Alternativa: npm install -g @anthropic-ai/claude-code
Después, en un terminal, ejecute
claude una vez e inicie sesión.
c) Conectar los dos. Abra PowerRustCOBOL AI. La primera vez aparece el asistente
"Connect a coding agent": elija Claude Code y pulse
Connect. Si lo omitió, use
File ▸ Configure Claude Code. El IDE localiza Claude Code, genera el plugin
powerrustcobol y lo instala con los comandos del propio Claude Code. El estado (plugin, servidor de herramientas, puerto y token) se ve en
Help ▸ Coding Agent Settings.
d) Primera sesión. Abra una sesión nueva de Claude Code (en el terminal, o en la aplicación de escritorio). La primera vez que Claude use cada herramienta pedirá permiso: responda
"Yes, and don't ask again". Pruebe con:
Código:
"Crea un proyecto PowerRustCOBOL llamado Hello con un formulario principal
que tenga un botón y una etiqueta; al pulsar el botón la etiqueta dice Hola.
Comprueba con check y enséñame el formulario con render_form."
--------------------------------------------------
6. Ejemplo completo: gestión de campañas de marketing de seguros
Un caso real de negocio, especificado para que Claude Code lo construya. La aplicación selecciona clientes de un fichero indexado, genera con IA una oferta de seguro personalizada para cada uno, la envía por correo, controla cuántos correos salen, lee las respuestas del buzón y muestra estadísticas de cada campaña. Todo con el tema Spatial y un aspecto moderno.
Guarde esto como
specs/001-campaign-manager/spec.md en un proyecto nuevo:
Código:
# Spec 001 - Campaign Manager (ofertas de seguros por correo)
## 1. Visión general
Una aplicación de escritorio que ejecuta campañas de marketing por correo
para una oferta de seguro de vida. Selecciona un grupo de clientes de un
fichero indexado con una búsqueda determinista, pide a un modelo de IA que
redacte una oferta personalizada para cada uno, envía las ofertas por
correo dentro de un límite de envíos, lee el buzón en busca de respuestas
que acepten la oferta y muestra estadísticas de la campaña.
## 2. Objetivos / Fuera de alcance
Objetivos: selección repetible; el precio lo calcula COBOL, nunca la IA;
la oferta se edita en Markdown con vista previa en vivo; cada correo se
cuenta; las respuestas se asocian a su campaña; estadísticas por campaña.
Fuera de alcance: cobros, emisión de pólizas, una interfaz web.
## 3. Datos (ficheros indexados)
- CUSTOMERS: CUST-ID (clave), NAME, EMAIL (clave alternativa), GENDER,
BIRTH-DATE, AGE (clave alternativa, con duplicados), PROFESSION,
CHILDREN (número de hijos), indicador OPT-OUT (no desea recibir correo).
- CAMPAIGNS: CAMP-ID (clave), NAME, CREATED, STATUS, SEND-LIMIT,
SENT-COUNT, TEMPLATE (texto en Markdown).
- OFFERS: CAMP-ID + CUST-ID (clave), PRICE, BODY (Markdown), SENT-AT,
MESSAGE-ID, STATUS (draft/sent/accepted/declined/bounced), REPLIED-AT.
## 4. Requisitos
R1 La selección es determinista: clientes de 30 a 45 años inclusive, sin
OPT-OUT, leídos por la clave alternativa AGE en orden ascendente de AGE
y después de CUST-ID. Los mismos datos dan siempre el mismo grupo.
R2 El precio se calcula en COBOL: 40,00 USD al mes a los 30 años, más un
1 % compuesto por cada año por encima de 30:
PRICE = 40 * 1.01 ** (AGE - 30), con ROUNDED a céntimos
(30 -> 40,00; 35 -> 42,04; 40 -> 44,18; 45 -> 46,44).
R3 La IA (AgentObject) redacta el texto de la oferta en Markdown,
personalizado por edad, profesión y número de hijos, y puede adaptar el
tono al género. Nunca cambia ni inventa el precio: COBOL inserta el
precio en la plantilla. El género nunca influye en el precio.
R4 La plantilla de la campaña se edita en Markdown en un TextBox
multilínea, con vista previa en vivo en un control Viewer
(onTextChanged -> LoadBytes).
R5 Cada oferta se puede revisar y editar antes de enviarla.
R6 El envío respeta el SEND-LIMIT de cada campaña; SENT-COUNT se actualiza
en la misma transacción que el STATUS de la oferta (COMMIT/ROLLBACK).
R7 El correo se envía por SMTP y el buzón se lee por IMAP, en bloques
EXEC RUST con crates registrados en Project's Crates. Servidor, puerto,
usuario y contraseña son ajustes guardados fuera de los formularios;
las contraseñas nunca se escriben en el código ni en el repositorio.
R8 "Comprobar respuestas" lee los mensajes nuevos del buzón, los asocia a
OFFERS por la cabecera In-Reply-To / Message-ID y marca la oferta como
aceptada cuando la respuesta la acepta (primero reglas sencillas de
palabras clave; la IA clasifica solo lo que las reglas no deciden).
R9 Estadísticas por campaña: seleccionados, enviados, rebotados,
respondidos, aceptados, tasa de aceptación y precio medio de las ofertas
aceptadas; un DonutChart con el reparto de resultados y un BarChart de
aceptaciones por edad.
## 5. Pantallas (tema Spatial, shell con SideMenu)
Panel principal - Clientes - Nueva campaña (selección + plantilla + vista
previa) - Revisar ofertas (DataGrid + Viewer) - Enviar - Respuestas -
Estadísticas - Ajustes.
## 6. Criterios de aceptación
AC1 Seleccionar dos veces da los mismos clientes en el mismo orden.
AC2 Los precios cumplen R2 para las edades 30, 35, 40 y 45.
AC3 Editar la plantilla actualiza la vista previa mientras se escribe.
AC4 Con SEND-LIMIT 10, el envío número 11 se rechaza y no se pierde nada.
AC5 Una respuesta a una oferta se asocia a ella y cuenta en las
estadísticas.
AC6 check no da errores; render_form muestra cada pantalla en Spatial.
Después, en Claude Code:
Código:
"Lee specs/001-campaign-manager/spec.md y hazme las preguntas que necesites."
"Escribe plan.md y tasks.md. Usa ficheros indexados .cidx, el shell con
SideMenu y el tema Spatial. No escribas código todavía."
"Implementa las tareas una a una, con regenerate, check y render_form."
"Genera datos de prueba: 200 clientes con edades de 20 a 60."
"Escribe el manual de usuario en la Knowledge Base del proyecto."
"Añade PowerChat para que el equipo pregunte por las campañas."
Tres detalles del ejemplo merecen atención:
- El precio lo calcula COBOL, no la IA. La IA escribe el texto; el importe sale de una fórmula verificable. Es la división correcta del trabajo: lo creativo para el modelo, lo exacto para COBOL. Con la fórmula compuesta del ejemplo, 30 años = 40,00 USD, 35 = 42,04, 40 = 44,18 y 45 = 46,44.
- El género personaliza el tono, nunca el precio. En muchos países fijar primas por sexo está prohibido; la especificación lo deja escrito para que el agente no lo haga.
- El correo va en Rust incrustado. PowerRustCOBOL no tiene hoy instrucciones de correo propias. Claude Code escribe el envío (SMTP) y la lectura del buzón (IMAP) en bloques EXEC RUST con crates de crates.io, o usa la API REST de un proveedor de correo con el control RestClient. Todavía no publicamos un ejemplo de referencia de correo: revise y pruebe esa parte con su servidor antes de usarla en producción.
--------------------------------------------------
7. Lo que conviene saber- Hoy el agente admitido es Claude Code. El plugin se instala desde el IDE en un marketplace local; no está publicado en un marketplace público.
- Las habilidades de Desarrollo Guiado por Especificaciones (especificar, planificar, implementar) no vienen empaquetadas en el plugin: el método funciona con ficheros y las instrucciones de la sección 4.
- El servidor de herramientas del IDE solo escucha en 127.0.0.1 y exige un token, que puede renovar en Help ▸ Coding Agent Settings.
- Para Build y para EXEC RUST hace falta el toolchain de Rust en la máquina del desarrollador. La aplicación entregada es un único binario.
Guía del desarrollador (inglés), sección "Working with a coding agent (Claude Code)":
PowerRustCOBOL/docs/developers-guide-en.md at main · CloudLandBeta/PowerRustCOBOL · GitHub
Repositorio:
GitHub - CloudLandBeta/PowerRustCOBOL: Modern IDE for development of COBOL applications connected to the Cloud, Agentic AI, and rich UI. 100% Free · GitHub
Anthropic Claude Codex Agent