What engineers and their managers can try, from reviewing AI-written code to the instruction files agents read, taken from what the teams in these articles did. Jev, an AI model from TypeSafe, checks that each one makes sense without its article. How the check works

A person other than the one who built a piece of AI-assisted work checks it and approves it before it reaches customers, often called keeping a human in the loop.
When prompting an AI coding agent for a change, tell it which requirements the change can ignore, for example that cached data may be briefly out of date, so it does not add unneeded locks and checks.
Assign the review of each agent-built code change to the tech lead or engineering manager of the team that owns that code, not to whoever is free.
Write down which actions an AI agent may take alone, such as opening a pull request, and which wait for a person, such as merging or deploying to production.







Require screenshots or short recordings of the state before and after a change in every pull request an AI agent opens.
When an AI assistant maps or writes code for a system with no documentation, have an engineer review everything it produces, and keep telling it what the task is and why it matters.
Write a specification of the problem and the required behaviour before asking a coding agent to build an internal tool.
Sort AI-written pull requests by risk: let test and documentation changes merge once automated checks pass, and send authentication, billing and public API changes to an engineer qualified to review them.
Let AI agents build and deploy changes to test environments, but require a person's approval before any change merges to the main branch or reaches production.
Keep a list of every AI agent in use, with who uses it and what it may change, and give each agent only the permissions it needs.
When a pull request was approved without every part being read, say in its description which parts nobody read, so that later reviewers and incident reviews know what was checked.
Tag every pull request by type, such as feature, bugfix or maintenance, and track the mix instead of the total count.
Let an AI agent investigate production problems with read-only access, then require approval of its full plan before it gets write access.
Require an approver other than the engineer who asked for it on every pull request an AI agent opens, and enforce the rule in branch protection.
Limit the coding agent to safe, well-scoped customer changes and have it open a pull request with a short spec and screenshots for an engineer to review.
Before reading an agent-written change line by line, rank its files by risk and spend close review on the riskiest ones.
Keep changes to migrations, sign-in, permissions, billing and deployment settings under human review whatever score an AI reviewer gives them.
Treat the review of every new dependency as part of code review, including for pull requests written by AI.
After a production incident, stop pull requests of the same kind from merging on automated checks alone until the team fixes the check that missed the problem.
Write down who may open a pull request, who reviews it and what a change from outside engineering must prove, before adding more AI tools.
Turn each bug that caused an incident into an automated check, and require an escalation with a written reason to bypass any check.
Before an AI agent's code change goes live, have an engineer check the agent's plan for watching it in use, and agree in advance what happens if a problem appears.
Have a person approve the AI agent's implementation plan before any code is written, and post the approved plan on the issue for the next person or agent.
Test changes to an AI agent's investigation instructions by replaying past production incidents, with the answer hidden from the agent.
After three rounds of AI review and fixes on one pull request, have the AI reviewer stop and ask the engineer who wrote it to rethink the approach.
When reviews are slower than usual, have the AI agent request reviews for the engineer's waiting pull requests, with the engineer's approval, before starting new work.
Send every change that an AI agent makes through the same validation and saving code that people's changes use, so that the product's rules are kept in one place.
Label every code change an AI agent writes, then compare how often those changes contain security flaws, and how often reviewers catch problems before merge, with changes people wrote.
Mark which parts of the codebase AI agents may change with light review and which need a named person to read every change, and make the repository require that person's approval.
Tag every ticket that fixes AI-assisted code with an AI rework label in the issue tracker, so the hours spent on that rework show in sprint reports.
Review a release that bundles several pull requests, together with its plan, instead of reading each pull request alone.
Post a cost report to the ticket after an AI agent finishes each task, so the team can see where the spending goes.
Let named engineers release code to production without review, and put their releases back under review after a set number of outages traced to their changes.
Have the AI agent score each pull request for how well it was tested, what it touches and how hard it is to undo, so the reviewer knows where to look first.
Before an AI agent starts a new task, compare how long the team's pull requests now wait for a first review with the usual wait.
When an AI agent writes a bug fix, have a different AI model review it, and have engineers check and sign off on those reviews across many incidents.
Send engineers only the highest-ranked bug reports from AI-written tests, after AI models and fixed rules remove false alarms, and ask whether each change in behaviour was intended.
Sort each pull request from an AI agent by risk, have an engineer review the risky ones and give routine ones a lighter check.



Assign routine clean-up tasks to an internal AI agent through a chat message and let it gather its own context from earlier team conversations.
Keep a fixed list of changes that always need a person's approval, including changes to the approval rules, and check it with a script the AI agent cannot edit.
When a production failure exposes a rule the code does not show, write it in the instruction file that engineers and AI coding agents read before changing code.
Require review by a named human code owner of the service on every production change, and let automated checks confirm the code is built correctly.
Have a second AI agent session try to disprove an AI agent's diagnosis before any fix is written.
After each bug in code written by AI agents, name the class of error, add an automated check that detects it, then change the code so that error cannot be written again.
Rank each part of the code base by the harm a mistake there would cause, and require a human merge for agent changes only in the riskiest parts.
Have a subject-matter expert check any table mapping that an AI assistant produces before it is used in a migration.
When reviewing an AI-generated change, look first for added locks, extra checks and layers that no requirement calls for.
Write down approval tiers by risk, set from what a change touches rather than who wrote it, and require two people only for the riskiest paths.
Turn the code review rules that nobody on the team disputes into lint rules, tests and automated checks that run before a person reviews.
Have a separate AI review pass check each larger AI-written change before a human reviewer sees it.
Have code, not the AI model, verify each required approval for a production change, and let the AI model only explain the result.
Have a coding agent attach a note to each change listing what was asked, what changed, what has no test and what was left out, for the reviewer to check.
Have an AI agent that reviews production code changes pass a review to a person whenever it cannot find a required approval in the approval records.
Report AI agent spending by team per piece of finished, reviewed work, so the cost of reviewing agent output counts, not only the AI model's bill.
Move simple checks such as linting onto the engineer's machine, so that AI agents run them before opening a pull request.
Let an AI review tool approve a pull request without a human reviewer only when it is under 1,000 lines, has no serious findings and its author has ten merged changes in that service.
Require a review on the default branch so that no unreviewed change, from a person or an AI agent, can be merged.
Let engineers merge routine changes without a second reviewer when they accept responsibility for fixing them, and keep reviews for the core of the product.
When turning code review comments into automated checks, hold back any rule reviewers disagree on until the team agrees it and names who decides.
For each step where a person approves an AI agent's action, log the median time to approve and the approval rate. Redesign any step with a median under two seconds or an approval rate above 95 percent.
Each night, have AI models write tests for the previous day's riskiest code changes, chosen by a risk score, so that a test fails if a change introduced a bug.
Give every change an AI agent makes its own live preview link that people outside engineering can open.
Let the person who asked an AI agent for a code change review that change, and track how often people have to correct or redirect the agent.
Give an AI agent short-lived credentials limited to the approved plan and to the approving person's own permissions.
Make every new commit cancel earlier approvals, so each merged pull request carries an approval of its final version.
Let ordinary code fetch, group and reassign test failures, use an AI model only for unfamiliar errors, and have an engineer approve each conclusion.
When an AI agent drafts text for users, let the AI model write the wording, and let ordinary code route requests, copy record numbers and check the output format.
Stop AI agents from merging database migrations, so that a person takes responsibility for each one.
When a small pull request that an AI review tool approved alone causes an error, tighten the team's eligibility rules for such approvals instead of blaming its author.

How the jobs of product managers, designers, engineers and their managers change when AI agents do more of the building.
Pair each new engineer with an experienced engineer who coaches them on when to trust and when to question work from AI tools.
Have AI tools write the team's status updates and progress reports, and spend the engineering manager's freed time on coaching and on aligning priorities with dependent teams.
Engage a UX designer to produce the designs that will be built, even when the design document already holds AI-generated mock-ups.
When an engineer uses an AI model to propose changes outside their own area, have the domain expert for that area review the design document before work starts.
Have engineers build a separate system that checks an AI agent's work, including that no failing test was deleted, instead of accepting the agent's own report of success.
When reviewing code an AI agent wrote, question each added safeguard, such as a new lock on shared data, and ask which real requirement it serves.
Share department-wide AI usage figures with every engineer, show names only to each engineer's own manager, and never rank engineers by usage.
Write the company's rules for installing Model Context Protocol servers, the connectors that give AI agents access to data and tools, so no engineer installs one straight from the internet.
State the team's high-level technical values to the coding agent explicitly before it starts work.
Have the AI coding agent produce a short readable summary of each pull request it opens, for the engineer to read before merging.
Run a week-long trial in which AI agents write all the code, and judge it by what the team learns, not by how much code the agents produced.
Run an AI agent on the same job twice, once with its stored memory and once without, and compare speed and quality to see whether the memory helps.
Add task abandonment, conversion drops and support ticket spikes as signals in the monitoring of deployed software, so that a fall in user success triggers the same automated response as a spike in server errors.
Require the author of an AI-assisted pull request to explain the change, run the relevant tests and check security concerns before requesting a review.
Add each new way a change has broken production to the instructions of the AI agent that reviews every pull request.
Ask the AI agent to test its own change locally, by starting the servers, sending requests and trying edge cases, before a person reviews it.
Have engineers build the internal coding tools, automated pull request review and deployment automation that let designers ship their own changes.
Check regularly whether reviewers still examine AI agent output or only approve it.
Report how long pull requests wait for review and how many are reworked afterwards, next to the amount of code produced.
Require every code change written by an AI agent to pass automated reviews, including security reviews, and fixed rules that block edits to restricted code before it can merge.
Give an AI agent its own chat channel and access to logs so that it watches the health of one system component.
Have an AI agent attach the relevant code, user activity, active experiments, recent pull requests and reproduction steps to each bug report before an engineer picks it up.
Write personal and professional opinions in team communication by hand, and keep AI agents to drafting other prose and code.
Read the code an AI model writes before it ships.
Before AI agents write a feature's code, have senior engineers write the tests, interface contracts and architecture checks that the agents' code must pass in the delivery pipeline.
Cap how many topics each engineer and each squad may have open at once, and hold the cap when stakeholders or engineers push to start more AI-assisted work.
Set stricter automated checks for test coverage and code complexity on AI-written code than on hand-written code, and run them on every change before merging.
Before an AI agent reads logs, experiments or pull requests, filter them with simple rules so it examines only the likely causes.
Use the most expensive AI models for large exploratory tasks that produce a plan, and give the plan to smaller AI models to carry out.
Put the engineers who build a service on call for it, including the most senior and best-paid engineers.
Build an internal tool that lets non-engineers make apps from company data and the company's own design library.
Have AI agents write the tests as well as the code, and keep spending about as much effort on tests as on the code itself.
Credit every commit an AI agent makes to both the agent and the person who asked for the work.
Before an engineer reviews code that a designer made with AI, run automated checks that it uses the design system's values, imports the real components and meets accessibility rules.
Agree written guardrails with designers so that they can ship small layout, spacing and colour fixes to the production code themselves.
Give each engineering manager responsibility for some of the team's technical decisions, instead of leaving every technical choice to the engineers they manage.
Have an automated pipeline propose and test a fix for each flagged security vulnerability, so an engineer starts from the fix and decides whether it is safe to ship.
Add an automated check that rejects code from an AI agent when it does not use the design system's components and design tokens.
Send predictable operations requests to an AI agent first, and route them to a person when the agent's confidence score is low.
Have AI agents write end-to-end tests first and correct each one against the real system before they build the code that must pass it.
For each stage of software delivery, write down the inputs, the jobs for people and AI agents, the output and the criteria for success, and improve the stages separately.
Before building on an open standard for AI agents, check that it is stable, governed by a neutral body and open to contributions.
Set each senior engineer a coaching goal to review and answer for every AI-assisted change they ship, as fully as for code they write by hand.
When an engineer reviews a code change written by an AI agent, have them check what the change is meant to do instead of every line. Reject the change if it breaks a core rule of the system.
Compare every proposed ticket, design document or delegated task against the cost of making the change directly.
When an engineering manager reports on AI enablement, show how the team's delivery has changed since adoption, not how many engineers use the tools.
Give employees who build their own software with AI one shared platform where IT and security teams can see which applications reach which tools and data.

A person or team answers for what an AI agent does, and decides its instructions, its default settings and when it must hand a decision to a person.
Count an AI agent's incident task as finished only when a separate check shows the problem has gone, such as the alarm clearing, not when the agent's action reports success.
Enforce an AI agent's limits with fixed rules in code that decide which tools it may call, and leave every action that moves customer money to a person.
Before an AI agent goes into production, write down the one job it is for and test that it declines requests outside that job.
Limit an AI agent's database changes to adding tables and columns, and leave deletions and renames out until the data can be restored.
Keep AI agent instructions as version-controlled files so that any change can be reviewed and rolled back.
Start using AI agents in one low-risk process that the rest of development does not depend on, and name one person in that team to set the agents up.
Ask an AI agent to check metrics and logs before and after each deploy or feature-flag change, and to keep checking at set intervals for the rest of the day.
Schedule an AI agent to read overnight messages each morning, flag the questions and problems that need a reply, and look up the relevant logs before the workday starts.
Save each AI agent run's progress, conversation and files to storage outside the cloud machine it runs on, so a new machine can resume the work after a failure.
Track rework rate, code review wait time and pull request size as AI agents take on more of the coding.
Restrict the network addresses an AI agent's machine can reach to an approved list the machine enforces, instead of relying only on an AI model that screens the agent's inputs.
Keep a register with one row per AI agent that names its owner and a backup, its permissions and what people do if it is switched off.
Hold a monthly review that retires AI agents unused for 60 days and revokes credentials that no running agent needs.
Collect reviewers' feedback and records of each AI agent run, and use them to propose changes to the software that runs the agents.
After every release, run a fixed set of real questions against the AI agent and check which tool it chose as well as its answers.
Count an AI agent's task as done only when automated tests and visual checks pass, and attach the results to the pull request for the engineer who approves it.
Build a shutdown control for each production AI agent that the agent cannot change, which ends the agent, revokes its credentials and keeps its logs intact.
When AI agents repair their own failing work, cap the repair attempts and the spending, and hand the problem to an engineer once either limit is reached.
Run a nightly AI agent that reviews the previous day's agent sessions and opens pull requests to improve the agents' instructions.
Require a named person's approval before any AI agent merges a pull request or takes an irreversible action.
Before opening a pull request, have the coding agent render each new screen in the mobile emulator, and compare the screenshot with the approved design.
Before shipping an alert threshold for an AI agent's work, replay it against past data to see how often it would have fired.
Make every shared AI agent visible to all teams with its usage count, so that teams copy and extend a working agent before building their own.
Map every active AI agent workflow and assign one named person, not a team, to answer for each workflow's output before it runs again.
Name one person as the owner of each production AI agent, with a written list of actions it may never take and a named approver for changes.
Give each AI coding agent one whole feature, from interface to storage, instead of one layer such as the frontend, so that agents seldom need to brief each other.
Keep a register of each AI agent's decision rights, with an escalation route and an audit trail.
When a team hands one low-risk development step to an AI agent, measure how review and testing time change in the steps before and after it, not only the time saved on that step.
At each handoff between AI agents, record what the agent was trying to do, what data it had, how confident it was and what action it took.
When an AI agent repeats the same mistake more than twice, write the correction into the project's permanent rules for the agent.
Copy build and test run data into a database that AI agents can query, instead of having agents call the code host for every question.
Turn the team's rules on what AI agents may change without a person's approval into automated checks in the deployment pipeline that block any change breaking them.
Keep an AI agent's instructions, tool descriptions, data definitions and access rights in one repository and release them together through the usual approval gates.
Before an unattended AI coding agent pushes a fix to a pull request, have a separate script check whether the push is allowed, and in approval mode wait for a person to reply with a single-use token.
Run an AI agent in a shared Slack channel under a service account that sees only what every channel member may see, instead of the requester's own access.
Give the AI agents that staff build a shared company workspace with access rules, version history and a record of what each agent did, instead of banning them.
Have AI agents that check other agents' work answer pass, warn or fail in a fixed format, and compare several checkers' answers instead of trusting a single one.
Show each question an AI agent raises with the decision first, then the facts, then the options, so a person can answer by number.
Store with each file version the AI agent conversation that produced it, and let a person undo one conversation by restoring only the files it changed, saving a renamed copy where someone has edited a file since.
Cap how many issues a new AI agent task may create in one run while the team checks its output.
When one AI agent hands tasks to other agents, make it wait for an engineer's approval before anything colleagues will see, such as a pull request sent for review.
Keep credentials out of an AI agent's environment and let a proxy add short-lived credentials only for approved destinations.
Start each new AI agent with access to nothing, and grant each resource only when its work requires it.
Give every always-on AI agent its own identity, a named human sponsor and a stated business purpose.
Start a recurring AI agent task with a narrow scope that only suggests work, and let it assign work only after its suggestions prove reliable.
Run a second AI agent on a different AI model to read every action of an agent on live systems and stop it when it breaks agreed rules.
Let AI agents work on the build pipeline only when one of a few fixed queries flags a problem, such as a flaky check, a failing main branch or a slower workflow.

The files an AI agent reads before it works, such as AGENTS.md, CLAUDE.md, design-system rules and other written instructions, and the person or team who keeps them current.
Have an AI model draft a glossary of company terms from internal documents and chat logs, then have experts in the business correct it before AI agents use it.
Test candidate AI models on the team's own languages and frameworks before choosing a company-wide default.
Add a table to the AI agent's project instructions saying where each kind of note belongs, by how long it stays true and who keeps it current.
Define the design system's colours, type, spacing and components in one source before AI agents build screens, and point every agent's instruction file at that source.




Test AI agents on the same tasks with and without their added instruction files, because extra context can confuse an agent and make its results worse.
Write down how senior engineers investigate a problem, including their checks, trusted signals and order of steps, and turn it into instructions an AI agent follows.
Give AI coding agents a small local tool that answers narrow questions about the design system, such as which properties a component takes, instead of loading every component's documentation on every turn.
When a bug reaches users, fix the automated check that should have caught it, for example by running screenshot tests at phone width, before closing the bug.
Give a coding AI agent the same build tasks several times with the design system's instructions and documents and several times without them, then score every result with pass-or-fail checks.
Have the AI agent update a shared handover file and change log at the end of every working session.
Add an automated check to the build that renders every interface component at phone width, records the layout overflows that exist today as a baseline that may only shrink, and fails the build on any new overflow.
Put a short index file in each folder of an AI agent's context files that says what the folder holds and when the agent should read it.
Search AI-written tests for known worthless patterns, such as tests that expect a server error, and review a sample of files by hand.
Let AI coding agents look up current colour values and component options directly from the design system, instead of from a summary file that goes out of date.
Publish the design system's components as installable packages that an AI coding agent can read, not only as written guidelines.
Write a file of security rules for the team's AI coding tools in each programming language the team uses, and test the rules again whenever the team changes AI model.
Store the instructions every AI agent task reads, the files for one task and incoming streams such as email in three separate folders.
When users in different roles see the same data, keep every rule about who may see what in one central permissions table in the code, so that granting a permission is a one-line change.
Add a lint rule to the front-end build that fails when component code uses a raw hex colour instead of a design-system colour token, so that AI coding agents correct it.
Ask the AI agent to report the problems it met after every run, and treat that report as a list of fixes.
Put the rules an AI agent keeps getting wrong into the instruction file it reads every time.




After each AI agent run, save what the agent had to learn, the decisions it made alone and the engineers' review comments, and update the reusable prompts from them.
Compare the tokens an AI agent spends building one screen when it reads one long design rules file in full and when it fetches only the rules it needs.
In the product repository's AI agent instruction file, require the agent to import components from the design system package and use its design tokens for colour and spacing.
Write the steps an experienced engineer follows to write a test, and the team's testing trade-offs, into a skill the AI agent reads before writing tests.
Use one AI agent session to write the implementation prompt from the requirements, and have a person review it before a second session writes the code.
Score an AI model only on hand-settled cases that the examples in its prompt never used, so the score measures understanding rather than memory.
Generate from the code a file listing every design system component with its properties, allowed values and defaults, and connect AI coding agents to it so they build prototypes only from real components.
Distribute shared AI agent instructions and skills to every engineer through one plugin that updates itself, instead of asking each engineer to install each skill.
Split agent work into steps that each map to one pull request, and run the coordination between steps in ordinary code rather than in an AI agent.
Make the team that adds a skill to the engineers' shared AI coding plugin deliver and support that skill, with architects setting the quality checks it must pass.
When AI agents write much of the code, invest in shared structure for the parts that change most, such as a design system or generated database queries.

A written record of what was decided and why, kept with the work so that someone who did not build it can review it.
Have a second AI model from another maker review the code that the first AI model writes.
Record every test case left out of a release with the reason it was left out, so the choice can be reviewed after a bug.
Keep a short list of the assumptions behind each major engineering plan, each with a signal to watch, a named person responsible and a condition that triggers review.
Keep one file in the code repository that lists the team's settled engineering decisions for coding agents, and update it in the same commit that changes a decision.
Commit plans and decision records to the repository beside the code, so that an AI agent returning to a task can read why the team chose its approach.
Sort a year of code review comments into repeated rules and one-off decisions, and turn the repeated rules into checks that run on every pull request.
Turn each written design rule into an automated check that blocks a code change breaking it, for example a colour typed by hand where a named design-system colour belongs.
Ask for a two-page design brief covering the approach, the alternatives and the failure modes before AI agents change code that crosses services or alters stored data.
Require every AI-written pull request to include a file listing each check the AI agent ran and each thing it could not verify, before the pull request leaves draft.
In code review of AI-written pull requests, look first for changes that the approved plan did not ask for.
Write the rules a coding agent must not break, each with its reason, in one file in the code repository. Test the file by giving the agent a task that touches a rule and checking whether the agent cites it.
Open each AI agent's pull request with a short summary a person has checked, and fold the agent's full description into a collapsed section.
Before a release, choose test cases with a written table that rates each acceptance criterion by how badly its failure would harm users and whether the release changes it.
In each engineering plan that counts on AI tools, name a person to reassess it if code review capacity grows more slowly than the code being written.
Have engineers read each day's pull request files listing what AI agents checked, and open an issue for each recurring gap in what the agents could not check.
Skip the two-page design review for code changes that stay inside one service, leave stored data alone and are easy to undo, even when an AI agent wrote them.
List every decision made during an AI-written change in its pull request, with where the decision came from and who settled it.
Review and merge a written plan for any change that contains a decision someone could disagree with, then let AI agents implement against it.
Before any code is written, have a person check the AI agent's plan against the requirements, the code it will touch and the shape of data and interfaces.
Have an AI agent check every factual claim in a plan against the real code before people approve the plan.

Before an AI feature is built, the team writes down what a good output looks like, so that the result can be tested against it.
Before an AI agent writes code, require a short written spec that says what the change does, how to tell it works and what it must not break.
Before trusting one AI model to grade another's output, label a set of examples by hand and measure how often the grader agrees.
After each change to an AI agent's instructions, rerun its tests and list every case that flipped between pass and fail, instead of trusting the total score.
Do not count tests that an AI model wrote for existing code as verification, because they record what the code already does, errors included.
Before adopting an extra step in an AI coding workflow, run the same tasks with and without it and compare correctness against time and token cost.
Have the AI agent ask its questions or show its plan before it builds anything.




Have the business owner approve 20 to 30 example requests and their expected answers before measuring an AI agent's first baseline.
Before an AI agent starts building, agree with the people who approve its changes which automatic tests every change must pass.



When an engineering team changes an AI agent's instructions, test each rule against two sets of real chats, one where the rule should apply and one where it should not, and keep the change only if both pass.
Give every new automated check a test that makes it fail on purpose, and have each check report how many files it examined.
Turn failed conversations into test personas, and run them again whenever the AI model or provider changes.
When an AI agent fails on a case that no criterion covers, add the criterion and its examples first, then change the agent to meet them.

A set of correct answers or expected results, prepared by someone other than the builder, that a reviewer uses to check work made with AI.
Run the full automated test suite once as a final acceptance check before accepting an AI agent's work, even when a frontier AI model passes first time.
When testing an AI agent, run each test task many times and report how many tasks it passed on every attempt beside its average pass rate.
Make test data files read-only to coding agents, or add a continuous integration check that flags unexpected changes to them.
Have an AI coding agent write down the test results it expects, then have a separate tool run the tests and compare the actual results with those expectations.
Give a separate testing AI agent only the original requirements and the running app, so it checks behaviour without sharing the coding agent's assumptions.
Audit a sample of AI-written unit tests by hand and count how many would catch a real defect.
Write customer tests as tables of inputs and expected results in plain terms, and have an AI agent write the program that runs them.
Keep acceptance tests written by people separate from the coding agent, and instruct the agent to fix its code instead of changing expected results.
Grade an AI agent by checking the records it leaves behind, not by reading its own report of what it did.
Run the AI evaluations on every pull request in an isolated preview environment, and block the merge when quality scores fall below set thresholds.
When adding an AI model to a rule-based system, keep the old hand-written rules as reference answers that each new version of the model must match before it ships.
Before an AI coding agent runs each test, have it lock its predicted pass or fail result, and let it change the test later only with a written reason.

A team checks on purpose that its people can still explain work that AI agents produced.
Have the engineer writing a test for a new feature run it once with the feature missing and confirm it fails, so that a later pass shows it measures something.
Ask an AI agent fixing a bug to record the broken behaviour, apply the fix and repeat the same steps, so the reviewer sees the result before and after.
When reviewing a large code change, first trace one important path through the functions it touches, then read the changed lines from start to finish.
Measure defect rates and mean time to resolution, not lines of code, to judge whether AI coding tools speed up delivery.
Check a sample of required documents, such as risk assessments, against the work they describe.
Ask the team that owns a critical service to explain its recent consequential changes without its go-to engineer or its AI tool before approving the next release.
Sort the team's documents into those colleagues will actually read and those that only record a step, such as risk assessments, and spend careful writing only on the first kind.
Once AI agents write most of the code, have engineers present their finished work to the team, so that each keeps pride in the work and knows what colleagues build.
Have a low-cost AI model label every coding agent conversation by outcome, and use the failed conversations to rewrite the agent's instructions.
Write at least one simple example-based test for every feature, and run the whole suite before each release.
Give the team that owns a critical service the authority to delay a release when it cannot explain a change, before any reliability target is breached.
Read an AI reviewer's comments as carefully as the code, and still read the code itself.

Before an AI agent starts, the work is split into pieces small enough for a person to review one at a time.
When a team plans its work, set aside review time for pull requests produced with AI coding agents and name who has authority to approve them.
Run automated checks, such as behaviour tests and independent code reviews, before a person approves agent-built work, so that each piece reaches the person already checked.
Have the AI agent test each database query change on a read-only copy of the database before it opens a pull request.
Start each task given to a coding agent with a written plan agreed by the engineer and the agent, and have the agent record its test results for review.
Split long-deferred cleanup work into small defined tasks that coding agents complete through the same test and review process.
At the end of each day, turn the day's code review comments into rules in the files that AI agents read before they work.
Before AI agents build a large feature, have a person review its written specification, and add a feature flag and a rollout checklist.
Before starting another AI coding agent, count the agent tasks that are finished or paused and still need the developer's review or decision.
Have an AI agent review each agent-written pull request against the team's architecture rules before a person reviews it.
Have the AI agent read the code and its change history and state what might break before it changes anything.
On a regular schedule, clear the column of tasks marked ready on the team's board, to find work that has stalled close to completion.
Cut each agent-built feature into thin slices that each work end to end, and review the agent's implementation plan as a group before any code is written.

AI makes a working prototype quick, so the effort moves to choosing a direction and getting from prototype to production with a reliable product.
To test a code base's quality, give an AI coding agent a small change to make in it and note where it wastes effort or gets confused.
Before an AI agent runs with broad permissions, restrict the files and systems it can change, limit its network access and run endpoint protection on its machine.
Write a document that links each design-system colour, spacing value and component to the production code it matches, give it to the AI agent that builds prototypes, and correct it when engineers reject the agent's pull requests.
Throw away a prototype built to learn, and design its data model again before any of it goes into the product.
When an AI agent's written instructions for a task give different results from run to run, have the agent run a fixed script for the critical step, such as extracting icon names from a Figma file.
Let a group of no more than five people build a working version end to end behind a staff-only feature flag before reconciling the details with other teams.

How people new to a craft build judgement when AI tools do the work that used to teach it.
Never assign a junior engineer a project alone, and have a senior engineer review the junior's pull requests, including code written with AI.
Once a week, have each junior engineer explain aloud to a senior engineer the decisions in one merged pull request.
Mark some onboarding tickets as learning tasks that a junior engineer attempts without AI tools first, then explains in writing how the AI's approach differed.
Run incident reviews that ask what the team believed that turned out to be untrue, so that junior engineers practise judging their own assumptions.
Teach junior engineers to review what an AI tool produces and to explain why some of its choices may cause problems.
Write critical thinking into career frameworks as specific behaviours, such as validating assumptions before implementation, so that managers can see a junior engineer's growth that shipped tickets no longer show.

Product pages and data designed so that an AI agent, not only a person, can use them.
For a mobile app built separately for iOS and Android, write each behaviour test once, run it against both apps, and block any pull request that passes on only one.
Publish each screen's state and allowed actions as data, so an AI agent can test the app from a command line without an emulator.

Plays from links that are not filed under a topic.
Group related issues into one batch before giving them to an AI coding agent, so that one round of coding and one test run closes them all.
Compare user stories closed before and after AI adoption, not only pull request counts, to see whether more code means more delivered work.
Require a test coverage check to pass before any pull request merges, because an AI coding agent may ignore a testing rule written in its instruction file.
Record a baseline of standard delivery metrics before rolling out an AI coding tool, so its effect on speed and quality can be measured.
When AI agents build the same feature separately for iOS and Android, make both versions pass one shared test suite for the business logic before either ships.
Each month, run a script that sorts the team's pull requests into features, automated checks and same-day emergency fixes, and compare the three counts side by side.
Offer each new AI model to staff on release day as an experiment with a capped budget, and keep it only if benchmarks, user reports and cost data support it.
When comparing AI code review tools, report each tool's share of comments that led to a code change next to its number of comments per pull request.
Compare a new AI model's cost per session on the same group of early users before and after, because early users are heavier users of AI than most staff.
Have the same developer build each mobile feature on both iOS and Android with AI coding agents, instead of keeping separate iOS and Android teams.
Before an engineering leader prices a hard but bounded task as senior engineers' time, have an AI agent attempt it first, with a person setting the design and review standard.
Before buying more AI coding tools, compare lead time on similar pieces of work from before and after adoption, including tickets still unfinished.
Before an AI model grades an AI agent's output, run a free check in ordinary code first, such as a rule that flags a list with too many items.
Run an AI agent on each pull request that flags oversized changes and verbose code before a person reviews it.
Have AI agents merge their branches into one integration branch and run the full test suite once on that frozen branch before a single pull request to release.
Involve engineers in writing the rules for how AI is used, so the people who review AI output also set the standard it must meet.
Have engineering managers report lead time split into waiting time, active work and rework next to AI adoption figures, with a specific reason recorded for every wait.
Define once what counts as an AI review comment being fixed, such as the code changing afterwards, and recount every review tool against that definition each month.
Read AI credit spending next to merged pull requests and ticket closure rates, and do not treat spending alone as a measure of delivery.
Hello, I'm Wevy. Ask how product, design and engineering teams work with AI agents. The answer comes only from the 315 links on this site.
Claude picks the links and writes the answer from them only. Answers can be wrong. Do not type personal information: questions go to Anthropic. How Ask works · Privacy
I send the week's answers from real teams in one email, every Monday.
You get one email to confirm, then one every Monday. Your address goes to Resend once you confirm it. Privacy