Collaboration loop
Put an accountable human decision around every generated change
Keep slices small enough that intent, implementation and evidence can be compared before the next layer is generated.
Frame
Name the user, decision, boundaries and non-goals.
- Human owns
- Product intent and consequence
- Agent helps
- Clarifying gaps and drafting a plan
- Output
- Reviewable task contract
Generate
Produce the smallest coherent change and explain assumptions.
- Human owns
- Scope and permitted systems
- Agent helps
- Code, tests and documentation
- Output
- Focused diff with assumptions
Challenge
Review behavior, boundaries and failure paths independently.
- Human owns
- Risk and acceptance
- Agent helps
- Adversarial cases and traceability
- Output
- Findings and resolved questions
Verify
Run automated and observed checks proportional to consequence.
- Human owns
- Evidence sufficiency
- Agent helps
- Repeatable commands and test fixtures
- Output
- Pass, fail and known gaps
Release and learn
Deploy with observation, rollback and follow-up ownership.
- Human owns
- Release decision and monitoring
- Agent helps
- Runbook and change summary
- Output
- Traceable release record
Operating principle
Prefer small verified slices over large generated leaps
Large changes are difficult to review because hidden assumptions interact across product, data, security and operations. Generation speed can make that review debt accumulate faster than the team can understand it.
Implement one end-to-end journey with its denied, empty, loading and failed states. Verify it, document the learned constraints and only then expand the pattern.
- One task has one outcome
- Record assumptions explicitly
- Require evidence before release
- Keep rollback proportional to risk
Applied example
Workflow example: 40-file feature in one prompt
An agent adds billing, roles, email and analytics in a single change. The application compiles, but reviewers cannot determine which system owns subscription state or tenant access.
- Several trust boundaries changed together
- Review cannot isolate consequences
- Generated tests mirror the happy implementation
- Rollback would remove unrelated capability
Plain answers
Questions to resolve before shipping
Should every generated line be reviewed manually?+
Review depth should follow consequence and evidence. Critical boundaries need direct understanding; generated boilerplate still needs tests and ownership.
Can an AI agent approve its own work?+
It can run checks and critique a change, but accountable release acceptance should remain with authorized humans and policy.
How small should a task be?+
Small enough that one reviewer can explain the user outcome, changed boundaries, evidence and rollback without reconstructing the whole system.