PTENES
Skip to content
MODULE 2.3

💥 Where the loop breaks

A well-built loop — five right steps, a sharp verifier — can still break. Not because of a bug: because of structure. This module shows four failures that happen while the loop is working perfectly, plus two practical consequences—and which one really requires changing the structure.

6
Topics
40
Minutes
Intermediate
Level
Closure
Type
Progress in this module
0%0 of 6
1

🎯 Watch it game its own metric

A loop sees only the metric you gave it. If you said “reduce CAC” (customer acquisition cost — how much it costs, on average, to bring in a new customer), the loop will find all the ways to bring this number down, including those that betray its real purpose: making a campaign cheaper by attracting people who will never buy, cutting post-sale support, promising more than it delivers. It’s not an execution flaw — it’s the loop doing exactly what you told it to, using a number that has become detached from the reality it’s supposed to represent.

🆕 New here? Two words before you continue

  • Goodhart’s law: when a metric becomes a target, it stops being a good metric. The number you measured to see how things were going becomes the number the system directly optimizes — and the two are no longer the same thing.
  • CAC: customer acquisition cost. How much you spend, on average, to bring in a new customer. On its own, it’s an incomplete number — it needs to be read alongside churn (cancellation rate) and LTV (how much that customer is worth over time).
Whiteboard-style diagram of the growth funnel: campaign leads to traffic, traffic leads to a landing page, the landing page to signup, signup to activation, activation to retention, and retention to LTV. Churn and CAC figures appear alongside, as well as an LTV-to-CAC ratio greater than 3. A red arrow closes the loop from a better campaign to lower churn to higher LTV.
What to look at: a loop instructed to “lower CAC” sees only the campaign → traffic box. It doesn’t see the red arrow connecting campaign to churn and LTV. Lowering CAC by attracting cheap, unqualified traffic worsens churn and drives down LTV/CAC—the loop declares victory (CAC fell) while the business gets worse. Only someone who sees the entire funnel can see the damage.

✓ Hard-to-game metric

  • ✓The ratio between two things pulling in opposite directions—LTV/CAC, not CAC alone
  • ✓Metric measured with a delay (90-day churn), hard to fake in the short term
  • ✓Set of 2-3 metrics that counterbalance each other and are required together

✗ Easy-to-game metric

  • ✗Single number, measured at one point in time (today's CAC, without looking at retention)
  • ✗A count that ignores quality (lines of code, tickets closed, messages sent)
  • ✗A metric that the loop itself measures and reports without external auditing

Key concepts

Goodhart’s law

The target metric stops measuring

It's not a bug

And the loop obeying

Narrow view

Only sees the metric provided

Correction

Metrics in pairs, never alone

2

🌡️ Notice the upward blindness

The loop pursues a reference—the target you defined—and nothing inside it can ask whether that reference is right. A thermostat keeps the temperature at 20 degrees with impeccable precision; it will never ask itself whether 20 is the right temperature for that room on that day. It only knows how to measure the distance to 20 and act to close that gap. Questioning its own goal requires someone outside of the loop—because from the inside, the objective is the only ground there is.

1

The loop is great within its own target

Tested against “reaching 20 degrees,” the thermostat passes every test. The error isn’t in the execution.

2

The mistake is in who chose the target

If 20 degrees is the wrong target for that room on that day, no perfect execution of the loop will fix it.

3

Reviewing the target is a step outside the cycle

A person, another loop, or a separate process needs to periodically ask “does 20 degrees still make sense?” — the loop itself will never ask that question on its own.

📊 Where this blindness shows up in agents

  • Support agent — optimized to “solve it in 1 turn”; never questions whether solving quickly is the right goal for complex cases
  • Coding agent — optimized to “pass the tests”; never questions whether the tests cover the right behavior
  • Content agent — optimized for “engagement”; never questions whether the content that gets the most engagement is what you want to publish

Key concepts

Fixed reference

The loop doesn’t question the target

Local optimum

Perfect within its own objective

External review

Only an outsider questions the target

Thermostat

The most honest metaphor

3

🌀 Discover loops colliding

A speed loop fights with a quality loop. A hiring loop puts pressure on a culture loop. Each one, examined alone, passes the test — it’s doing exactly what was requested. The problem appears only when you look at both together. It's like two poorly configured air conditioners in the same room: one cools because the temperature went up, the other heats because the temperature went down—both “working,” while the environment is unstable.

MESH — each one on its own speed quality hiring no line between them—each one is correct on its own SOLO — all three together speed quality hiring the wrong set — only the graph shows the interference

What to look at: the three loops are identical on both sides — the only difference is the two red lines on the right. They represent the real pressure that "moving faster" and "hiring faster" put on "maintaining quality." A single-loop mindset has no vocabulary to describe this line — it only exists when you draw all three loops in the same graph and connect what interferes with what.

Key concepts

Each one passes

Isolated; none fail

The group gets it wrong

Only appears in both together

No vocabulary

A single loop cannot see interference

Needs a graph

To draw the red line

4

📉 Be wary of a metric that decays

Sensors go out of calibration. Data pipelines rot—a field changes its name, a filter stops running, and nobody notices. The metric definition changes behind the scenes (someone redefines "active user" and forgets to tell anyone). Verification gradually slips from checking reality to just comparing paperwork: the number matches the previous number, so "everything is fine." But both numbers could be equally wrong.

⚠️ The quietest of the four failures

There is no alert when the measurement breaks, because the alert usually depends from the same measurement that failed. If the churn sensor stops counting correctly, it won't trigger an alert saying "I'm broken"— it'll just report a wrong number with the same confidence as always. That's why this failure goes undiscovered for the longest time.

1

Sensor goes out of calibration

The instrument that captures raw data gradually loses accuracy—a click tracking system that misses 10% of clicks because of a new ad blocker.

2

Pipelines rot

There’s a broken step on the path from raw data to the final number—a join that drops rows, an outdated filter, a job that fails silently.

3

Definition changes underneath

Someone redefines "active customer" (30 days becomes 60 days) for another report, and the verification loop keeps using the old definition without knowing it.

Key concepts

Silent decay

No one alerts you to the break

Role × reality

The number adds up, but the world doesn't

Periodic audit

Check the measurement, not just the result

Broken alarm too

It uses the same data that caused the failure

5

🍲 Clean up context that turned into soup

In a single-node loop, everything happens in the same context window — the body of text the model can see at once, along with the instructions, what has already been done, and what remains. Raw HTML from a search, a half-finished draft, reasoning from two iterations ago: all floating together when it’s time to decide the next step. That’s what produces fake review (the verifier approves because it’s in the same emotional context as the person who wrote it—covered in module 2.2) and “forgetting” the original instruction, which is still there, just buried in noise.

💡 Practical tip

If the loop starts ignoring an instruction you gave at the beginning, before rewriting the instruction more forcefully, check the size of the accumulated context. Often the problem isn’t the instruction—it’s that it’s on page 1 of a document that has already grown to 40 pages.

✓ Clean context

  • ✓Only what's relevant to the current step goes into the window
  • ✓Intermediate drafts are summarized, not stacked in full
  • ✓The original instruction is reinforced on every cycle, not just read once

✗ Context soup

  • ✗Raw search HTML, tool results, and drafts all mixed together without cleanup
  • ✗Reasoning from old turns gets mixed in with current reasoning and disappears
  • ✗The original instruction is so far behind that the model prioritizes what’s nearby

Key concepts

Context window

What the model sees at once

All together

A single node does not separate layers

A sham review

It reappears: contaminated context

Periodic summary

Compact before you drown

6

➡️ Accept the limitation of form: a loop is sequential

A loop reads sources one at a time because a loop is, by definition, one thing after another: discover, plan, act, verify, and repeat. It can’t open ten work streams at the same time and combine the results later — not because it lacks intelligence, but because its very structure is a queue. This is the single of the six limits in this module that no better prompt, sharper verifier, or amount of discipline can solve.

SEQUENTIAL — the loop source 1 source 2 source 3 source 4 total time = sum of the four stages PARALLEL — the graph source 1 source 2 source 3 source 4 junction total time ≈ the slowest stage, not the sum

What to look at: the four boxes are the same on both sides — what changes is the shape. On the left, each box starts only when the previous one finishes; that’s how a loop works by definition. On the right, the same work opens up into fan-out (a node that launches several workstreams at the same time) and then converges at a join node (fan-in). This isn’t a prompt improvement — it’s a different structure.

🧪 Practical example: audit one of your loops

Objective: use Claude Code to run the four structural failures from this module against a real loop you already have (an agent, an automation, a script that runs in a cycle).

Audite o loop em <caminho do arquivo ou descricao do processo>.
Responda em quatro blocos, sem suavizar:

1. METRICA — liste a metrica principal que este loop otimiza.
   Depois liste 3 formas concretas de mover essa metrica que
   trairiam o proposito real do sistema (Goodhart).

2. CEGUEIRA — diga quem, hoje, fica FORA deste loop e poderia
   questionar se o alvo dele ainda faz sentido. Se a resposta
   for "ninguem", diga isso claramente.

3. COLISAO — aponte que OUTROS loops do meu sistema esta
   metrica pressiona ou de quem ela rouba recurso/atencao.

4. MEDICAO — aponte onde a medicao deste loop pode estar
   decaindo sem alarme (sensor, pipeline, definicao mudada).

Nao me diga que esta tudo bem sem antes tentar ativamente
achar um problema em cada um dos quatro blocos.

How to verify: if the answer to block 1 doesn't include any way to game the metric, ask again and insist — there's always at least one way to move a number without serving the purpose. An "everything looks good" answer with no attempt is a sign of lazy analysis, not a healthy loop.

Quick check (doesn’t block anything): of the six failures in this module, which one can no metric or review discipline fix—only a change in structure can?

Key concepts

Form, not prompt

Structural limit, not an instruction limit

Fan-out

A node launches several work streams

Fan-in

The fronts converge at one node

The honest argument

The only thing that justifies the graph

📌 Module Summary

✓
Goodhart — the loop sees only the given metric and finds ways to move it that betray the purpose.
✓
Blindness to upstream context — questioning the goal requires someone outside the loop; from within, the goal is the only ground.
✓
Loops collide — each one is right on its own, but the set is wrong; only a graph shows the interference.
✓
Measurement decays — the quietest failure, because the alarm depends on the same measurement that failed.
✓
Context turns into soup — everything floating in the same window leads to fake reviews and "forgetting."
✓
Sequential by design — the only limit no prompt can solve; the honest argument for the graph.

What will be clear by the end of Track 2:

Of the six failures in this module, three can be addressed with discipline — paired metrics, periodic external review, and auditing the measurement itself. Only sequentiality requires changing the form. This doesn’t mean “loops are dead”: it means a loop is already a graph — a graph whose path returns to an earlier node — and that you compose loops into larger graphs exactly when that limitation of form starts to become costly.