# AI4SE End-to-End Software Delivery Best Practices

Between 2025 and 2026, Anthropic, OpenAI, Cursor, Google (DORA), Microsoft, GitHub, and others converged on a strikingly consistent set of conclusions about AI-assisted software engineering:

1. AI is an amplifier, not a cure-all — an organization’s existing delivery capability sets the ceiling on AI’s value
2. End-to-end success depends on a closed loop — spec → context → execute → verify → measure
3. Harness and the human-machine division of labor — Planner / Generator / Evaluator is the key to long-running delivery
4. Organizational enablement and engineering practice must move together — policy, Champions, platforms, and the Inner Loop all matter equally

AI Amplifies an Organization’s Existing Capability

DORA 2025’s core thesis:

AI’s primary role in software development is that of an amplifier. It magnifies the strengths of high-performing organizations and the dysfunctions of struggling ones.

Stage	Weak organizational foundation	Strong organizational foundation
Requirements/spec	AI amplifies requirement ambiguity	AI helps clarify and produce acceptance criteria
Development	More code that’s hard to review	Small batches + code review boost throughput
Testing/release	Defects and MTTR worsen	Flow efficiency and quality improve together

See DORA 2025: AI as an Amplifier for details.

The DORA AI Capabilities Model (Seven Amplifiers)

#	Capability	E2E implication
1	Clear AI stance	Available tools, boundaries, and room for experimentation are clearly communicated
2	Healthy data ecosystems	Internal data quality, consistency, discoverability
3	AI-accessible internal data	The foundation of context engineering
4	Strong version control	Handles the change volume and PR size AI brings
5	Working in small batches	Offsets the risk of AI generating large chunks of code at once
6	User-centric focus	Keeps acceleration aligned with business value
7	Quality internal platforms	Converts individual productivity into organizational flow efficiency

AI tends to inflate PR size; small batches are the safeguard.

Plan First, Then Code

Cursor’s official guidance summarizes E2E feature delivery as:

1. Plan Mode — research the codebase, clarify requirements, produce an editable plan
2. Independently verifiable small steps — the agent can confirm completion of each step on its own
3. Roll back on plan failure — revert and revise the plan, rather than patching repeatedly in the wrong direction
4. The five-step TDD flow — write the test → confirm it fails → implement → pass → commit
5. Verifiable targets — type system, linter, tests

The biggest risk when building features quickly is skipping verification.

Structured specs and acceptance criteria form the interface across BA → DEV → QA. See SDD: The Single Source of Truth.

Context Engineering

Anthropic defines context as the highest-signal set of tokens within a finite attention budget:

Component	Principle
System prompt	Minimal but sufficient, clearly sectioned
Tools	Few and precise; avoid a bloated tool set
Rules / CLAUDE.md	Project conventions, commands
Just-in-time retrieval	Lightweight references + runtime fetching, not pre-loading the entire codebase

Three mechanisms for long-running tasks: compaction, structured note-taking (PROGRESS.md), and sub-agents (returning a summary to the main agent).

BA’s requirement packages, DEV’s context packs, and QA’s acceptance intent should all be designed to be referenceable, versionable, and incrementally loadable — corresponding to the Middle Loop Harness.

Harness and the P/G/E Triad

Role	Responsibility	E2E mapping
Planner	Turns a short prompt into a product spec	BA + architecture outline
Generator	Implements in small steps against the spec	DEV Inner/Middle Loop
Evaluator	Independently verifies; hard pass/fail threshold	QA + automation

The key insight:

Separating the agent doing the work from the agent judging it.

The Evaluator should use runtime tests (Playwright, pytest), not just LLM self-assessment. A sprint contract aligns on “what counts as done” before coding begins. See Planner-Generator-Evaluator and the HITL/HOTL/HOOL Spectrum.

A Multi-Layer Verification Stack

Layer	Mechanism
L1 Local	Unit tests, type checking, linters
L2 Task	Sprint contract / acceptance criteria
L3 Runtime	Playwright, integration tests
L4 Process	PR agent review
L5 Organizational	Contextual evals, golden sets
L6 Continuous	CI/CD gates, SAST

OpenAI’s Evals framework has three phases: Specify → Measure → Improve. Don’t hope for “great” — specify it, measure it, improve toward it.

An End-to-End Reference Architecture

ORGANIZATION LAYER
  AI stance · Enablement · DORA 7 caps
        |
        v
MIDDLE LOOP -- Spec & Harness
  Planner/spec · Context packs · Review · Permissions
        |
        v
   BA/PM    DEV (Gen+CR)    QA (Eval)
        |
        v
OUTER LOOP -- Delivery System
  Git PR · CI/CD · Platform · Metrics · Feedback -> Eval

Favor the Simplest Solution

From Anthropic’s Building Effective Agents:

Find the simplest solution possible, and only increase complexity when needed.

Complexity	Pattern	Best fit
Low	Augmented LLM (retrieval + tools)	Single-step classification, generation
Medium	Workflow (chaining, routing, parallel)	Decomposable, fixed subtasks
High	Agent (dynamic tool loop)	Open-ended, unpredictable number of steps

Favor workflows plus human review first; escalate to agent autonomy only with evaluation evidence supporting it.

Organizational Adoption Is Change Management

From the GitHub AI Playbook:

Companies fail at AI adoption because they treat it like installing software when it’s actually rewiring how people work.

Eight pillars of enablement: executive support, policies, AI advocates, communities, learning & development, DRI, right-fit tooling, and metrics. A license is not the same as realized value at scale.

Key Cautions

Topic	Point of view
Agent complexity	As models get stronger, some scaffolding may become obsolete
PR size	AI can inflate PR size, conflicting with small batches and code review
Individual vs. organizational effectiveness	individual effectiveness up ≠ organizational performance up
Number of tools	more tools ≠ better

References

• DORA 2025 Report
• Anthropic: Harness design for long-running apps
• Anthropic: Building effective agents
• Cursor Agent Best Practices