Domain 1 of 6 · Chapter 1 of 3

Integrate agents into the software development lifecycle

Unlock the complete study guide.

Bundled into the existing Developing in Agentic AI Systems premium course — no separate purchase.

14-day money-back guarantee — no questions asked.

Included in this chapter:

  • What this objective covers, and where its neighbours begin
  • The contract: the mental model this page uses
  • Triage before delegation: which work an agent should be given
  • Local or cloud: placing work you have decided to delegate
  • Working interactively: test-driven development and bulk migrations
  • Custom agents for a recurring specialist role
  • The assigned issue is a prompt: problem, criteria, scope, and evidence
  • Preparing the repository so the agent can build, test, and validate
  • Iterating on the agent's pull request
  • When and how reviewers see the agent's approach
  • Giving each agent workflow job the context it needs
  • Reading an exam scenario: cues, boundaries, and the tempting wrong answer

Who owns each candidate task by default, and the property that decides it

Candidate taskDefault ownerThe deciding propertyWhat would move it
Fix a failing accessibility check on a settings pageCopilot cloud agentBounded, verifiable, and little can break if it goes wrong (a low blast radius): the class GitHub names for early delegationThe fix reaching into authentication or production-critical code, or no longer being small and easy to verify
Align a shared domain model across four repositoriesDeveloper-ledBroad change needing design consistency and context that spans repositoriesSplitting it into per-repository issues after the interfaces are agreed
Change how session tokens are validated in auth middlewareDeveloper-ledAuthentication repercussions and production criticality, independent of difficultyNothing about agent capability; the impact decides, not the size of the diff
"Make onboarding better"Neither, yetOpen-ended requirement with no agreed outcome and no acceptance criteriaTurning it into a defined change with complete acceptance criteria first
Refresh three README sections while you debug a race condition locallyCopilot cloud agentDelegation is settled by the properties above; placement is the later decision, and it sends this one to the cloud with /delegate because the task is tangential to the local session and touches separate filesThe task needing the same files the local session is editing
Fix the backoff bug in the retry layer you are trying to understandDeveloper-ledHands-on understanding is the point of the taskThe learning goal no longer applying to this change

Decision tree

no yes no yes no yes Is it production-critical or incident response, or does it touch security, authentication, or personally identifiable information? Are the requirements still open-ended or the outcome still undecided? Does it need deep cross-repository or design context, or do you want to learn it hands-on? Keep it developer-led (a strong default, not a ban) Define the change and its acceptance criteria first Keep it developer-led; the context or learning goal decides Delegate it: bounded issue, complete acceptance criteria, outputs to hand back
Cheat sheet

Cheat sheet

  • Start agent delegation with clear, bounded development changes.
  • Broad changes requiring deep domain context are candidates for developer-led work.
  • Sensitivity and production criticality affect whether work should be delegated.
  • Resolve open-ended requirements before treating an issue as an implementation task.
  • A developer's learning goal can justify retaining implementation work.
  • Use CLI delegation for independent cloud work while local development continues.
  • An assigned issue should specify the problem, acceptance criteria, and change scope.
  • Semantic code search can discover relevant files when exact paths are unknown.
  • Provide visual references when the expected agent output is a user-interface design.
  • Use a custom agent when a recurring workflow needs specialized behavior and tools.
  • In agent-assisted test-driven development, review the failing tests before requesting implementation.
  • Record repository-wide build and validation commands in .github/copilot-instructions.md.
  • Use path-specific instructions for validation requirements that apply only to selected files.
  • Keep agent instructions concise, actionable, and nonconflicting.
  • Preinstall known dependencies instead of relying on agent trial-and-error setup.
  • Agent-side validation requires an operational development environment, not just generated source code.
  • Convert bulk migration findings into a checked-off work list.
  • Submit a batched review when several comments must guide the same agent iteration.
  • Only a user with repository write access can drive an agent revision through @copilot.
  • Human developers can contribute fixes directly to an agent's feature branch.
  • Merge-conflict resolution can be requested as follow-up work on an agent pull request.
  • Repository research and branch iteration can precede pull-request creation.
  • Specify the reviewable outputs before delegating implementation.
  • Task success requires the intended outcome and authorized scope as well as passing checks.
  • Choose a plan-first pull request when approval must precede implementation.
  • Use a pull-request template to standardize the plan and evidence reviewers see.
  • Pass small workflow values through step and job outputs rather than logs or environment variables.
  • Condition pull-request-dependent agent jobs on the triggering event in multi-trigger workflows.
  • Route follow-up changes to the existing agent pull request with an @copilot comment

Unlock with Premium — includes all practice exams and the complete study guide.

References

  1. Assigning and completing issues with coding agent in GitHub Copilot Blog