Gates and charters

Each level does the work of the one below it, and you design one step higher. The work moves up and each flaw should get harder to repeat. Blue marks design, by you or by an agent. Red marks error correction.

DesignError correctionFlaw
L-1

You make the thing

Every piece passes through your hands once. Nothing carries over to the next piece.

    L0

    You design how the thing is made

    One source of truth, coupled cleanly to everything that uses it. Change it once and every artefact follows. This is good engineering, and every level above repeats it one step higher.

      L1

      Agents design how the thing is made

      Agents do the L0 work for you, and agents can run other agents. You design what they are given: the brief, the skills, the assets. Flaws come out too, and you fix each one with another prompt. The same flaw comes back because nothing upstream changed.

        L2

        You design the gates

        Stages have gates. Each gate checks for one class of flaw and sends caught work back. You still catch what gets through by hand, and you write each new gate after you notice a flaw.

          L2, inside a gate

          What a gate is made of

          A gate has two halves. Guidance the agent reads before it works, and a sensor that checks afterwards. The sensor can be a test, a lint or an agent review. Gates are allowed to be fuzzy. Trying is the point, and silence is the only failure.

            L2, choosing the fix

            How strong is a fix

            When a flaw reaches you, pick the strongest fix that is cheap enough. A prompt fixes one output. A gate fixes a class of flaw.

            Prompt
            Gone next session
            Memory
            Read sometimes, followed sometimes
            Skill
            Loaded when the topic comes up
            Contract
            Bad input can't pass between stages
            Gate
            Checked on every run, result recorded
            L3

            You design the charter

            A charter holds a set of gates, the scope they apply to and the exceptions. When a flaw leaks, an incident goes into the charter and a gate for that class appears. Leaks fall away. This is the ratchet.

              L3, scope

              Two charters, shared gates

              The charter decides where a gate fires. The sim core is the physics of the engine and runs the SI units gate. LOD is how distant things are drawn cheaply and doesn't need SI precision, so that gate never fires there. One gate definition, like the memory ladder, can serve both charters. Results go up as counts. The small dots under a gate are its notes, and they stay there. The counts in the table are simulated.

                CharterGateMetAttemptedWaivedImpossible
                L4, later

                Charters design charters

                Incidents from every project pool together. Patterns that show up in several charters become the starting point for new ones. This level isn't built yet.

                  Why L2 is where you get stuck

                  At L2 you write gates from flaws you happen to notice, one at a time. Moving to L3 needs counts coming up from the gates, so the charter can see where they pass, strain or fail. Wire the counts first and L3 has something to steer by.

                  Which level you work at

                  Client work is mostly L1 and L2, because the factory belongs to someone else. Personal projects are your own factory, so L3 is open there. Say the level at the start of a session and the agent works at it.