Code gets cheap.
Engineering doesn’t.

Working software is useful only when it changes an outcome we care about.

Generated code is inventory until it produces evidence of value.

We prefer:

a smaller validated change

over:

a larger impressive implementation.

Keeping every engineer and every agent busy is not the goal.

A system with ten concurrent AI-generated changes and a review bottleneck is not productive. It is congested.

We prefer low work in progress, short queues, and fast feedback over local utilization.

AI should increase throughput inside the WIP limit, not justify increasing WIP.

AI reduces the cost of producing large changes.

That makes small changes more valuable, not less.

We prefer changes that can be:

• understood;
• tested;
• reviewed;
• deployed;
• reverted or forward-fixed;
• observed

independently.

Cheap generation is not permission for large batches.

Plausibility is one of AI's strengths and one of its risks.

A coherent implementation can still be based on a false assumption.

We therefore prefer executable or observable evidence:

• tests;
• contracts;
• invariants;
• production telemetry;
• reconciliation;
• benchmarks;
• experiments;
• user behavior

over confident explanations.

The cost of understanding a change must not be transferred downstream.

The author of a change remains responsible for making it reviewable, regardless of who or what generated it.

We reject the pattern:

cheap generation
-> expensive human review
-> hidden organizational cost

A useful constraint is:

No faster than understanding.

This does not require memorizing every line. It requires sufficient understanding to explain the problem, important decisions, trade-offs, failure modes, and evidence.

We do not want regions of the system that only one engineer and their agent can safely modify.

Knowledge should remain transferable through:

• small changes;
• tests;
• executable contracts;
• simple design;
• shared operation;
• pairing or swarming when useful;
• production feedback.

AI must reduce the cost of knowledge sharing, not create private synthetic expertise.

AI is very good at producing complete-looking abstractions.

Completeness is not the same as necessity.

We prefer the simplest design that satisfies current evidence and preserves cheap future change.

We refactor when pressure appears.

We do not pre-pay complexity because generation is cheap.

Integration is a feedback mechanism, not an administrative stage.

We prefer:

• trunk-based development;
• short-lived changes;
• feature flags where needed;
• build once/promote many;
• reproducible validation;
• frequent integration.

A branch that contains days of agent work is delayed feedback.

AI can generate, inspect, explain, and propose.

It cannot own organizational accountability.

The engineer accepting a change remains responsible for:

• understanding its intent;
• evaluating important trade-offs;
• validating relevant evidence;
• escalating uncertainty;
• operating the result.

"AI generated it" is neither a quality exception nor an incident explanation.

Lean and XP are not ceremonies.

A practice exists because it improves a feedback loop or reduces a known form of waste.

When a practice no longer improves the system, we change or remove it.

We prefer evidence that the system is improving over evidence that the team followed the process.