Plays are taken from what the teams in these articles did, and tagged for product, design or engineering work. Jev, an AI model from TypeSafe, checks that each one makes sense without its article. How the check works

How the jobs of product managers, designers, engineers and their managers change when AI agents do more of the building.
Before building an interface for an AI feature, test the prompt it will use on about 20 real user inputs in a chat tool and read every answer.
Pair each new engineer with an experienced engineer who coaches them on when to trust and when to question work from AI tools.
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.
Before opening a prototyping tool, write down the one question the prototype answers and the result that would change the plan.
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.
After an AI agent finishes a task, show the user a list of the decisions it made and why, and let the user reverse any of its actions from that list.
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.
Share department-wide AI usage figures with every engineer, show names only to each engineer's own manager, and never rank engineers by usage.
Engage a UX designer to produce the designs that will be built, even when the design document already holds AI-generated mock-ups.
State the team's high-level technical values to the coding agent explicitly before it starts work.
Have the designer review an AI-drafted prototype for usability and accessibility, and approve the experience separately from the product manager's sign-off on scope.
Have user experience designers write down which product changes need a person's review, such as changes to navigation, in the instructions AI agents follow when they build.
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.
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.
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.
Before pausing work done with AI agents, share its files, write down the next step and list open questions, so a colleague can continue it without the person who started.
Have the AI coding agent produce a short readable summary of each pull request it opens, for the engineer to read before merging.
Before engineers start building a new product, have the product manager decide whether the product should exist at all, and stop the work if the answer is no.
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.
Agree with a partner team how success will be measured before agreeing on the architecture of a shared AI model.
Add each new way a change has broken production to the instructions of the AI agent that reviews every pull request.
Test every candidate AI tool against ten real tasks with answers the team trusts, scoring errors caught, edits needed, hours saved and token cost, before signing a contract.
Keep a simplified copy of the product with fake data where designers can prototype in code without waiting on or breaking the production system.
Tell each new product manager to read the last two months of the team's public channels, then bring a written view to the team instead of asking for a catch-up.
Replace annual product goals with a short list of assumptions about the next three to six months and a plan rewritten each month.
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 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.
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 each design leader own one piece of production work a month, such as a component or a prompt, and put it through the usual review.
Give an AI agent its own chat channel and access to logs so that it watches the health of one system component.
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.
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.
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.
List the week's pending decisions, mark the few that are hard to undo, and return every reversible decision to the person doing the work.
Write one discovery brief with five fields: user problem, evidence, assumptions, business outcome and open questions, each question with a named owner.
Write personal and professional opinions in team communication by hand, and keep AI agents to drafting other prose and code.
Report how long pull requests wait for review and how many are reworked afterwards, next to the amount of code produced.
Read the code an AI model writes before it ships.
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.
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.
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.
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.
Put the engineers who build a service on call for it, including the most senior and best-paid engineers.
Have product leaders record, for each product, whether its product managers and designers may deploy their own changes to production, rather than one rule for all teams.
Before an AI agent reads logs, experiments or pull requests, filter them with simple rules so it examines only the likely causes.
Have designers submit visual changes as pull requests built from the design system's coded components, and have a developer review each one before it ships.
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.
Test an AI feature with examples taken from real use, have an AI model tuned to that feature grade its answers, and keep running these tests after launch.
Give each engineering manager responsibility for some of the team's technical decisions, instead of leaving every technical choice to the engineers they manage.
Name three to five people who use AI tools every week to decide which tools the team adopts or drops, and give operations the contracts, security, access and budget.
Treat AI output as a draft that someone checks before anyone builds on it.
Measure AI adoption by whether finished work reaches users faster, counting the time colleagues spend checking and fixing AI output.
Agree written guardrails with designers so that they can ship small layout, spacing and colour fixes to the production code themselves.
Before building on an open standard for AI agents, check that it is stable, governed by a neutral body and open to contributions.
Give product designers ownership of the production interface, including its performance, bugs and quality, and have them ship changes as pull requests.
Build an internal tool that lets non-engineers make apps from company data and the company's own design library.
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.
Send predictable operations requests to an AI agent first, and route them to a person when the agent's confidence score is low.
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.
Keep reusable agent instructions in one shared repository so that product managers adapt an existing one instead of building a duplicate.
Before an AI agent drafts a report from planning data, have a second AI agent check each item against written rules and tell its owner what to fix.
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.
When testing a product built on AI models, make the product manager decide whether each answer is good enough, judged by its value to customers and its business risk.
Add an automated check that rejects code from an AI agent when it does not use the design system's components and design tokens.
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.
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.
Record decisions about what to build and how in a shared specification that becomes the tasks AI agents carry out and update.
Keep engineers responsible for deciding what is released to production, even when product managers or designers build features with AI agents.
When a new feature ships, check that the product's AI agent knows when to use it, and treat a gap as a defect.
Run automated checks for design tokens, real component imports and accessibility rules on code designers make with AI, before an engineer reviews the pull request.
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.
Expect each product manager to defend every statement in their own documents, using AI as a thought partner rather than the writer.
Compare every proposed ticket, design document or delegated task against the cost of making the change directly.
Once the company has an internal tool that lets staff build apps from company data, have every new employee build a simple app with it during onboarding.
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.
Give designers who code with AI an environment of their own, with clear rules on what they may change, shared AI skills and a design system the AI can read.

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.
In the design system's documentation for each component, add when to use the component and when not to beside its properties, so an AI agent building screens retrieves the reasoning as well as the options.
Keep a separate glossary for each part of the business in version control, with entries for terms agents must not use, such as internal names kept out of customer screens.
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.
Sort a prototype folder into main, exploration and archive areas, with a short map at the top that says what not to touch.
Write rules the AI agent reads at the start of every session that say where new work goes and how to name files.
At the end of a working session with an AI agent, have it turn the designer's review comments into written rules or skills that later sessions follow.
Write the design system's usage rules and known mistakes into guideline files attached to the library, so the AI agent reads them on every task.
Name design-system representatives in both design and engineering who take part in final decisions, so review does not wait on a central team.
Before a team's bug-testing session, give an AI agent that can operate a web browser a test account and a written board of scenarios, and have it record what it finds on that board.
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.
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.
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.




Make one person responsible for the design system, separate from whoever builds screens, and have that person review every gap or exception the builders record.
After an AI agent builds a screen from the design system, mark up the remaining layout problems on screenshots or recordings and send them back to the agent.
Keep a register of deliberate exceptions to the design system's rules, each with its reason, for AI agents to read before they report a bug.
Write down the actions the AI agent must never take, such as renaming a customer's existing feature flags.
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.
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 an order of authority for conflicting design guidance, from the user's goal to general heuristics, and give it to the AI agent.
Write a design system's DESIGN.md file mainly as an overview, colour roles and rules on what to do and avoid, and name the package version its values came from.
Before an AI tool builds an interface component, write down how it takes keyboard focus, which states it shows, how it is dismissed and which colour tokens it uses in each mode.
Have an AI agent add feedback from review meeting transcripts to the design file as annotations, so the designer can take part in the meeting.
Have the AI agent record unclear business rules as open questions in its completion report instead of deciding them, and take that list to the client.
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 an AI model a guide of about 100 words for each task, with a definition, three to five solved examples and a few rules taken from a designer's past decisions.
Check colour contrast in screens an AI agent builds, even when the agent used the correct colour values from the design file.
Before merging a page that an AI agent has rebuilt, click through its interaction states and confirm that each existing function still works.
Store the AI skills and instruction file that a product team's managers use in one shared Git repository, and have it check that each manager's copy is the latest version.
Mark which component is current and which are retired, so an AI agent does not have to guess between them.
Give an AI agent one new kind of task at a time, such as testing its own work before merging, and add the next only once it handles that reliably.
Check every colour and size in a screen built by an AI agent against the design system's named values, and replace any that is not one of them.
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.
Set a recurring date to read in full the instruction file that an AI agent loads before every task, and move instructions that serve only one task into separate files.
Log every component that an AI agent searches for and does not find, and review that list as the design system's backlog.
Publish the design system's components as installable packages that an AI coding agent can read, not only as written guidelines.
Ask the AI agent for a note beside each prototype listing the components it used, what it built by hand and where Figma and code differ.
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.
When a change made with an AI agent goes wrong in code, fix the design in the design tool first, then have the agent carry it back into code.
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.
Search AI-written tests for known worthless patterns, such as tests that expect a server error, and review a sample of files by hand.
Write a script that compares the component names, properties and defaults in the Figma library with those in the coded components, instead of asking an AI model to compare them.
Have the AI agent update a shared handover file and change log at the end of every working session.
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.
Write the steps for documenting a component, such as diagramming its structure and mapping colours to tokens, as AI agent skills that any designer can run.
Store the instructions every AI agent task reads, the files for one task and incoming streams such as email in three separate folders.
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.
Instruct AI agents that when no approved component, pattern or documented exception fits, they report the gap for review instead of creating a new pattern.
Ask the AI agent to report the problems it met after every run, and treat that report as a list of fixes.
Before a manager calls a colleague resistant to AI, list which documents, drives and team systems that colleague's AI assistant can actually open.
Prototype with AI agents on a design branch that is never merged, and have developers rebuild the accepted ideas on a feature branch.
Write a short contract for each design-system component in its code, listing the allowed variants and the uses it forbids, so that AI coding agents follow it when building screens.
When the same lesson recurs across an AI agent's runs, write it as a one-line rule in the agents' instructions, and have a designer approve the rule in the pull request.
Keep components identical in Figma and code, then write their usage rules into DESIGN.md files and Agent Skills so that AI tools build screens from the same rules.
When someone corrects an AI agent's mistake in the design system, have the agent write the lesson in a file beside its instructions. Then add an automated check that fails the build if the mistake returns.
Have the design-system team publish its rules from one shared service that AI coding agents read directly, so no developer works from an outdated copy.
Schedule a regular review in which an AI agent compares recent meeting notes with the instruction files it reads, and a person approves each suggested update.
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.
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.
Ask the AI agent to write a list of everything it could not express or was unsure about each time it builds design-system components, and review that list by hand.
Give every component a profile and rules for correct and incorrect use, and write down what the product never does.
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.
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.
Put the rules an AI agent keeps getting wrong into the instruction file it reads every time.




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.
Before adding variants to a component library, separate the few that need a design decision from those that only repeat sizes, and handle the repeats with variables.
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.
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.
Keep building screens and maintaining the design system as separate jobs for AI agents, so an agent that needs a missing component notes it instead of changing the design system.
Name each Figma component and its properties exactly as in the code component library, so an AI agent can rebuild a screen from Figma in code, or back, by looking up parts instead of guessing.
Give the AI agent a way to look up the existing component and its rules for the screen it is building, instead of the whole design guide.
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.
Have the design-system team store its design tokens, the named values for colour, type and spacing, in one shared industry format that every design tool and AI agent reads the same way.
Settle which source wins when the design file and the shipped component disagree before giving either to an AI tool as a reference.
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.
Let a designer, not the AI agent, decide which corrections are added to the design system.
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 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.
Before releasing an AI assistant in a new language, have employees who are native speakers of it test a preview and report errors such as misread names or the wrong level of politeness.
Write a specification of the problem and the required behaviour before asking a coding agent to build an internal tool.
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.
Require screenshots or short recordings of the state before and after a change in every pull request an AI agent opens.
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.
Before a feature is built, write down the customer value it adds, the problem it solves, how it fits the product and how it fits the financial strategy.
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.







Sort the actions an AI agent asks a person to approve into tiers by consequence, such as spending, publishing or deleting, and offer undo for actions that can be reversed.
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.
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.
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.
Tag every pull request by type, such as feature, bugfix or maintenance, and track the mix instead of the total count.
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.
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.
Have a person review each interface an AI agent builds by opening its live preview link, including on a phone.
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.
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.
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.
Turn each bug that caused an incident into an automated check, and require an escalation with a written reason to bypass any check.
Let an AI agent investigate production problems with read-only access, then require approval of its full plan before it gets write access.
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.
Before reading an agent-written change line by line, rank its files by risk and spend close review on the riskiest ones.
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.
Treat the review of every new dependency as part of code review, including for pull requests written by AI.
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.
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.
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.
Ask the coding agent for a plain-language summary of every change a designer submits, and hold the change to the same review standard as an engineer's.
Ask whoever hands over work that AI helped produce to confirm they have checked all of it, and treat any error in it as their error.
Route every language-quality report through one shared channel where field staff, product owners and language experts agree priorities and name one owner for each issue.
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.
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.
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.
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.
Publish the list of checks an agent must pass before release at the start of a project, so that builders plan for them from the first day.
Sort each pull request from an AI agent by risk, have an engineer review the risky ones and give routine ones a lighter check.



Post a cost report to the ticket after an AI agent finishes each task, so the team can see where the spending goes.
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.
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.
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.
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.
Before an AI agent's proposed change is applied, show users a preview of its full effect, including on other people, and apply it only when they confirm.
Sort design system guidance for AI agents into rules checked automatically, guidelines a person reviews, and decisions a named person owns.
Let an AI agent propose documentation updates when a Figma component changes, and have a person approve each update before it merges.
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.
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.
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.
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 subject-matter expert check any table mapping that an AI assistant produces before it is used in a migration.
Turn the code review rules that nobody on the team disputes into lint rules, tests and automated checks that run before a person reviews.
Require a review on the default branch so that no unreviewed change, from a person or an AI agent, can be merged.
When reviewing an AI-generated change, look first for added locks, extra checks and layers that no requirement calls for.
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 separate AI review pass check each larger AI-written change before a human reviewer sees it.
Move simple checks such as linting onto the engineer's machine, so that AI agents run them before opening a pull request.
When turning code review comments into automated checks, hold back any rule reviewers disagree on until the team agrees it and names who decides.
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.
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.
Sort pull requests by what they could break, let test and documentation changes merge on passing checks, and send authentication, billing or public API changes to a qualified reviewer.
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.
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.
Include an accessibility check in the reviews an agent must pass before it is released to other staff.
Give every change an AI agent makes its own live preview link that people outside engineering can open.
Before a person reviews an AI agent's answers, give that person a verified reference to check them against, and re-check any corrections the reviewer makes.
Ask an expert in the subject, not a generalist, to review an AI agent's output, with a structured way to check each answer.
Put a designer on the team that sets up the company's AI agents, so that the agents' output is judged by a designer's standard of good work.
Let ordinary code fetch, group and reassign test failures, use an AI model only for unfamiliar errors, and have an engineer approve each conclusion.
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.
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.
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.
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.
Stop AI agents from merging database migrations, so that a person takes responsibility for each one.

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.
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.
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.
Limit an AI agent's database changes to adding tables and columns, and leave deletions and renames out until the data can be restored.
Require an AI agent that classifies documents to give a written reason for each decision that a person can check against the source.
Before an AI agent goes into production, write down the one job it is for and test that it declines requests outside that job.
Keep AI agent instructions as version-controlled files so that any change can be reviewed and rolled back.
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.
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.
Name the person accountable for each AI agent's behaviour, and write down what the agent may do without supervision.
Write down what the first version of an AI feature will not do before deciding what it will do.
Run a hard design review of an AI feature before any code is written, testing each part of the concept against what happens when it goes wrong.
Collect reviewers' feedback and records of each AI agent run, and use them to propose changes to the software that runs the agents.
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.
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.
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.
Assign every AI agent a named owner and a defined scope before launch, and update both when people or processes change.
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.
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.
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.
Require a named person's approval before any AI agent merges a pull request or takes an irreversible action.
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.
Write down the decisions that stay with people, such as creative direction and money, before handing studio work to AI agents.
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 the agent acknowledge the steps a user has already tried before it suggests anything new.
Have an AI agent break an approved project document into user stories with acceptance criteria written for coding agents, and keep them in the team's work-tracking tool.
In evaluations of an AI feature, test the whole task end to end, not only the text it writes, and include cases where a connected tool is disconnected, a saved preference changes or no answer fits.
Keep a register of each AI agent's decision rights, with an escalation route and an audit trail.
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.
Make one person responsible for how an AI-built product fits together as a whole, and have that person check that each new change fits.
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.
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.
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.
Show the user exactly which records an AI agent will add, change or delete, run the change only after approval, and return the values it replaced.
Run a nightly AI agent that reviews the previous day's agent sessions and opens pull requests to improve the agents' instructions.
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.
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.
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.
When an AI agent repeats the same mistake more than twice, write the correction into the project's permanent rules for the agent.
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.
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.
Give every instruction file that an AI agent works from a named owner who keeps it current.



Cap how many issues a new AI agent task may create in one run while the team checks its output.
List the moments when users lose trust in a support agent and write the agent's behaviour for each one, including a stated handoff to a person.
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.
Write down, for each AI agent, what it may recommend, decide and carry out, and when authority returns to a person.
For each action an AI agent can take, decide with engineers whether it needs the user's approval and what stops when the user cancels.
When a feature's behaviour is hard to show in static screens, build an interactive prototype in code with the real design tokens and let stakeholders try it on their phones.
The first time a person decides an unusual case for an AI agent, have that person write the decision down as a rule the agent follows the next time.
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.
Give each AI agent its own account with minimal rights and one of three levels of action: act and log it, prepare and wait for approval, or never act.
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.
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.
Ask a person to accept the AI agent's plan for a broad request before the agent may request permission to change files.
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.

AI makes a working prototype quick, so the effort moves to choosing a direction and getting from prototype to production with a reliable product.
Hold design reviews in small groups several times a week instead of in one large weekly meeting.
Bring a working prototype to a design review instead of a written specification.
Place several prototype directions side by side where the team can compare and discuss them, instead of judging one prototype on its own.
Have someone with strong design knowledge review an AI-generated prototype before anyone treats it as ready to ship.
Remove any named solution, such as generative AI, from a design workshop's problem statements, so that the team does not choose the answer in advance.
Show stakeholders proposed versions of a feature as clickable prototypes kept side by side, instead of describing each version in a document.
Release a new feature to half of new users and keep the other half unchanged as a comparison group.
Ship a new AI feature switched off by default as an experiment, and measure who turns it on and keeps it on.
Keep a written list of the features the team has built but not yet checked with real users, and track it alongside the technical debt backlog.
Show stakeholders a working prototype with real data instead of static screens when proposing a new idea.
Before a product experiment ships to users, write down the number of users it needs and the date the team will read the result.
Show the working prototype to stakeholders before the production build, so that engineering and marketing partners can commit early.
Split design guidelines into many small markdown files with an index, so an AI agent reads only the file it needs.
Before an internal tool built with AI ships, name the person who maintains it and set aside 30 per cent of its build cost every year for upkeep.
Before anyone builds a prototype, write down the decision it is meant to help the team make.
Write down the business rules a piece of software must follow before prototyping it with AI, and give developers those rules along with the prototype.
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.
Split design system guidelines into many small Markdown files with an index, so that an AI agent reads only the file it needs.
When building an AI feature, score its outputs against a fixed set of test cases during development, and keep A/B tests on live users for proving that the feature adds value.
Compare one recurring design task done with and without an AI agent, timing the first version, the review and the fixes until the team can approve the change.
Before engineers give a coding agent a refined design prototype to apply, have the designer write down the secondary interactions and edge cases the prototype does not show, so the agent does not invent them.
Book small-group sessions to set up access, VPN, the terminal and Git before a workshop that teaches designers to prototype with AI tools.
Before launch, decide formally whether each prototype the team has built is worth the customer's attention, and set the rest aside.
Require every proposed AI feature to fill in a one-page brief naming who asked, what it does, and its AI cost per seat.
Keep 20 to 30 real user tasks with known good answers, and rerun them whenever a model or vendor release changes, reviewing the results like a usability study.
Build prototypes from the production design system and let reviewers load their own account data, so that reviews discuss the idea rather than placeholder content.
Before deploying a change built from a customer call, ask whether it is worth doing and whether it is what the customer meant.
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.
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.
Build stakeholder prototypes from the same coded components the developers use, so reviewers see how the design will behave in the shipped product.
End each stage of a project with working software that the team must inspect, not with a plan.
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.
Hand engineers the refined working prototype, with its design system and a changelog of what changed in each version, instead of a separate set of design files.
Start each AI chat session in early research with a short brief, and copy what the session produced back into the project's shared notes.
Name who may approve and who may revert a change made with an AI agent, and set technical permissions to match.
Change one piece of the interface or one step of a flow at a time with an AI model, and check it against the current product before merging it back.
Revise the written specification and the working prototype against each other, so that a change in one is checked in the other.
Give designers prototype templates built on the design system, and let improvements made in a prototype flow back into the template.
Have product teams run their own experiments, with experimentation specialists embedded to coach them instead of running tests on request.
Before choosing a direction from an AI prototype, build out the states it leaves out, such as a cancelled booking, to see whether the direction still holds.

A written record of what was decided and why, kept with the work so that someone who did not build it can review it.
Keep a visible list on the team's planning board of each customer problem the team chose not to solve and each solution it rejected.
Keep a file beside each prototype that records what was decided, by whom and why, and read it before changing the prototype.
Have a second AI model from another maker review the code that the first AI model writes.
Add a deliberate review step whenever research findings are copied into a new document, such as a ticket or a brief, and record what changed.
Name one person to keep the maps and documents that explain the product current, and to mark the out-of-date ones, so newcomers know which to trust.
Ask the AI assistant to sort requirement notes into confirmed, assumed and unknown items, with a source line for each confirmed item, before it drafts any user story.
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.
Replace a feature's requirements document and design brief with one table that has a row for each thing the product lets someone do. Link a click-through prototype under each row, and have a designer record a video walkthrough at the top.
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 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.
Put a short human-written brief at the top of every ticket or specification handed to an agent, and label each section as written by a person or generated by the agent.
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.
Write a prototype's fidelity rules, such as no new colours or components, in a file that the AI agent reads before each task.
Require a person to approve each stage of agent-drafted product work, from the list of customer problems to the final specification, before the next stage starts.
List the tasks AI agents now do, have their former owners test whether they can still do them unaided, and schedule practice without AI for skills that are slipping.
Sketch a screen in rough grey lines before any code, and check whether the rules written for it contradict each other.
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.
In code review of AI-written pull requests, look first for changes that the approved plan did not ask for.
Before engineers estimate a roadmap item, write down the customer behaviour behind it, the belief it rests on and the result that would stop the work.
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.
Show the design options rejected during discovery beside the option carried forward, so that a reviewer can see that alternatives were compared.
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.
Write each business rule stakeholders agree, such as what counts as a duplicate, into a decision record with its owner and source, and have AI draft acceptance criteria only from it.
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.
Link every synthesised finding and ticket to the transcript or feedback it came from, and stop work on any item that cannot be traced to its source.
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.
Review and merge a written plan for any change that contains a decision someone could disagree with, then let AI agents implement against it.
Trace every acceptance criterion in a specification back to the customer problem and priority score it came from.
On the roadmap, draw untested bets in a different style from contracts and regulatory deadlines, each with a funding window and a stopping condition instead of a delivery date.
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.
List every decision made during an AI-written change in its pull request, with where the decision came from and who settled it.

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 a team automates a workflow with AI, list each step as it runs today, mark the steps where work gets stuck or effort is wasted, and fix those steps first.
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.
Have the agent add sliders and other live controls to a prototype, so that its colours, sizes and motion can be adjusted while it runs.
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.




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.
Before an AI agent starts building, agree with the people who approve its changes which automatic tests every change must pass.



Record how long a workflow takes and how many people it needs before an AI project starts, so the result can be compared against that baseline.
Split a structured AI conversation into explicit stages with rules for moving between them, instead of relying on one long prompt.
Before changing an AI feature's prompt to fix a known error, write a check that counts how often the error appears, and rerun it after every change.
Have the business owner approve 20 to 30 example requests and their expected answers before measuring an AI agent's first baseline.
Have a person read 10 real user sessions with an AI feature and note what went wrong, then 100, before anyone writes a measure of its quality.
After an AI agent proposes failures in a set of real user sessions, have a person check each one against the team's own notes on those sessions. Accept or reject each failure before anyone writes a metric for it.
Write a research section into a feature's spec naming the expected outcome, signs of success and harm, and what to track, so the coding agent builds the tracking.
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.
When release data shows one group behaving unexpectedly, such as a department sending back many tickets, schedule interviews with people from that group.

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.
Write down the problem a feature solves before building it, and judge the result against that statement.


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.
When a survey uses AI-generated respondents, treat its answers as hypotheses only, and put the same question to real people before deciding anything that depends on rare answers or differences between groups.
Audit a sample of AI-written unit tests by hand and count how many would catch a real defect.
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.
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.
Write customer tests as tables of inputs and expected results in plain terms, and have an AI agent write the program that runs them.
Grade an AI agent by checking the records it leaves behind, not by reading its own report of what it did.
Keep acceptance tests written by people separate from the coding agent, and instruct the agent to fix its code instead of changing expected results.
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.
When an AI agent analyses data, save the steps it followed in a tool the whole team can use, so that anyone can repeat the analysis and check the answer.
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.
Compare any study that uses synthetic respondents with answers from real people before treating its findings as evidence.

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.
Before requiring a team to use an AI tool, agree in writing which tasks it is for, so that nobody feels they must fake enthusiasm for it.
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.
Have AI agents place before-and-after screenshots of each interface change side by side for review.
When AI tools draft research findings, have a second researcher work through the interpretation with the first, so that someone can disagree and catch what was missed.
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.
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.
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.
Write at least one simple example-based test for every feature, and run the whole suite before each release.
Have a low-cost AI model label every coding agent conversation by outcome, and use the failed conversations to rewrite the agent's instructions.
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.
Have the AI agent test each database query change on a read-only copy of the database before it opens a pull request.
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.
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.
Have an AI agent review each agent-written pull request against the team's architecture rules before a person reviews it.
Define the visual reference for each agent-built screen, such as the existing app or approved designs, and require the comparison to pass before a designer reviews it.
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.
Have the AI agent read the code and its change history and state what might break before it changes anything.
Take each workflow apart step by step before an agent is built for it, and decide which steps the agent takes over and which are cut.
Clear the queue of work marked ready on a regular schedule to find items stalled close to completion.

Product pages and data designed so that an AI agent, not only a person, can use them.
In design review, check that each flow can be finished without guessing: distinct button labels, states visible without hovering, and a clear confirmation when a task succeeds.
Cut the app's sidebar from a list of product pages to about five items, each named for a question customers ask of their data.
Run a usability study of a task that an AI agent starts and a person finishes, and check whether information, logins and progress carry across the handoff.
Record each AI agent's calls to the product and replay sessions call by call, as the team does for human users.
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.
In a product built on an AI model, list the checks added only to work around an older AI model's mistakes, and remove those the current one no longer needs.
Use the places where AI agents operating the product fail as a list of usability problems to confirm with people and fix.
Replace checkmarks in comparison tables with specific values that name their source and date, so that an AI assistant can copy them and a person can check them.
Study how customers who work through AI agents use the app, and design a home page that shows what needs their attention today.
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.
Give AI agents the same actions and forms that people use in the interface, and show an agent only the actions that are possible at the current step.

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.
Pair each junior designer who works with AI tools with a senior who reviews the output beside them, and put the teaching time in the project plan.
Once a week, have each junior engineer explain aloud to a senior engineer the decisions in one merged pull request.
Run incident reviews that ask what the team believed that turned out to be untrue, so that junior engineers practise judging their own assumptions.
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.
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.

A workshop that confirms rules a team has already drafted while reviewing real work, instead of trying to invent them in the room.
Write down a design principle whenever a review catches AI-generated work drifting from the product's existing patterns, and share the list with the other design leaders.
Check in design critique whether an AI feature's loading state describes more steps than the system runs, and use a plain spinner for a single quick call.

Plays from links that are not filed under a topic.
Ask staff which tasks they do with personal AI accounts, and use that list as the case for which AI tools the company approves next.
Ask users what they expect before they first use an AI feature, then compare that with what they report afterwards.
For each new sign-up or login flow, list every step and every new term a customer must learn, and remove the ones that do not help them finish the task.
Collect 90 days of requests that customers sent to analysts and use them as the list of questions a chat feature should answer.
Ask the people already using AI tools to show colleagues in similar roles what works for them, before training the rest of the team.
Design what a person sees while an automated action runs and just after it ends, such as a saving indicator, before the feature ships.
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.
Compare user stories closed before and after AI adoption, not only pull request counts, to see whether more code means more delivered work.
On each AI answer, label what the AI system checked against a source, what it inferred and what the user still needs to review before acting on it.
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.
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 a user gives an AI agent an instruction, ask whether it applies this once or from now on.
Add the question of whether users understand and trust a feature to every product review, beside the question of whether it works.
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.
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.
Show every standing rule an AI agent follows on one page where the user can read and revoke 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.
Run an AI agent on each pull request that flags oversized changes and verbose code before a person reviews it.
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.
Design an AI feature to hand users the finished result first, such as a personalised report, and offer the underlying tool and controls as a second step.
Before buying more AI coding tools, compare lead time on similar pieces of work from before and after adoption, including tickets still unfinished.
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.
Keep the existing interface beside any new chat feature and track which path users choose.
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.
When people keep asking an AI agent in chat to do the same job, have the agent build a small dedicated tool for that job instead.
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.
Have the AI agent record each edit as a named move, such as merge, move or reframe, so users can see what changed.
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.
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.
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.
Keep untested product ideas off dated roadmaps until product discovery has shown that they solve the customer's problem.
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 296 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