modulos
Skill0 starsChanged todayMITView on GitHub
Define los módulos de la app. Dice qué resuelve cada uno, qué tablas son suyas, de quién depende, quién puede hacer qué y qué se deja listo para lo que pueda venir. Deja el modelo de datos, el mapa de pantallas y el roadmap general. Va después de /iniciar-proyecto y antes de la primera /spec; se vuelve a correr cuando la app suma un módulo.
In this repository8 other files it gives its agents.
- adoptarSkill
- cerrar-specSkill
- dibujarSkill
- estadoSkill
- iniciar-mobileSkill
- iniciar-proyectoSkill
- spec-implSkill
- specSkill
The file
We split this skill into the rules it gives an agent
1 rule. About 0 are common, 1 is distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈1
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 40
No se crea ninguna tabla ni campo para una función que todavía nadie pidió.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
/modulos
Define los módulos de la app. Un módulo es una parte grande de la app, dueña de sus datos. Puede no tener tablas, como la base del sistema o los mails.
Contesta una pregunta: qué partes tiene la app. Si te pasaron algo en $ARGUMENTS, es el módulo que se suma o que cambia: leé lo que ya existe y tocá solo lo que cambia.
Modelo y esfuerzo
Este comando está pensado para Fable 5.2 con esfuerzo alto: cómo se reparten los datos es de lo más caro de cambiar después.
Esta sesión corre con esfuerzo ${CLAUDE_EFFORT}. En la primera línea, decí con qué modelo y qué esfuerzo estás corriendo, y si alguno no es el recomendado, cuál conviene. Después seguí igual: el usuario decide si cambia o sigue así.
La idea
Se busca que cada módulo se ocupe de una sola cosa y dependa poco de los demás. Así, sumar algo más adelante es agregar un módulo, no romper los que ya andan.
Un ejemplo. La app tiene eventos, y algún día podría vender entradas.
- Mal: la tabla
eventollevaprecio_entradayentradas_vendidas. El día que se vendan entradas hay que cambiareventoy todo lo que la usa. - Bien:
eventotiene solo lo suyo (nombre, fecha, lugar, cupo). El día que se vendan entradas se agrega un módulo Entradas, con su tablaentradaque apunta aevento.eventono se toca.
Los nombres de los ejemplos de esta skill están en castellano para que se lean fácil. En el proyecto, las tablas y los campos se llaman como digan sus convenciones de código.
Se deja la puerta abierta; no se construye la habitación. Hoy no se crea la tabla entrada. Solo se cuida que evento no se mezcle con nada, y se anota por qué.
Las reglas
- Cada tabla tiene un solo módulo dueño.
- Un módulo escribe solo en sus tablas. Para cambiar un dato de otro módulo, se lo pide a ese módulo.
- Un módulo nombra los datos de otro solo por su
id. - Cada tabla habla de un solo tema. Un campo que solo le sirve a otro módulo no va ahí.
- Las dependencias van en un solo sentido: si A necesita a B, B no necesita a A.
- No se crea ninguna tabla ni campo para una función que todavía nadie pidió.
Pasos
- Una decisión por pregunta, con tu recomendación primero.
- Se pregunta lo que cambia lo que la app hace. Lo técnico lo decidís vos y lo decís en una línea.
- Cada bloque de preguntas termina el turno: esperá la respuesta antes de seguir.
- Si preguntás con una ventana de preguntas, lo que escribas antes puede quedar tapado. Lo que hace falta para contestar va dentro de la pregunta.
- Lo que el usuario no sabe del negocio va a
Cliente/Preguntas al cliente.md, con su prioridad; no se inventa.
1. Leer
El CLAUDE.md del proyecto, el núcleo (sobre todo las decisiones caras y la versión 1) y las preguntas al cliente. Si ya hay módulos, también Roadmap general.json y el modelo de datos.
2. Proponer los módulos
A partir del núcleo, mostrá una lista: el nombre de cada módulo, qué resuelve en una oración y quién lo usa. Si no lo usa nadie directo, qué módulos se apoyan en él.
- Para saber si algo es un módulo aparte: si se puede explicar sin nombrar a otro, es otro módulo.
- Si un módulo no entra en una oración, son dos.
- Una app chica tiene entre 4 y 8, contando los que no tienen tablas. Con más, fijate si alguno es en realidad una función de otro.
Preguntá si la lista está bien antes de seguir.
3. Las palabras del negocio
Van antes que las tablas, porque las tablas se llaman con estas palabras. Una lista corta: cada palabra del negocio con lo que quiere decir en esta app.
- Una sola palabra para cada cosa. Si en la idea aparecen dos para lo mismo ("recibo" y "liquidación"), preguntá cuál queda.
- Cada palabra lleva al lado su nombre en el código, según las convenciones del
CLAUDE.mddel proyecto: por ejemplo, "turno" esappointment. Es el único nombre que esa cosa va a tener en tablas, clases y rutas. - Una sola cosa para cada palabra. Pasa seguido con "cliente": en la bóveda es quien encargó la app (la carpeta
Cliente/). Si la app tiene clientes propios, en las notas nuevas a quien la encargó se lo nombra de otra forma.
4. Los datos de cada módulo
Para cada módulo, sus tablas en borrador: columnas, tipos, y qué es clave primaria y qué clave foránea. Preguntá lo que no esté definido, en bloques de 3 a 5.
Aplicá las decisiones caras del núcleo. Por ejemplo: si la app la usan varias empresas, toda tabla con datos de una empresa lleva su empresa_id.
5. Las dependencias
Listá quién necesita a quién ("Recibos necesita a Empresas"). Si aparece un círculo, mostralo y proponé cómo cortarlo: casi siempre hay un dato que está en el módulo equivocado.
6. Los permisos
Una tabla por módulo: las acciones en las filas, los roles en las columnas, y sí o no en cada cruce. Quién puede hacer qué es una decisión cara: escrita acá, la usa cada spec.
- Los roles salen de "Quién la usa" del núcleo. Sumá "sin entrar" si hay algo que se ve sin cuenta.
- Lo que el desarrollador hace a mano (por ejemplo, crear la primera cuenta) se anota al pie: no es un rol.
- Preguntá los cruces que el núcleo no define.
7. Las puertas abiertas
Proponé hasta cinco cosas que el cliente podría pedir dentro de un año, y preguntá si son esas. Para cada una, anotá:
- Qué queda listo hoy. Casi siempre es "nada nuevo: el módulo X ya es dueño de lo suyo".
- Qué no se construye hoy. La tabla, el campo o la pantalla que todavía no hacen falta.
Si para dejar una puerta abierta hay que construir algo hoy, no es una puerta abierta: es una función, y va al roadmap o queda afuera.
8. Revisar las reglas
Pasá las seis reglas por cada módulo y cada tabla. Mostrá lo que no cumple y cómo se arregla. No sigas con una regla rota sin que el usuario lo sepa. Lo que queda al límite de una regla se nombra en el resumen.
9. Escribir en el núcleo
Sumá a Proyecto/Núcleo.md cuatro secciones:
- Módulos. Primero las seis reglas, una por línea: las leen
/specy/cerrar-spec. Después, uno por uno: qué resuelve, sus tablas, de quién depende, lo que hace paso a paso y sus reglas de seguridad. - Permisos, con las tablas del paso 6.
- Palabras del negocio.
- Puertas abiertas.
Corregí también lo que el núcleo ya decía y acá cambió (por ejemplo, la versión 1). El núcleo muestra el modelo de datos y el mapa de pantallas con sus dibujos.
10. Dibujar
Con la skill dibujar. Los tres archivos de datos llevan la misma lista "modulos", en el mismo orden, para que cada módulo tenga el mismo color en el modelo de datos y en el mapa de pantallas. El roadmap no pinta los módulos: su color dice qué está hecho y qué falta.
El modelo de datos, en Backend/Estructura/Modelo de datos. Una flecha entre dos colores es una dependencia entre módulos: revisá que coincidan con las del paso 5. Si una tabla está en casi todas (la empresa, cuando la app la usan varias), nombrala en sinFlecha: sus claves llevan la pastilla y no la flecha.
El mapa de pantallas, en borrador, en Frontend/Pantallas/Mapa de pantallas. Una caja por pantalla, con su nombre y lo que se hace en ella. Sirve para descubrir lo que nadie nombró: si aparece una pantalla sin módulo, o un módulo sin pantalla que debería tenerla, volvé al paso 2 y preguntá. La base y los mails no tienen pantalla, y está bien. El diseño fino de cada pantalla se hace en su spec, justo antes de construirla.
El roadmap general, en la raíz de la bóveda. Es el único lugar donde vive el orden de las specs. Mostralo en Inicio.md con ![[Roadmap general.svg]].
- La primera fila es la base del sistema, e incluye publicarla. Desde ahí, cada fila que se cierra queda disponible para mostrar.
- Se construye de a rebanadas: cada fila lleva el backend de algo que una persona puede usar y, al lado, su pantalla. Así siempre hay algo que se puede probar de punta a punta.
- El nombre de cada fila es corto, de hasta tres palabras: se escribe dentro de los carteles de las filas que la necesitan.
- Lo que necesita cada cartel (
necesita) nombra otras filas. Toda fila necesita a la base del sistema, directo o a través de otra: la que no necesita a ninguna otra, nombra a la base. - Cada fila dice su módulo, lo que deja funcionando (
deja) y su tamaño:chico: hasta dos días.mediano: hasta una semana.grande: hasta dos semanas. Si pasa de eso, partí la fila.
version1Hastaes la última fila que hace falta para la versión 1 del núcleo. Las filas de la versión 1 van primero.- Si la app tiene web y mobile, el roadmap general lleva el backend y la web, y el mapa de pantallas es el de la web. Lo de mobile no se dibuja ahora: lo arma
/iniciar-mobile. Las tablas y los permisos sí se piensan desde ahora para los dos.
Mirá los tres dibujos como imagen antes de seguir.
11. Resumen
Mostrá:
- Los módulos, cada uno en una línea.
- Las puertas abiertas, cada una en una línea.
- Cuántas filas tiene la versión 1, y cuántas de cada tamaño.
- Lo que quedó al límite de alguna regla, si hay algo.
- Las preguntas al cliente que frenan algo.
- La primera spec, lista para copiar en una sesión nueva:
/spec <nombre de la primera fila>: <lo que deja funcionando>Antes del resumen, un commit en la bóveda con lo que cambió.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

