Principles Library / Upstream Quality

Upstream Quality

Upstream Quality Reduces Downstream Failure Propagation

Act

Showing all 6 practices. Answer the Diagnose questions and the most relevant come first.

Check assumptions before others build on them

Validate assumptions and requirements before other work starts to depend on them.

Start by asking your team: What assumptions are we accepting without early validation?

Avoid · You’ll know it’s working when

Avoid

  • Treating quality as a final check at the end of delivery

You’ll know it’s working when

Defects turn up before merge, and quality feedback lands while the decision can still change.

Test right where the work is made

Put executable tests, automated checks and fast feedback close to the point where work is created.

Start by asking your team: Which quality risks could we detect closer to the point of creation?

Avoid · You’ll know it’s working when

Avoid

  • Treating downstream QA as the main quality mechanism
  • Treating downstream approval as the main quality mechanism

You’ll know it’s working when

Defects turn up before merge, and a change can ship without a long manual regression pass.

Automate checks for failures you've seen before

Automate verification for the failure modes you already know and keep seeing.

Start by asking your team: Where do we first learn that something is wrong?

Avoid · You’ll know it’s working when

Avoid

  • Deferring known quality issues to keep short-term delivery speed

You’ll know it’s working when

Known failures stop coming back, and fewer defects are found after release.

Make quality signals impossible to miss

Make quality signals visible and unavoidable for every meaningful change.

Start by asking your team: How far can an error travel before it becomes visible?

Avoid · You’ll know it’s working when

Avoid

  • Adding more review stages instead of improving upstream quality signals
  • Equating test coverage or checklists with actual confidence

You’ll know it’s working when

Teams can see work is correct before downstream approval, and review layers start to come off.

Use AI evals to catch regressions early

Use AI evaluation frameworks to catch regressions and probabilistic failure modes early.

Start by asking your team: Where could a single upstream error create several downstream consequences?

Avoid · You’ll know it’s working when

Avoid

  • Relying on static evaluation frameworks while system behavior changes

You’ll know it’s working when

Agent evaluations are current, and AI output that passes checks holds up downstream.

Grow autonomy only as far as signals are trusted

Increase automation and agent autonomy only when the team understands and trusts its quality signals.

Start by asking your team: Are our quality signals keeping pace with growing automation and AI-generated work?

Avoid · You’ll know it’s working when

Avoid

  • Assuming AI-generated output needs less scrutiny because it's automated

You’ll know it’s working when

Quality gates fit agent work, and people review agent output before errors pass through several stages.

Overview

Principle intent

Design quality into the earliest stages of delivery so defects, weak assumptions, and invalid outputs are detected or prevented before they propagate through the system.

Read the full intent

The later a quality issue is discovered, the more downstream work may already depend on it. Upstream quality controls reduce rework, instability, and the cost of correction.

When it holds: what it does for you

Errors caught early

Problems show up close to where they're made, before other work depends on them.

Less rework

Teams spend less effort undoing work that was built on early mistakes.

Autonomy you can trust

Automation and agent autonomy grow only as fast as the quality signals people trust.

When it is ignored: from early signs to a lasting condition

Early warning signs · Visible now, cheap to fix

  • Most defects turn up after merge, integration or release.
  • Teams count on downstream testing or approval to tell them work is correct.
  • The same known failures keep coming back.

What happens over time · Accumulates, costly to reverse

  • Defects and wrong assumptions travel through several stages before anyone catches them.
  • Teams spend more and more effort undoing work built on early errors.
  • Extra reviews, approvals and coordination pile up to make up for weak quality signals.

The condition it becomes

Quality Fragility · Primary

Customers find defects before the team does.

How this principle feeds it

problems found after several stages are found after they are cheap to fix.

Batch Amplification · Primary

Problems are found at release, not before it.

How this principle feeds it

the more stages an error crosses, the later it surfaces, typically at release.

Governance Drag · Primary

Work is done. Approvals are not.

How this principle feeds it

approval layers added for weak signals delay finished work without cutting risk in proportion.

Implementation Drift · Secondary

The agents are building. Nobody is sure it still matches the plan.

How this principle feeds it

each agent handles the flawed input correctly, so output looks locally right while the whole drifts from the plan.

Where is your system on this path?

Diagnose

Diagnose

AI signs are on by default. Use the AI switch to exclude them.

1. Which of these early warning signs are you seeing?

  • Most defects turn up after merge, integration or release.
  • Teams count on downstream testing or approval to tell them work is correct.
  • The same known failures keep coming back.
  • Quality feedback arrives after the decision it should have shaped.
  • Each change needs a long manual regression pass before release.
  • AI output passes automated checks, then fails business or structural expectations later. (AI)
  • Agent evaluations are missing, incomplete or out of date. (AI)
  • Quality gates and the definition of done still assume human-made work. (AI)
  • Human review happens only after agent errors pass through several stages. (AI)

2. Over the last few months, have you noticed…

For each consequence: Not seen / Sometimes / Persistently / Not sure.

  • Defects and wrong assumptions travel through several stages before anyone catches them.
  • Teams spend more and more effort undoing work built on early errors.
  • Release dates slip, and fewer people trust a release will hold up.
  • Extra reviews, approvals and coordination pile up to make up for weak quality signals.
  • The system gets harder and riskier to change.
  • Small upstream errors spread fast across automated agent pipelines. (AI)

3. The condition it becomes

Based on your answers, recognize at most two conditions: No / Partly / Yes, that is us.

Quality Fragility: Customers find defects before the team does.

Batch Amplification: Problems are found at release, not before it.

Governance Drag: Work is done. Approvals are not.

Implementation Drift: The agents are building. Nobody is sure it still matches the plan.

Take your Diagnosis to the next level by invoking AI Diagnostic Coaching tool.

What else have you observed? Optional. Shared only if you choose to start coaching.

Start a Diagnosis session: review and edit a draft containing your note, conditions you recognized in Step 3 (including whether they match partly), warning signs and consequence ratings before sending it. No scores or principle files are sent.

See what practices will help you