GitHub’s November 6, 2026 guide, Beyond code generation: A developer’s guide to agentic engineering, describes an AI-assisted software workflow across four stages: Plan, Build, Verify, and Observe. For QA engineers, the important point is not that an agent can produce more code. It is that the verification work must remain clear, reviewable, and independently evidenced as AI-assisted work moves faster.
What GitHub is recommending
GitHub’s guide recommends explicit requirements and acceptance criteria before implementation, isolated work for separate tasks, and a Verify stage built around smaller pull requests, automated quality checks, Copilot code review, security scanning, dependency policy checks, and passing verification before merge. Its Observe stage then connects production behavior back to issues, regression tests, and future guidance.
These are workflow recommendations, not a guarantee that an AI-generated change is correct. Teams should still decide which checks are authoritative, who approves a release, and what evidence is retained.
Why this matters for QA engineers
AI agents can turn a small request into a broad diff, generated tests, and a convincing explanation in a short time. That makes scope control and independent validation more valuable, not less. A practical agentic engineering QA checklist separates three questions: did the requested behavior change, did the original regression disappear, and did unrelated behavior remain safe? Each needs evidence beyond the agent’s own narrative or tests.
A QA checklist for the Verify stage
- Start with a testable contract. Pin the acceptance criteria, affected services, known edge cases, and expected non-changes before an agent begins work.
- Keep the change reviewable. Prefer a focused pull request. If an agent changes unrelated files, generated artifacts, or dependencies, split or justify those changes before functional review.
- Preserve a baseline. Capture the failing test, bug reproduction, or current behavior at a known commit. Do not allow a proposed fix to weaken or replace the only meaningful assertion.
- Use independent test evidence. Run targeted regression checks plus the relevant suite from a clean checkout or controlled CI environment. Treat agent-generated tests as inputs to review, not the sole oracle.
- Review behavior and risk separately. Check the diff for error paths, permissions, configuration, observability, data handling, and dependency changes—not only whether the happy-path test passes.
- Record the merge gate. Save the commit SHA, CI run, required-review outcome, security or policy findings, and any accepted exceptions alongside the pull request.
- Close the loop after release. Define a production signal, rollout boundary, and rollback path. If telemetry or support evidence contradicts the pre-merge result, create a regression case before changing instructions or agent memory.
A small evidence pack
Request and acceptance criteria
Baseline commit + reproduction result
Candidate commit + focused diff review
Targeted regression result
Clean CI run URL + result
Security/policy checks + exceptions
Release signal + rollback ownerThis evidence pack is intentionally compact. Its purpose is to make a result reproducible by someone who was not present for the agent session, without storing prompts, credentials, or sensitive data unnecessarily.
Keep automation helpful, not self-validating
GitHub’s guide points to automated quality checks, code review, security scanning, and follow-up work as ways to focus human attention. QA teams can turn that into a durable control: ensure the assistant that proposes a change is not the only system that validates it. Independent CI, a human review of high-risk changes, and production observation cover different failure modes.
Bottom line
GitHub’s agentic-engineering guidance is a timely reminder that speed in implementation shifts the quality bottleneck toward verification. Start with one bounded workflow, keep the diff small, preserve a baseline, and require independent evidence before and after release. That is how an AI agent becomes part of a dependable QA process rather than a source of faster uncertainty.