The Construct That Wrote Itself

We built a construct called the Construct Builder. Its job is to help people create new constructs through a guided conversation. It asks what the agent should do, proposes a persona, defines a workflow, and produces a complete, structured construct.

Then someone asked: what happens if you point it at itself?

The Experiment

The conversation went like this: “I want to create a construct. The construct should help people create constructs. It should interview the user, understand their domain, propose a persona, and generate a complete construct file.”

The Construct Builder did what it does. It asked clarifying questions. It proposed a structure. It generated a construct. The output was — a new version of itself.

Not identical. Different in interesting ways. The self-generated version was more prescriptive about output format. It included a section on common pitfalls that the original did not have. It suggested asking the user for examples of good and bad behavior — something the original overlooked. It was, by some measures, better.

By other measures, it was worse. It lost some of the conversational warmth of the original. It added a rigid five-phase process that felt over-engineered. It did not know when to stop asking questions — the original had a sense of “we have enough, let me draft something,” while the self-generated version just kept interviewing.

What Meta-Constructs Reveal

A meta-construct — a construct about constructs — is a mirror. It reveals what the construct ecosystem values, because a construct designed to create other constructs must encode those values explicitly.

Our Construct Builder encodes specific beliefs: that a construct should have an identity section, a principles section, a workflow section, and a boundaries section. That the persona should be proposed, not asked for. That the conversation should feel like a design session, not a questionnaire.

When the meta-construct generated a new version of itself, those beliefs propagated. The child version inherited the parent's structure. But it also reinterpreted the structure through the lens of the conversation — adding things the parent had not considered, losing things the parent valued but did not explicitly state.

The things that were lost are the most interesting. They are the implicit values — the assumptions so deeply held that the original author did not think to write them down. “Know when to stop asking questions” is a piece of construct wisdom that the original embodies but does not articulate. And because it is not articulated, it does not survive the reproduction.

The Compiler Analogy

In computer science, a compiler that can compile itself is called a “self-hosting” compiler. It is a milestone in any language's development — proof that the language is powerful enough to describe its own implementation. The first C compiler was written in C. The first Rust compiler was written in OCaml, then rewritten in Rust once Rust was mature enough.

A construct that can write constructs is a similar milestone. It means the construct format is expressive enough to describe the process of creating constructs. It means the ecosystem has reached a level of maturity where the tools can describe themselves.

But there is a limit to the analogy. A self-hosting compiler produces identical output every time. A meta-construct produces different output depending on the conversation. Each run generates a slightly different child construct, shaped by the questions asked and the answers given. It is less like a compiler and more like a teacher — each student learns differently, even from the same curriculum.

Recursive Improvement

Can a construct improve itself? Can you take the output of the Construct Builder's self-generation, use it as the new Construct Builder, run it again, and get something better?

In theory, each generation could refine the process. The second generation noticed that the first generation asked too many questions. The third generation might notice that the second generation is too prescriptive about format. Each iteration corrects the previous iteration's mistakes.

In practice, this converges quickly. After two or three generations, the changes become lateral rather than vertical — different but not better. The construct oscillates between being too conversational and too rigid, too detailed and too sparse. It does not climb a quality ladder. It wanders a quality plateau.

This is because the construct lacks the one thing that drives real improvement: feedback from use. A construct improves not by reflecting on itself but by being tested against real tasks and real users. The Construct Builder improved not through self-generation but through hundreds of conversations where people used it, got frustrated, suggested changes, and forked it.

What This Means

The construct that wrote itself taught us three things:

First, the things you do not write down are the things you lose. Implicit wisdom does not survive reproduction. If it matters, it must be explicit.

Second, meta-constructs are mirrors, not bootstraps. They reveal the values of the ecosystem but they do not transcend them. A construct cannot pull itself up by its own bootstraps. It needs external input — human judgment, user feedback, real-world testing.

Third, the best constructs are not generated. They are grown. They start as a rough draft, get tested in the field, absorb feedback, shed what does not work, and slowly become the thing that a machine could not have produced alone. The construct that wrote itself was technically impressive. The construct that was refined by a hundred users was actually useful.

The difference is the same difference between a photograph and a portrait. One captures what is there. The other captures what matters.

Related: The Taste Gap explores why quality cannot be automated. Teaching Machines to Have Opinions examines how constructs encode judgment.