Verification Before Completion

What Is This?

Overview

Verification Before Completion provides systematic approaches for validating work completeness before declaring tasks done. It covers requirement checklist verification, comprehensive test execution including edge cases, integration testing with dependent systems, performance validation under load, acceptance criteria confirmation, and documentation completeness checking.

The skill emphasizes not assuming work is complete, testing happy paths and error scenarios, verifying with actual users when possible, checking non-functional requirements like performance and security, and maintaining verification checklists for consistency.

This prevents premature completion, reduces rework from missed requirements, catches issues before production, and ensures deliverables truly meet expectations.

Who Should Use This

Developers completing features or fixes. QA engineers validating implementations. Product teams accepting deliverables. Technical leads reviewing completion. Anyone wanting to reduce rework and issues.

Why Use It?

Problems It Solves

Premature completion declarations lead to rework when issues are discovered later. Systematic verification catches problems before marking done.

Missing requirements cause failed acceptance. Requirement checklist validation ensures completeness.

Untested edge cases cause production bugs. Comprehensive testing including edge scenarios prevents issues.

Integration problems surface after individual component completion. Integration testing before completion avoids late discoveries.

Core Highlights

Requirement checklist verification. Comprehensive test execution. Edge case and error scenario testing. Integration testing with dependencies. Performance and security validation. Acceptance criteria confirmation. Documentation completeness checking. User validation when applicable.

How to Use It?

Basic Usage

Create a verification checklist, execute tests comprehensively, validate against requirements, and confirm acceptance criteria before marking complete.

Review acceptance criteria checklist
Execute all test scenarios including edge cases
Verify integration with dependent systems
Validate performance meets requirements
Confirm with stakeholders if needed
Document verification results
Mark complete only after all checks pass

Specific Scenarios

For feature completion:

Verify all acceptance criteria met
Test happy path and error scenarios
Check integration with existing features
Validate performance under expected load
Confirm UI matches designs
Get stakeholder approval if required

For bug fixes:

Verify fix resolves reported issue
Test that fix doesn't introduce regressions
Check related functionality still works
Validate fix under original conditions
Confirm with bug reporter if possible

For refactoring:

Verify all tests still pass
Check behavior preservation
Validate performance not degraded
Confirm API contracts maintained
Test integration points unchanged
Review code quality improvements

Real-World Examples

A developer implements a checkout feature and considers it complete after basic testing. Before marking done, they verify against acceptance criteria, discovering payment failure handling is missing. They implement error scenarios, test with invalid cards, verify error messages match designs, and validate recovery flows. Integration testing reveals timeout handling needs improvement. After addressing all items, the feature truly meets requirements.

An engineer fixes a race condition bug. Rather than assuming the fix works after one test, they reproduce the original bug, confirm the fix prevents it, test with higher concurrency than production, validate related concurrent operations are unaffected, and have the bug reporter validate in the testing environment. Comprehensive verification prevents premature completion and missed edge cases.

A team completes API refactoring. Before declaring done, they verify all existing tests pass, check API contracts are unchanged, validate performance benchmarks match baseline, test integration with dependent services, confirm documentation is updated, and get approval from consuming teams. Systematic verification prevents breaking changes and ensures smooth deployment.

Advanced Tips

Create verification checklists for common task types. Test edge cases and error scenarios, not just happy paths. Verify integration with actual dependent systems rather than mocks. Validate performance under realistic load. Get stakeholder confirmation for user-facing changes. Document verification results for an audit trail. Do not mark complete until all checks pass. Review past issues to improve checklists over time.

When to Use It?

Use Cases

Feature development completion. Bug fix validation. Refactoring verification. API changes validation. Performance optimization confirmation. Security fix verification. Documentation completeness checking. Any work requiring quality assurance before completion.

Related Topics

Quality assurance practices. Test-driven development. Acceptance criteria definition. Integration testing strategies. Performance testing approaches. Definition of done. Checklist methodology. Verification and validation techniques.

Important Notes

Requirements

Clear acceptance criteria and requirements. Comprehensive test suite. Access to testing environments. Integration system availability. Performance testing capabilities. Stakeholder availability for validation. Documentation standards.

Usage Recommendations

Define acceptance criteria before starting work. Create verification checklists for task types. Test comprehensively, not just happy paths. Verify integrations with actual dependencies. Validate performance under load. Get stakeholder confirmation when needed. Document verification results. Do not skip verification under time pressure. Review and improve checklists regularly.

Limitations

Comprehensive verification takes time. Some issues may still escape despite thorough checking. Stakeholder availability for validation varies. Testing environment limitations may constrain coverage. Production environment differences can introduce unexpected behavior. Balance thoroughness with efficiency.