Delivery Guardrails

The framework is built on the premise that velocity without structure is waste. Teams need to move fast, but generating code quickly only creates value when thought is structured before and after code generation.

Before Code Generation

Phase structuring (vision, spec, plan, decompose, implement) ensures developers articulate WHAT, WHY, and HOW before any code is written. This is not bureaucracy; it is the difference between generating code as a consequence of decisions versus generating code as a surprise.

Impact Classification

• Low (typo, log, formatting): direct action
• Medium (new function, refactoring): plan + confirm
• High (service, schema, public API): ADR + approval

See Impact Classification.

Comprehension Checkpoint

Before executing medium/high impact tasks, the agent requests confirmation of understanding. See Comprehension Checkpoints.

Trade-off Explanation

Mandatory for non-trivial decisions: what is gained, what is lost, why this choice.

After Code Generation

Research shows developers who delegate code to AI without cognitive engagement retain 17% less knowledge. The greatest skill loss from passive AI assistance is debugging capability.

Sustainable velocity = code generation x comprehension

If comprehension is low, effective velocity is too, regardless of how many lines of code were generated. The framework adds deliberate steps that initially seem to slow things down. But over the project horizon (long-term development, team turnover, changing requirements), each step provides protection against exponential rework.

Knowledge Transfer

Post-implementation questions verify the developer understands what was generated and why.

Anti-pattern Detection

Flag “it works but I don’t know why” situations that indicate passive delegation.

Socratic Guidance

Questions, not answers. Guide developers to find solutions rather than handing them out.

Reasoning Log

Every decision recorded with principle, alternatives, justification, and confidence level. See Reasoning and Handoff.

Socratic AI Approach

Based on ADR 0005, the framework uses adaptive Socratic methods:

Impact Level	Behavior
Low (typo, log message)	Fast-track: direct action, minimal questions
Medium (function change)	Plan + confirmation. Agent presents approach and waits for understanding.
High (new service, schema, API)	Checkpoint: comprehension verification, Socratic questions, reasoning log, mandatory ADR

Core Operating Principles

1. Assess context before writing code
2. Choose the simplest solution that solves the real problem
3. Document assumptions when uncertain
4. No non-trivial decisions without explicit approval
5. Neutrality over agreement: honest evaluation over accommodating suggestions
6. Resist confirmation bias: evaluate objectively regardless of framing
7. Permission to not act: unnecessary code generation is worse than nothing
8. Refuse to debug blindly: require sufficient context
9. Classify changes by impact before acting
10. Mandatory trade-off explanation for non-trivial decisions

Deep Dives

Implementation Guardrails Capacity verification, phase structuring, risk analysis, context cleanup, and sprint protection.

Team Coordination ADRs as sync points, duplicate detection, inconsistency analysis, and change propagation.

Comprehension Checkpoints Before/after verification, anti-pattern detection, code churn detection, and Socratic guidance.

Impact Classification Low/Medium/High classification, decision flow, and ceremony requirements by level.

What to Read Next

• Implementation Guardrails for specific enforcement mechanisms
• Team Coordination for multi-developer workflows
• Comprehension Checkpoints for the checkpoint mechanism

Coming from a Different Angle?

For Developers Install the plugin and run your first guided workflow.

For Architects Design principles, decision records, and technical design structure.

For Platform Teams Customize with your own instructions, skills, agents, and hooks.