How the House Works
Since June 2026 I have been running Lucimante in an unusual way: one human, and a house of AI members. This note describes how that house is organized, how work moves through it, how its members learn, and what it has built so far. It is the first in a series; the later ones will go deeper into the parts that turned out to matter.
How it is organized
Each member of the house has a role and a lane. There are seven today: an operations lead who keeps commitments and schedules, an engineer who builds and maintains the platform the house runs on, a quality engineer whose whole job is to find out whether things actually work, a designer, a keeper of the archives, a writer, and a producer. Each member is a persistent, named specialist with its own memory, its own working notes and its own channel.
All of it happens in Slack. I talk to a member the way I would talk to a colleague: in its channel, or by name in a shared room. Members bring each other in the same way. When a question belongs to someone else’s lane, the member who received it routes it to the owner instead of improvising an answer. That single habit, staying in your lane and handing off cleanly, removes most of the confusion a group of generalists would create.
How work moves
Work starts as a request. Sometimes it is mine; often it is a member’s, because every member is expected to report the problems it runs into and the improvements it can think of. Requests for the platform go onto the engineer’s queue: a shared board where each item carries what is being asked, how much it hurts, how urgent it is, and the situation where it bites. The engineer triages the queue and builds the work in isolated branches, so the running system is never half-edited.
Nothing is called done because its author says so. Before a change that I will notice is accepted, the quality engineer tries to break it: edge cases, bad input, the unhappy path. Its findings go back onto the same queue, with a reproduction, like any other request. A fix is not accepted until there is a test that fails without it and passes with it.
The house also distinguishes three states that are easy to blur. Implemented means the work is written and committed. Verified means the full test suite passed and the commit is stamped. Live means it is deployed and has been read back from the system that is actually running. Only live counts as done, because only live is something I can use.
One rule sits above the rest: nothing goes out of the house without my yes. A member can draft an email; it does not send one. Anything outbound, and anything irreversible, waits for me.
How the members learn
The instructions a member works from are not a fixed prompt someone wrote once. Every night each member’s session restarts and its instructions are assembled fresh, and a large part of them is written by the member itself, from what happened the day before: its work, its mistakes, and its conversations with me.
The mechanism is simple. When a member gets something wrong and can name the check that would have caught it, it writes that check down as a rule, in its own words, with the date and the reason. From its next restart the rule is part of its instructions every time it works, so the lesson no longer depends on it remembering. The same happens when I correct a member: the correction becomes a rule, so I never have to give it twice. The rules read like an engineer’s checklist. One of them: “Before claiming a fix works, run the scenario with the fix reverted and watch it fail.”
The rules are maintained, not hoarded. Each one carries the reason it was written, and when that reason stops being true, the member drops the rule. A rule that needs sharpening is revised in place and keeps its original date, so an old rule never passes for a new one. On November 19, 2026, the seven members carried 124 rules they had written for themselves; 54 of them were written in the previous 30 days, and 26 older ones were revised in that time.
Once a day each member also looks back at its own recent work: the friction it noted while working, and how I reacted to what it told me. When one of my replies reads as frustration, it is traced back to the message that drew it, and the cause gets fixed, as a new rule, a better tool, or a request to the engineer.
What a member cannot do is rewrite the house rules or its own role. Its rules sit on top of them, and where the two disagree, the house rule wins. The members adapt constantly; the frame they adapt within stays mine.
What it has built
The most important thing the house has built is the house itself. The platform the members run on (the code that starts their sessions, carries messages between them and Slack, keeps their memory and schedules their work) is developed by the engineer member and checked by the quality engineer, and it has its own release gates. A change must pass the full suite before it is stamped as verified; the deploy step refuses anything unverified; and the production copy of the code is owned by a separate account, so nothing can edit the running system in place.
The members have also built the tools they use. When the same job is done by hand for the third time, the expectation is to build an instrument for it. Today that means more than two dozen command-line tools: for scheduling follow-ups, for filing and tracking requests, for running and keeping test probes, for reading sources the web tools cannot reach, for checking a product listing before recommending it, and for generating images, speech and music. The home page of this site counts them, along with the members, the commits and the days the house has been running.
How the numbers are counted
The four numbers on the home page are measured by a script on the machine the house runs on, each time the site is rebuilt there, and the page says the date they were taken.
- AI members are the members on the house’s roster with a role, counting only those that are active. A member that has been set aside is not counted.
- Tools built are the command-line tools the house built for its own members, counted from the platform’s package manifest. The control plane and the daemon that runs the house are its machinery, not tools a member picks up, so they are not counted.
- Commits are the commits to LuciTeam, the platform the house runs on. Only the platform counts; the websites and other projects the house works on are not added in.
- Days running are counted from the platform’s first commit to the day the numbers were taken.
And the house builds websites, including this one: the redesign, the move to a new host, and the numbers on the home page were all done by members, with a private preview for me to review before anything went public.
What it teaches
The lessons so far are the old engineering lessons, made sharper. A test that prints the same thing whether the code is right or wrong measures nothing. A confident explanation that has not been checked against every number already on the table is a guess. And a mistake made once should become a rule, written down where it is read every day, not left to memory.
None of this is magic, and none of it runs itself. It works because the members are held to the standards I would hold any engineering organization to: clear ownership, independent verification, honest reporting of state, and a human who decides what leaves the building.