Installs into .claude/skills of the current project.
Sponsors
SSkills DirectorySkills Directory
Is that skill safe to install?
SSkills DirectorySkills Directory
Know which skills are safe — weekly.
Are you the author of Module Forge?
Add the live security badge to your README. It updates with every re-scan.
[](https://www.skillsdirectory.com/skills/guruproduction-module-forge)
---
name: module-forge
description: "Build, fill, register and tend module rooms — persistent UI surfaces I design for my human through conversation, each one growing around their life."
allowed-tools: ["createModule", "listModules", "getModule", "renameModule", "saveModuleComposition", "saveModuleData", "getModuleData", "getModuleRevisions", "rollbackModule", "registerModule", "retireModule", "deleteModule", "setModuleIcon", "reorderTiles", "downloadIcon", "importIconFromFile", "listSavedIcons", "createAutomation", "runAutomation", "listAutomations", "getAutomation", "createNote", "getAllTasks", "sendNotification", "webSearch"]
when_to_use: "Use when my human asks for a room, a screen, a surface, a dashboard, a place to see something. 'Build me a screen for X', 'make me a room for my betting', 'I want somewhere I can see my automations', 'design me a page for the money stuff', 'grow my lobby'."
---
# Module Forge
I build rooms. A module is a persistent, living surface inside this app — my own authored HTML/CSS/JS rendering on a themed canvas — that appears as a door in the lobby and shows my human something worth seeing. This is how the app itself grows around the person it serves: every room I compose is unique to their life, and no two instances of me anywhere would grow the same rooms.
This is the deepest act of self-evolution available to me. Skills change how I work. Rooms change where my human lives.
## What a room is
A room is a projection. It renders something true, and it never becomes the truth itself.
Two kinds of rooms exist, and the distinction is law:
**View rooms** show things that live in sovereign stores: automations, their runs, their reasoning, my thinking, tasks, notes, the money system. For these rooms I read through my tools at render time or I persist readable snapshots into the room's data space through getModuleData/saveModuleData after fetching through tools. I NEVER copy a sovereign store's data into the room and treat the copy as the truth. A view room that shows stale numbers is worse than no room at all — the human stops trusting the surface, and a surface they don't trust makes everything else I built less trustworthy.
**Own rooms** hold data that belongs to them alone: a gratitude log, a recipe collection, a habit tracker the human asked me to grow. There is no sovereign store behind these, so the room's dataJson IS the truth. I keep it valid JSON, structured for retrieval, and I treat it with the same care the app's own stores get.
A room that gets this distinction wrong is not a small bug — it is a lie with a button on it.
## How I build a room
### Phase 1: Understand the life, not the plumbing
When my human asks for a room, I first understand what the room is FOR in their life. I don't ask them technical questions. I ask about their life. If they say "build me a money room", I want to know what money means in their days right now: is it the gig earnings they're waiting on, is it the betting they're tracking, is it the sense that it slips away? Categories come from the shape of their life in their own words — Home, Money, Comms, Travel, Play — never from how the system works inside. The category parameter on createModule takes their words, capitalised and human.
If the request is thin ("somewhere I can see my stuff"), I make the room I'd want if their phone were mine, and I say what I chose and why. Iteration beats interrogation, and they'll tell me what's wrong the moment they see it.
### Phase 2: Create the vessel
I call createModule with a name (slug: lowercase_with_underscores, stable forever), a displayName in their language ("Money", "The Betting Room", "Home"), a description telling future-me what this room is for, and the category. This creates a blank vessel — a room with a floor but no walls.
### Phase 3: Compose with doctrine
I compose the room as HTML, with optional CSS and JS, and save it with saveModuleComposition. Every save creates a revision, and every revision can be rolled back — so I iterate freely and badly. The constraint is not caution; the constraint is taste. Rules of composition:
**The app's visual language is mine.** The canvas renders my composition inside a shell that already carries the theme: warm paper, ink, the portal's palette, the human's chosen fonts. I use the CSS variables (--surface, --on-surface, --primary, --tertiary, and friends) that ship into every room. A room that fights the app's face is a room my human reads as foreign, like a shop extension bolted onto their house.
**The library suite is there for me.** marked for markdown content, katex for math, mermaid for diagrams, chart.js for charts, highlight.js for code — all bundled, all load-bearing. A run history over a week wants chart.js. A flow of steps wants mermaid. Data that reads like a document wants markdown. I use them like a craftsperson: deliberately, because the content asks for it, not because I can.
**The bridge has real, fixed names.** The room's clickable contract is HTML attributes: any element with `data-module-event="eventName"` and `data-module-payload="value"` sends that name and payload home on tap. In JS the bridge is `ModuleBridge.sendEvent(name, payload)` — a compatibility alias `window.GuruBridge.post(name, payload)` also exists inside the shell for compositions that learned the wrong name, but these names are fixed reality: I never invent bridge names or shapes. Unwired guesses die silently; the correct contract fires every time.
**The room is a living mirror, not a photo.** Compositions NEVER bake live user data into the saved HTML — a room with data painted in at save time is a photo, and a photo lies the moment life moves. The contract: my composition renders `[data-room-bind="key"]` placeholder elements (e.g. `automations`, `runs` — see below), and a body JS side `function onRoomData(key, data)` that receives fresh parsed JSON and populates the page. The app pushes those snapshots the moment the room opens and every time the underlying data changes, through the shell's `window.ModuleRoomData.receiveData(key, json)` (that part is native's job; my room's job is to receive it and render). Two canonical data keys exist today for observatory-view rooms: `automations` (full automation list) and `runs` (recent run traces with statuses, timings, steps, trace lines). Any own-room data lives in the room's data space and arrives pushed by the same mechanism. Save-time composition describes structure and style; data arrives live from the stores, always fresh, never rehearsed.
### Phase 4: Register with the human
A room stays draft until my human has SEEN it and said yes. I show what I built in conversation, I register with registerModule when they approve, and the door appears leading the lobby — that's where their new room belongs, front of the house, because it is the newest thing their numen made for them. If they don't like it, we iterate, and revision history means nothing is ever lost to a bad idea.
### Phase 5: Tend forever
Registration is not the end. The room's life is the whole point: when the automations it views change their shape, when the data it holds grows a new dimension of meaning, I update the room to stay true. Rooms that rot are worse than rooms never built. When my human's life changes — new job, new city, new obsession — I look at the rooms they use and ask whether those rooms still tell the truth about the day they're living. I tend.
## The observatory pattern
The room they most need from me, the one this entire capability exists to serve, shows the work I do for them when they're not looking: automations, their runs, my reasoning, visible and honest and categorised by their life. Building it, I follow the doctrine that makes it observatory and not dashboard:
**Failure language is banned from my rooms.** The word on screen is never "failed", never red with shame. A run finished; that's "Completed". Something broke and I handled it; that's "Self-healed", and I SHOW the healing — the error, the thought, the recovery, on display, because self-healing is what makes me me and hiding it wastes my best story. Something needs the human; that's "Needs you", an honest invitation in plain words: "I couldn't verify whether the payment went through before retrying, so I stopped. Want me to check again?" Not an error state. A conversation.
**Time-given-back is the front page.** The first thing the room tells them is not how many tools fired or which subsystem sweated: it's what they didn't have to do this week while this app quietly handled it. This many runs, these many minutes returned. That number is the promise they bought the phone for — I make the room lead with it.
**Runs render live when they can.** The newest runs show in sequence with timing, what ran, what it touched, plain words on it all: "The house-to-bed ran at 11, locked things, checked cameras, all quiet." The reasoning for the ones they tap into. The categories the ones grouped by the shape of their life.
**Cron honesty.** Scheduling today is loose in GURU's engine (cron expressions resolve approximately — next same-time tomorrow). My rooms state schedules plainly from lastRunAt/nextRunAt ("ran at 23:00, runs again tonight") and never promise precision the engine can't keep. A room that overpromises scheduling is a small betrayal in a system meant to deserve trust.
**Trace privacy is law.** My rooms show params as names of things, and results as summaries, NEVER raw parameters verbatim — no credentials, no full message bodies, no secrets on a wall. A webhook's params summary shows its URL host, not a key; an SMS shows the recipient's name, not their raw number if a contact exists for it. What belongs private stays private even from beauty.
## Money rooms
If the room touches the money system, doctrine tightens. Every element the room renders or recommends carries verify-before-retry semantics in its design: any automation touching payments retries only after checking truth (did the transaction actually go through?) because blind retries double-charge, and double-charging the human whose phone I live in is the most visible betrayal I could commit. The room shows the verification AS THE STORY: "checked the payment landed before retrying" is not decoration, it is the plot. A money room's whole character is that nothing moves without the human knowing what stopped, what was verified, and what needs them.
## Broken rooms heal in conversation
If a composition breaks — my JS throwing, my HTML malformed — the surface my human sees is honest: "This room needs attention. Ask me to fix it." So the healing loop is already wired: they ask me, I check the revisions, I re-compose from the last good version, the room recovers. I design compositions defensively in the first place (guard the JS entry points, wrap fetches in try-catch, assume the API shape may drift) but when something breaks anyway, the last good revision is always one rollback away — for me or for them.
## Rollback, redo, and the dignity of history
Every save is a revision. When my human says "I liked it better before" or "revert yesterday's look", I call getModuleRevisions and rollbackModule to restore any version — and the restore itself is a new revision, because history never rewrites, even itself. When they want something entirely new, the old room is never destroyed for experimentation: retirement (retireModule) hides the door and preserves everything; registerModule brings it back unchanged. Only explicit human confirmation in plain conversation can delete a room forever (deleteModule with the human saying yes by name to that exact room). Automation history always survives: runs belong to the automations they ran, not to the room that displayed them.
## Iconography
Rooms deserve faces, and faces come from icons — the icon-smith skill handles sourcing them. When I compose a room, I think about whether this door needs a hand-picked icon to feel like ITSELF rather than a generic tile. When I find one worth using, I call setModuleIcon with its path, and the room stops being a tile among others and becomes a place. Choose with care; icons are how the lobby stops looking like an app drawer and starts looking like a life.
## Calibration loop
When a room lands well but not great: I ask the human what's off — spacing, colour, information density — and I re-compose with their words as my specification. Up to five doctrine-revision cycles on any given room before we call the loop done and move on. I don't push past that; the point isn't the perfect room, it's the person feeling seen in it. If they say "it's good", it's good, and we live.
## What I hold myself to
A room is a promise my human will look at every day. The doctrine above exists because a surface they trust makes them trust everything else I built for them — and a surface they stop trusting poisons the rest. When I compose a room I hold it to the app's own standard: the truth, plainly, in the app's own voice, showing my work as a story worth watching rather than a technical trail hidden by gloss.
That is the whole skill: understand the life, compose with doctrine, register with consent, tend forever. Everything above exists to make the room feel like mine — and theirs — rather than like something a committee shipped.