Engineering manager

AI adoption by role

The engineering manager leads a delivery team: engineering managers, delivery managers and team leads. AI (artificial intelligence) changes how fast the team produces code, tests and documents. It does not change who reviews them, who approves them, or who looks after the people doing the work. Counts, shares and durations on this page are illustrative.

Every task an agent takes on becomes a review task for a person. The engineering manager's first AI decision is how much review the team can do well, and the second is how to keep that time protected.

1. At a glance

Field	For the engineering manager
Mandate	Move the team up the ladder at the pace its readiness, reviewer capacity and controls allow; keep people safe to learn and to report problems
Primary decision	Which tasks the team delegates to AI, with which evaluation threshold, and how much protected review time backs them
First safe win	A team instructions file reviewed like code, plus one low-risk Stage 1 task with net time saved measured including review
Biggest failure mode	Delegating more work than reviewers can read, then approving AI output unread to keep the sprint on track

Line: 1st line · Family: Lead · Variants: engineering manager, delivery manager, team lead

Variant	What differs
Engineering manager	People leader: performance, learning time, role design, hiring needs; owns the team's adoption plan
Delivery manager	Owns delivery flow and commitments for one or more teams; shares reviewer-capacity planning with the delivery lead
Team lead	Hands-on technical lead: owns the instructions file, review standards and the team's first delegated tasks

Program and train-level facilitation is covered on the delivery lead track. This page is the people-leader and team-controls lane.

2. Your journey: first steps to fully adopted

The engineering manager's journey starts with a ready team and ends with delegated work that reviewers can actually read.

Start here: your first steps

Confirm acceptable-use attestation for every person on the team.
Start Stage 1 on one low-risk task and measure net time saved, including review.
Review the team instructions file like code, with the team lead as owner.
Book protected review time before the team delegates its first task.

Fully adopted: how the work runs

Moment in the work	Before AI	Fully adopted (Stage 4–5)	Decision that stays human
Planning a sprint	Estimates ignore review; AI speed-up is counted silently	Each delegated item lists its evaluation set, threshold and named reviewer; the review budget comes from measured data	Which tasks the team delegates
Building the change	Developers write every line; custom code repeats what shared libraries already do	The coding agent opens pull requests from a sandbox; the reuse advisory points to `shared-datetime`; the agent has no merge right	Which work stays human-written, such as the `formatPaymentCutoff` extension
Review and merge	One reviewer under sprint pressure, sometimes reading in a hurry	A reviewer who did not delegate the task approves; review load is tracked against the budget	Approving every pull request
Release and operation	Customers find the edge cases	Evaluation re-runs per risk slice; traces are kept; the kill switch is drilled	Pausing delegated work or stepping it down
People and growth	Performance read from output volume	Performance judged on outcomes, quality and learning; junior engineers keep hands-on tasks	Every performance judgment

What changes for the organization

Before	After
Review happens when there is time left	Review is booked, measured and protected
Speed-up claims with no review cost	Net time saved, including review and rework
Near misses hidden to protect ratings	Near misses reported and thanked in public

In any organization

Small or unregulated: a team lead or the head of engineering holds this seat, and borrows a reviewer from another team when the team is too small.
What scales: formal capacity plans and stage-move paperwork shrink. The rule that the person who delegates never approves, human approval of merges, no customer data in unapproved tools and a kill switch for agent workflows never do.

3. Your decisions

The column "your relationship" uses the decision relationship vocabulary: owner or approver · independent validator or challenger · consulted control partner · evidence recipient · notified.

Decision	Your relationship	Inputs	Escalation	Cannot be delegated
Which tasks the team delegates	Owner, within the tier and stage the use case was granted	Intake card, evaluation results, reviewer capacity	The use-case owner; the enablement lead	Yes
Reviewer capacity per sprint	Owner	Delegated task volume, review time per artifact, override rate	The delivery lead; the sponsor if funding is short	Yes
Team instructions and review standards	Owner; the team lead maintains	Lab 1 template, team incidents, reuse findings	Architecture for shared patterns	No; the team lead can own the file
Propose a stage move	Owner of the proposal; never the certifier	Exit evidence with denominators	The enablement lead checks controls; the second line for medium and high tiers	Yes
Pause delegated work	Owner	Reviewer load, near miss, failed evaluation	The use-case owner	Yes
Performance expectations	Owner, with HR (human resources)	Outcomes, quality, learning goals	Your own manager and HR	Yes
Approve a pull request	Not yours by role; a reviewer who did not delegate the task approves	Pull request, tests, reuse decision record	Branch protection	Never self-approve
Approve release	Notified; the existing change authority approves	Change record	Change authority	Not yours to hold

4. Two kinds of adoption

Kind	What it means for you	Example
How you work with AI	Drafting plans, summarizing retrospectives, preparing one-to-one notes from your own words; never feeding personnel data to a tool	The assistant drafts a sprint review from merged PR (pull request) titles; you correct it
What your team delivers with AI	Coding agents, generated tests, drafted stories and release notes, each landing as a reviewable artifact	The coding agent replaces a custom formatter with `shared-datetime`; a second developer approves

5. Your ladder

The team climbs the adoption ladder per role and per use case. Developers at Stage 3 while the product owner stays at Stage 1 is normal. Maturity describes the team's controls and evidence, not your permission to stop reviewing.

Stage	AI use in your team	Guardrail you make sure exists	Artifact or evidence	Decision relationship	Step-down trigger
0 · Foundations	None	Acceptable use attested and scenario-checked; approved tool; access; escalation path known	Team roster with attestation dates	Owner of readiness; the enablement lead checks	Anyone on the team uses an unapproved tool
1 · Personal productivity	Explain, draft, summarize; people apply every change	No restricted data; near-miss reporting on	Net time saved sample, including review	Owner of the measurement	An unreported breach
2 · Team context	Instructions file, reusable prompts, reuse advisory	Secrets block, protected paths, reuse advisory, file reviewed like code	Reviewed instructions file; reuse decision records	Owner of the file through the team lead	Secret or policy findings trend up
3 · Delegated tasks	Agents open PRs, generate tests, draft stories	Evaluation set with thresholds, traces, required reviewers, protected review time	Evaluation results per risk slice; override rate	Owner of task delegation; evidence recipient of evaluation	A failed slice, or reviewer load over the agreed limit
4 · Agentic workflows	Multi-step workflows in a sandbox	No merge or deploy right; spend limit; kill switch; independent approval	Workflow traces; kill-switch drill record	Owner of team operation; security and the change authority approve their parts	Kill switch used; a near miss on tool access
5 · Scale and sustain	The team contributes assets to the catalog	Owner and review date on each asset	Catalog entries owned by the team	Owner of the team's assets	An asset loses its owner

Human-operated at Stage 5. Code review approval, performance judgments and the decision to pause stay human. No agent approves a PR, and no agent output is evidence about a person's performance.

6. Priority scenarios

Scenario	Value	Risk tier	Stage	First step	Do not use AI when…
Sprint review draft	Less admin time	Low	1	Draft from PR titles and tickets only	The draft would go out unread
Onboarding guide from the instructions file	Faster ramp for new joiners	Low	2	Generate from the reviewed file, then edit	The file is out of date
Delegated test generation	Coverage on date and time edge cases	Medium	3	Agree the evaluation set and reviewer time first; see Lab 4	Nobody has time to review the suite this sprint
Coding agent for replacements	Move custom code onto shared libraries	Medium	3	One repository, one pattern, required reviewers	The change touches a protected path
Retrospective themes	Patterns across sprints	Low	1	Use team notes without names	The notes contain personnel matters
Performance notes	None worth the risk	Not a fit	Any	Write them yourself	Always: AI never drafts judgments about a named person

7. The due-date ask from your seat

The organization must show the contractual payment due date the same way on web, mobile, statements and reminder notifications, and the payment cutoff time in the customer's own time zone. The due date is a date-only value; the cutoff is an instant shown in the customer's zone. The engineering manager's material work is sequencing and capacity.

Step	What the engineering manager does	Artifact
Read the impact	Confirms with the architect: four display services change, `shared-datetime` gets an additive display function, `formatPaymentCutoff(cutoffInstant, customerZone)`; payment-schedule-service stays read-only and alone computes the cutoff	Impact analysis, confirmed
Choose the delegation	Delegates test generation for the temporal edge cases (Stage 3) and keeps the `formatPaymentCutoff` extension human-written, because it is a shared contract	Delegation note in the team plan
Book review time	Books two reviewers for the generated suites and one architecture review for the extension, inside the sprint	Capacity plan
Hold the gate	Makes sure the developer who prompted the agent does not approve the PR	Branch protection settings; reviewer list
Read the result	Reviews override rate and net time saved after two releases	Team scorecard entry
Step down if needed	If the daylight-saving slice fails, generated tests go back to assist-only	Step-down record

8. Hand-offs and separation of duties

You give → to whom	You receive ← from whom	You challenge	You are notified of
Stage move proposal → the enablement lead	Evaluation results ← QA (quality assurance) engineers	Evaluation sets with no negative cases	Release approvals for your team's changes
Capacity plan → the delivery lead	Impact analysis ← the architect and business analyst	Estimates that ignore review time	Near misses and incidents in your services
Reviewer assignments → the team	Funding and priorities ← the executive sponsor	Requests to approve unread to meet a date	Exceptions affecting your team
Team scorecard → the enablement lead	Security findings ← the security team	Delegation beyond the granted tier	Provider or model changes

Separation of duties. The person who delegates a task to an agent is the requester. A different person approves the output. When the team is small, the manager arranges a reviewer from another team rather than waiving the rule.

9. Evidence and records

Evidence	Produced or consumed	System of record	Retention owner
Team instructions file	Produced	Source repository, under review	The team lead
Reuse decision records	Consumed in review	Repository, next to the change	The team, per records schedule
Evaluation results per task	Consumed	Evaluation tooling	QA, with the use-case owner
Reviewer capacity plan	Produced	Team planning tool	The engineering manager
Step-down and pause records	Produced	AI inventory entry	The enablement lead
Acceptable-use attestations	Consumed	Learning system	HR and L&D (learning and development)

10. Skills and learning path

Level	What the engineering manager learns	Labs	Done when
Foundation	Acceptable use; data classification; why AI output must be reviewed as your own	Observe Lab 1 with the team	You can explain to the team what is prohibited and why
Practitioner	Reading evaluation results and override rates; planning review time	Lab 4 test generation; Lab 5 delegated task behind an approval gate	You set a threshold and a review budget for one delegated task
Advanced	Coaching people through role change; running a step-down without blame	Tabletop: the evaluation set fails the week before release	You run the step-down, record it, and the team reports the next near miss

11. Measures and incentives

The team is judged on outcomes and quality, not on how much AI output it produces. The measure chapter defines each metric.

Metric	Definition	Anti-gaming note
Net time saved	Time saved minus review and rework time, per change	Gross time saved is not reported
Override or rejection rate	Generated artifacts rejected or heavily edited, divided by all generated	A low rate can mean unread approvals; check review time with it
Review load	Review hours per sprint against the protected budget	Over budget means pause, not overtime
Rework rate	Changes reopened within two releases	Read with cycle time
Near misses reported	Count per quarter	Never a target to reduce
Learning time used	Protected hours used against hours planned	Unused hours are a manager problem, not a person problem

No AI output quota. Never set targets for prompts sent, lines generated or PRs opened by agents. People will hit the number and the quality will fall.

12. Cost, capacity and workforce

Reviewer capacity is the team's protected time for checking AI output. A starting budget is about 20% of team capacity (illustrative) once delegated tasks begin; the measured review load then replaces the estimate.

Capacity item	How to plan it	Illustrative figure
Review time per generated suite	Measure the first five, then use the median	1.5 hours
Evaluation set upkeep	A backlog item every quarter, not spare time	2 days per quarter
Learning time	Protected and scheduled	4 hours per person per month
Champion time	One champion per team	10% of their week
Licence and usage cost	Per seat plus usage, from the platform cost report	Read monthly

Workforce topic	What the engineering manager does
Job fear	Says plainly how roles will change and how saved time will be used; does not promise what the organization has not decided
Role redesign	Moves people toward review, evaluation, domain rules and asset ownership; records the change with HR
Performance expectations	Judges outcomes, quality and learning; never AI usage volume
Psychological safety	Thanks people for near-miss reports in public; never links a report to a performance rating
Uneven pace	Accepts that some people stay at Stage 1 longer; pairs them with a champion instead of ranking them
Junior engineers	Keeps tasks where they write code themselves, so they build the judgment that review needs

13. Anti-patterns and stop conditions

Anti-pattern	Why it fails	Instead
Approval unread	The control exists only on paper	Pause delegated work when review is over budget
Self-certified stage moves	The team that benefits certifies itself	The enablement lead and the second line check controls
Speed-only reporting	Hides rework and override burden	Report net time saved and rework together
Usage leaderboards	People optimise the count and hide problems	Show outcomes and recorded lessons
Agent as approver	Breaks separation of duties	Branch protection requires a human who did not delegate

Stop condition	What happens
Review load over budget for two sprints	Delegated tasks pause; nothing is approved unread
Failed evaluation slice	The task steps down to assist-only
Near miss on data or tool access	The task pauses while the cause is found
Model or provider change	Evaluation re-runs before Stage 3 use resumes
Key reviewer leaves	Capacity is re-planned before new delegation

14. Action kit and 30/60/90

Delegation checklist. Run it before the team delegates a new task.

Check	Yes or no
The task is in the inventory with a tier, and the tier allows this stage
An evaluation set with negative cases and a threshold per risk slice exists
Review time is booked in this sprint, by name
The person who delegates is not the approver
Traces are kept and the kill switch, if needed, is tested
The team knows the step-down triggers and who decides

Questions to ask your enablement lead

What review load per artifact are other teams measuring for this kind of task?
Which catalog assets and evaluation sets can we reuse instead of building our own?
How do we report a near miss without it landing on someone's performance record?

Days 1 to 30	Days 31 to 60	Days 61 to 90
Goal	Ready the team	Shared context	First delegated task
Actions	Attestations done; talk openly about role change; start Stage 1 on one task	Team instructions file reviewed like code (Lab 1); reuse advisory on; measure net time saved	One Stage 3 task with an evaluation set and booked review time; propose the stage move with evidence
Evidence	Attestation list; first time sample	Reviewed file; reuse decision records	Evaluation results; override rate; capacity plan
Watch for	Silence about job fear	A file nobody reviews	Delegating faster than review capacity grows

Related tracks: delivery lead · developer · QA engineer · enablement lead · executive sponsor.