# Reduce Until Contact Returns

GREENLOOP is built from a reduction doctrine:

> AI makes expansion effortless. Expansion eventually becomes fog. The work has
> to reduce back into reality before it can be trusted.

This is not a rejection of exploration. Exploration is where the real shape often
appears. The failure mode is when exploration keeps adding layers until the work
loses contact with the thing it was originally trying to touch.

## The Pattern

```text
false precision -> frame captivity -> box -> spiral -> reduction -> contact
```

### False Precision

A bad frame can make perception sharper inside the wrong dimension. The work
feels more detailed, but not more correct.

In agent work, false precision looks like an elaborate plan, many generated
tasks, and confident summaries that still do not prove the result matches the
original intent.

### Frame Captivity

The frame stops being a lens and starts behaving like the world. The agent, the
operator, or the process begins optimizing inside the frame instead of returning
to the real target.

In agent work, this is when the plan becomes more important than the requested
outcome.

### The Box

The box is a model mistaken for reality.

It may be useful at first. It gives names, boundaries, steps, and a sense of
control. But when the box becomes heavier than the work, it stops clarifying and
starts trapping.

### The Spiral

AI accelerates the spiral:

```text
one prompt -> one feature -> one system -> one workflow -> one philosophy ->
another box
```

The spiral is not always laziness or confusion. Often it is unmetabolized
expansion: the machine lets the operator think, generate, and branch faster than
agency can compress.

### Reduction

Reduction is not making the dream smaller. It is making the next move small
enough to become real.

Useful reduction asks:

- What is the actual thing?
- What was the original contact point?
- What must be true for this to count as done?
- What can be made real in one sitting?
- What can be deleted?
- What would still matter if 80% of this disappeared?

### Contact

Contact is restored touch with the real thing:

- the original request;
- the observable behavior;
- the source evidence;
- the runtime state;
- the user's actual need;
- the artifact that survives outside the conversation.

Contact is the difference between a convincing loop and a trustworthy one.

## Generative vs. Defensive Complexity

There are two kinds of complexity.

**Generative complexity** is the necessary mess that helps an idea become real.
It includes wandering, metaphor, contradiction, temporary overreach, and the
pre-verbal shape becoming language. Do not kill this too early.

**Defensive complexity** is the extra layer added because the idea does not feel
real yet. It includes the extra framework, the extra dashboard, the extra
evaluator, the extra prompt, and the system that manages the system while the
artifact still does not exist.

GREENLOOP exists to preserve the first and cut the second.

## The Personal Loop

```text
field -> shape -> reduction -> artifact -> next field
```

Not:

```text
field -> field -> field -> field -> exhaustion
```

The field is exploration. The shape is what begins to emerge. Reduction collapses
the field into a real next move. The artifact proves the loop returned to
reality. Then another field can open.

Every serious AI session should end as one of three things:

- **artifact**: something was made;
- **decision**: a direction was chosen;
- **deletion**: a false layer was removed.

In engineering work, a fourth terminal form matters:

- **verified state**: the harness exits successfully against the stated
  done-when.

## How GREENLOOP Applies The Doctrine

GREENLOOP is reduction applied to AI-assisted development.

| Doctrine | GREENLOOP mechanism |
|---|---|
| Expansion becomes fog | branch pressure and compression-ratio checks |
| The box can trap the work | goal corruption checks against the original request |
| Contact must return | state, worklog, and evidence live on disk |
| The next move must be real | DONE WHEN before execution |
| The process must terminate | GREEN requires a verification harness exit code |
| False completion is dangerous | False-GREEN guard and independent verdict |

## The Public Wedge

Spec tools help plan the work.

GREENLOOP proves whether the work is actually done.

That proof is not a feeling, a summary, or a clean-looking diff. It is a reduced
state:

```text
original request -> done-when -> execution -> verification -> evidence -> GREEN/RED
```

## The Rule

Explore fully.

Reduce violently.

Return to contact.

Make it real.