What agents changed in how software gets built, and what still holds up
In the autumn of 2025 I kept a list of tips and techniques for coding with LLMs, and stopped adding to it that November. A year later I wouldn’t follow a lot of it myself.
That November Opus 4.5 and GPT-5.2 came out, and agents got good enough to write most of the code.[1] This year Fable and Astra went further and stopped needing most of what my list was for: detailed instructions, carefully prepared context, reminders to think hard.[2]
So I started again from what people who ship software with agents write about their own work. Below are 127 of their practices, each with a quote from the post that describes it.
Prompting is the part that got less important. The practices that were around long before LLMs went the other way: I couldn’t find anyone taking back tests, code review or CI, and if anything they carry more weight now.[3] 22 of the practices on this page grew straight out of one of those older ones, like continuous integration (1998) or test-driven development (2002). Teams that already had them had less to change. Even the rubber duck is still here; now it just happens to talk back.
- Site: https://inmve.github.io/agentic-coding-practices/ (the same reference with quotes on hover and schemes that play)
- Data:
data/entries.json, the single source; this README is generated from it - Survey for your team: team-survey, a GitHub template that asks the same practices inside your team
127 practices, 256 sources, 256 of them with a verbatim quote stored in the data, 65 example schemes. Preliminary edition: dates are not verified yet.
Inside every section the newest practices come first.
-
Self-contained task with proof. Each task for the agent is written as a self-contained ticket stating what is wrong, what done looks like and which command proves it. Sources: Addy Osmani, 2026-10-06; Addy Osmani, 2026-10-06. Grew from: Behaviour-driven development (2006).
-
Confidence markers on extracted facts. Every fact the agent extracts from legacy code carries a green, amber or red confidence marker, and ambiguous code is flagged in the output so that a human expert resolves it. Sources: Shashank Mishra, 2026-07-13; Shashank Mishra, 2026-07-13.
-
Source traceability. Every fact the agent extracts from legacy code carries a file:line reference back to that code. Sources: Shashank Mishra, 2026-07-13.
-
Screenshot iteration. The agent is given a screenshot of the result or of a mock-up, and the change and the screenshot are repeated until they match. Sources: kent-tokyo, 2026-06-03.
-
Throwaway editor with export. The agent builds a disposable interface for editing something by hand, and the interface ends with an export button that turns the edits into a prompt or a file. Sources: Thariq Shihipar, 2026-05-20.
-
Plan before code. The agent first lays out steps, risks and checks, and the developer corrects that outline before any code is written. Sources: Indragie Karunaratne, 2025-07-01; Mitchell Hashimoto, 2025-10-11; Addy Osmani, 2026-10-06.
-
Generated prototype. A project starts with a quickly generated prototype that shows whether the key requirement can be met. Sources: Simon Willison, 2025-03-11; Alex Grebenyuk, 2025-06-23. Grew from: Spike solution.
-
Spec walkthrough with the reviewer. Before the agent writes code, the author walks the future pull request reviewer through the product and technical specs. Sources: Dex.
-
Vertical slices in agent work plans. The agent's work plan for a feature is cut into vertical slices that cross backend and frontend, so that integration is exercised before the end of the work. Sources: shinpr; Dex. Grew from: Tracer bullets (1999).
-
Performance fixes from production traces. The agent is connected to the team's own production traces and asked to find issues on hot code paths, and each resulting pull request links an example trace that shows the extra query or call. Sources: Scott Cooper, 2026-11-03; Scott Cooper, 2026-11-03.
-
Hill climbing on a metric. An agent is given a measured number to beat and repeatedly changes the code and re-measures until the number improves. Sources: Raymond Wang, Sam Attard, and Issac G., 2026-09-23; sankalp, 2026-07-08; Alberto Gimeno, 2026-09-23.
-
Hypotheses from disjoint evidence. Several agents form hypotheses about a bug from separate, non-overlapping pieces of evidence, so that one early guess does not shape the whole investigation. Sources: Thariq Shihipar and Sid Bidasaria, 2026-06-02.
-
Codebase audit with the agent. The developer asks the agent to audit the codebase for one named problem and talks the findings through with it until a concrete change is clear. Sources: Bram Cohen, 2026-04-05.
-
CLI tools instead of MCP. Services are given to the agent as small command-line tools, each with a README that the agent reads only when it needs the tool, instead of MCP servers. Sources: Shrivu Shankar, 2025-11-02; Mario Zechner, 2025-11-30; Armin Ronacher, 2026-10-06; Peter Steinberger, 2025-12-28.
-
Agent feedback loop. The agent is given a check it can run (tests, a build, a linter) and repeats the change and the check until the check passes. Sources: Indragie Karunaratne, 2025-07-01; Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Birgitta Böckeler, Chris Ford, 2026-05-13. Grew from: Continuous integration (1998).
-
Generated code in place of dependencies. The agent writes the needed code in the project, and a new library is not added. Sources: Armin Ronacher, 2025-06-12; Ryan Lopopolo, 2026-02-11.
-
Logs for agent debugging. A system is built with detailed logging, so that an agent can read the logs and find the cause of a problem. Sources: Armin Ronacher, 2025-06-12; Alberto Gimeno, 2026-09-23.
-
Simple code for agents. Code that agents work on is kept simple. Sources: Armin Ronacher, 2025-06-12. Grew from: KISS.
-
Tools built for agents. The tools an agent calls are made to respond quickly, report errors clearly and withstand misuse. Sources: Armin Ronacher, 2025-06-12; Shrivu Shankar, 2025-11-02.
-
Developer-defined structure. The developer gives function signatures, an outline or scaffolding, and the agent fills in the implementation. Sources: Simon Willison, 2025-03-11; Anton Zhiyanov, 2025-09-26; Mitchell Hashimoto, 2025-10-11; Dex.
-
Stable libraries. The developer picks stable libraries that are popular enough for many examples of them to be in the model's training data. Sources: Simon Willison, 2025-03-11; Simon Willison, 2026-03-09. Grew from: Choose boring technology (2015).
-
Tests-as-data. Tests are kept as data files with the input, the expected output and the setup, read by a small test runner, so that agent changes to the tests are visible and can be blocked. Sources: Matteo Vaccari, 2026-11-11.
-
Read-only database for the agent. The agent has access to a read-only copy of the database and validates its query changes there instead of guessing their effect. Sources: Scott Cooper, 2026-11-03.
-
Before-and-after recording of a fix. For a bug fix, the agent reproduces the issue, records the broken behavior, implements the fix and repeats the same steps to show the reviewer the before and after; the team keeps the instructions for this in a skill. Sources: Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22; Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22.
-
Protected test expectations. Test files and expected results that a task should not change are protected from the agent: made read-only, checked in CI for changes, or named in the agent's instructions as inputs to keep. Sources: Matteo Vaccari, 2026-11-11; Naresh Jain, 2026-10-13; Matteo Vaccari, 2026-11-11.
-
Ratcheted benchmark. Each benchmark an agent optimizes also runs in CI as a guardrail whose threshold may only move in one direction, and benchmarks that are flaky or do not track the real metric are dropped. Sources: Raymond Wang, Sam Attard, and Issac G., 2026-09-23; Raymond Wang, Sam Attard, and Issac G., 2026-09-23.
-
Tests before agent code. Tests are written first and shown to fail, and the agent then writes the implementation until they pass. Sources: Arpan Patel, 2026-05-26; Simon Willison. Grew from: Test-driven development (2002).
-
Mutation testing of agent-written tests. Faults are injected into the code under test, by hand, by the agent or by a library in CI, to check that tests written by an agent break with a clear error message. Sources: Matteo Vaccari, 2026-11-11; Senko Rašić, 2026-03-22. Grew from: Mutation testing.
-
Browser checks by an agent. An agent drives a browser on the running application to check a change against each acceptance criterion and reports what it saw, with screenshots, for each criterion. Sources: Abhishek Ray, 2026-03-10.
-
Cap on CI rounds per agent run. An unattended agent gets at most a fixed number of CI rounds per task, two in the source, because every round costs tokens, compute and time. Sources: Alistair Gray, 2026-02-09.
-
Agent-readable test output. Test and CI output is kept short and fast for the agent: a few lines on screen, details written to a log file, progress printed rarely. Sources: Nicholas Carlini, 2026-02-05; Liz Fong-Jones, 2026-07-16.
-
Known-good oracle. The output of agent-written code is compared against an existing known-good implementation, which also narrows down which part of the agent's code is at fault. Sources: Nicholas Carlini, 2026-02-05; Aditya Sharma and Mahesh Kharade, 2026-03-27.
-
Manual verification of agent code. The developer tests that agent-written code actually works. Sources: Simon Willison, 2025-03-11.
-
Agent chain for alert triage. An alert passes through a chain of agents: one investigates and writes a plan, a second reviews the plan, and a third opens a pull request with a scoped fix for the on-call engineer. Sources: Ari Salem, 2026-09-03.
-
First investigation of an alert by an agent. An agent does the first investigation of a production alert: reads the logs, metrics and code, reports a root cause with its evidence, and leaves any change to production to a person's approval. Sources: Aditya Nugraha, 2026-10-22; Sachin Malhotra, 2026-08-18.
-
Category-specific bug hunting agents. Agents search parts of an application for one category of vulnerability, a separate verifier agent proves each finding with a test in the application's own test suite, and findings arrive as pull requests. Sources: Zack Deveau, 2026-07-29.
-
Agent-controlled feature flags. An agent puts its own changes behind feature flags for gradual rollout and reads the flag's results as feedback on whether the change does what it claimed. Sources: Liz Fong-Jones, 2026-07-16; Sachin Malhotra, 2026-08-18. Grew from: Feature flags (2009).
-
One verifier per rule. A list of rules or claims is checked by separate verifier agents, one for each rule or claim. Sources: Thariq Shihipar and Sid Bidasaria, 2026-06-02; Thariq Shihipar and Sid Bidasaria, 2026-06-02.
-
Voted review findings. Several agents look for bugs in a change at the same time, a separate group of agents votes on each finding, and only findings with enough votes are posted. Sources: Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Jon Kaplan, 2026-01-15.
-
Adversarial review. One agent does the work and a second agent, often on a different model, reviews it with the task of finding problems. Sources: Anthropic; Jesse Vincent, 2025-10-05; Arpan Patel, 2026-05-26; Thariq Shihipar and Sid Bidasaria, 2026-06-02; Zack Deveau, 2026-07-29.
-
Agent self-review. The agent reviews its own code before a person reviews it. Sources: Chris Dzombak, 2025-08; Mario Zechner, 2025-11-30; Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15.
-
Reading agent-written code. The developer reads the code an agent wrote before accepting it. Sources: Chris Dzombak, 2025-08; Mitchell Hashimoto, 2025-10-11; Mitchell Hashimoto, 2025-10-11; Justin Paul, 2026-07-30.
-
Lookups on smaller subagents. Verbose reading such as file search, logs and test output goes to subagents on a smaller model, while code edits and decisions stay on the main model. Sources: Addy Osmani, 2026-11-09; Addy Osmani, 2026-11-09.
-
Push for bolder attempts. The agent is told to take more risks and try more ambitious ideas. Sources: Raymond Wang, Sam Attard, and Issac G., 2026-09-23; sankalp, 2026-07-08.
-
Model choice per task. Each step of a task runs on the model that suits it: a cheaper model for routine steps, a more capable one for planning and judging. Sources: Abhishek Ray, 2026-03-10.
-
Model evals on your own tasks. A team chooses a model or an agent tool by running the candidates on a sample of its own real tasks, each with a check of the outcome, instead of going by published benchmark scores. Sources: Addy Osmani, 2026-11-09; Addy Osmani, 2026-11-09; Simon Rendon Arango, Colin Hallett, 2026-10-16; David Crawshaw, 2026-02-08.
-
Model escalation. Work starts on a faster and cheaper model and moves to a more capable one when the task turns out to be hard. Sources: Sankalp, 2025-07-17.
-
“More beautiful” prompt. The agent is asked to make an interface “more beautiful” or “more elegant”, with no further detail. Sources: Indragie Karunaratne, 2025-07-01; David Crawshaw, 2025-06-08.
-
Several options with trade-offs. The model is asked for several approaches with the pros and cons of each. Sources: Simon Willison, 2025-03-11; Thariq Shihipar, 2026-05-20.
-
Single source for agent instructions. One instruction file is canonical and the files of other agent tools point to it through a pointer line, a symlink or an include. Sources: Przemek, 2026-09-23; FerroxLabs.
-
Smallest-scope agent control. A team corrects an agent behavior with the control of the smallest scope that still gives the wanted output: first interface and output contracts, then automated checks, then skills or commands, and root instruction files last. Sources: Addie Beach, Rui Martins Lacerda, 2026-09-09. Grew from: Rules in linters (1978).
-
Gotchas section. Agent instructions, in a skill or the project instruction file, keep a section of gotchas built from the failure points the agent actually hit, updated over time. Sources: Thariq Shihipar, 2026-06-03; Thariq Shihipar, 2026-07-24.
-
Progressive disclosure. Agent context is split into a tree of files, and the agent is told which files exist so that it reads each one only when it becomes relevant. Sources: Thariq Shihipar, 2026-07-24; Thariq Shihipar, 2026-06-03.
-
Repeated prompt as a skill. A prompt or workflow that the developer keeps repeating is saved as a skill or command file, checked into git and run by name. Sources: Arpan Patel, 2026-05-26.
-
Instruction file. Project instructions for the agent (commands, conventions, constraints) are kept in a text document that the agent reads at the start of every session. Sources: agents.md community; Shrivu Shankar, 2025-11-02; Aditya Sharma and Mahesh Kharade, 2026-03-27.
-
Evals for agent instructions. A team runs the same agent tasks as evals with and without a change to instruction files or documentation, and keeps the change only after several runs show an improvement. Sources: Addie Beach, Rui Martins Lacerda, 2026-09-09.
-
Regular audit of the agent setup. Every few weeks, the developer audits the agent setup, including skills, plugins, instruction files and memory, with the tool's check command and reviews which parts still hold true. Sources: Addy Osmani, 2026-08-27.
-
Pruning old constraints. Constraints added to agent instructions for earlier, weaker models are reviewed and deleted, leaving the agent to rely on context and judgement. Sources: Thariq Shihipar, 2026-07-24.
-
Check that the instruction file is loaded. The developer checks which instruction file the agent tool actually reads, for example with a marker word, before relying on it. Sources: Systima, 2026-07-12; Przemek, 2026-09-23.
-
Harness engineering. After each agent mistake, the developer adds a rule, a script or a check to the agent's environment so that the mistake does not happen again. Sources: Mitchell Hashimoto, 2026-02-05; Ryan Lopopolo, 2026-02-11; Liz Fong-Jones, 2026-07-16.
-
Agent session log review. Saved agent session logs are reviewed regularly, by scripts, people or another agent, for repeated errors and permission requests, and the agent's instructions and tools are changed in response. Sources: Shrivu Shankar, 2025-11-02; Thariq Shihipar and Sid Bidasaria, 2026-06-02; Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22. Grew from: Retrospective (2001).
-
Shared experiment log. Agents log every attempted idea and its result, and later agent sessions read the log to see whether an idea was already tried. Sources: sankalp, 2026-07-08.
-
Compaction. A long agent session is summarized at a milestone or near the context limit, with instructions on what the summary keeps, and work continues in a new context from the summary. Sources: Arpan Patel, 2026-05-26.
-
Knowledge base from project history. Agents read the codebase, issues, pull requests and discussion threads and write a knowledge base of unrecorded decisions and conventions, which other agents use when they work on the code. Sources: .txt, 2026-04-29.
-
Repository knowledge as the system of record. Decisions, plans, conventions and other context are kept as versioned files in the repository instead of chats, documents and people's heads, so that agents can read them. Sources: Ryan Lopopolo, 2026-02-11; shinpr; Shashank Mishra, 2026-07-13. Grew from: Architecture Decision Records (2011).
-
Document & Clear. For a large task, the agent writes its plan and progress to a file, the context is cleared, and a new session reads the file and continues the work. Sources: Shrivu Shankar, 2025-11-02; Nicholas Carlini, 2026-02-05; rberg27.
-
Context priming with code. A session starts by placing existing code into the context, and changes are made from there. Sources: Simon Willison, 2025-03-11.
-
Documentation for new libraries. The agent is given current documentation and examples for a library that is missing from the model's training data. Sources: Simon Willison, 2025-03-11; Jude Gao, 2026-01-27.
-
Ceiling on parallel agent threads. The developer sets a ceiling on the number of agent threads run at once, three to four in the source, depending on their complexity. Sources: Addy Osmani, 2026-04-07; Addy Osmani, 2026-04-07.
-
Bootable app per worktree. The application can be started separately in each git worktree, so that every agent runs and checks its own instance. Sources: Ryan Lopopolo, 2026-02-11; Ally Piechowski, 2026-07-28.
-
Task claiming by agents. Parallel agents take work from a shared list, and an agent claims a task, for example by writing a lock file, before working on it, so that no two agents take the same task. Sources: Nicholas Carlini, 2026-02-05; Barry Zhang, Tianyi Peng, Elle Najt, Keller Scholl, and Lance Martin, 2026-11-09.
-
Feature sessions. Each feature or task gets its own agent session, or the context is cleared before an unrelated task begins. Sources: Fabien Sanglard, 2026-08-21; Lee Robinson, 2026-01-09; Addy Osmani, 2026-10-06; Anthropic; Lydia Hallie, 2026-08-14; Addy Osmani, 2026-09-25.
-
Parallel attempts. Several agents or models work on the same problem at the same time, each with its own approach, and the developer compares the results. Sources: Lee Robinson, 2026-01-09; Thariq Shihipar and Sid Bidasaria, 2026-06-02. Grew from: N-version programming (1978).
-
Orchestrator and workers. One agent holds the plan, hands subtasks to worker agents and merges their results. Sources: Anthropic, 2025-06-13; Wilson Lin, 2026-01-14; Thariq Shihipar and Sid Bidasaria, 2026-06-02; Plawan Rath, Akhil Jindal, Ashwini Verma, 2026-10-19.
-
Parallel agents. Several agents work on separate tasks at the same time, each in its own isolated copy of the repository. Sources: David Crawshaw, 2025-06-08; Anthropic; Addy Osmani, 2026-10-06; Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22. Grew from: Feature branch (2009).
-
Observable long-running commands. Long-running tasks are started in terminal panes, such as tmux panes, that the agent observes in real time, instead of the agent sleeping or setting timeouts while it waits. Sources: Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22.
-
Quarantine. Agents that read untrusted content, such as public issues or messages, are barred from high-privilege actions, and those actions are done by separate agents. Sources: Thariq Shihipar and Sid Bidasaria, 2026-06-02; Lance Martin and CJ Avilla, 2026-10-08.
-
Scheduled agent runs. Agent tasks run on a schedule without anyone starting them: a nightly review of existing code, a recurring cleanup or overnight bug fixes that end in pull requests. Sources: Ryan Lopopolo, 2026-02-11; Anthropic; Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22; Georgiana Calancea, 2026-09-10.
-
Warm environment pool for agents. A team keeps a pool of prepared machines for agents, with the main branch checked out, tools installed, apps built and caches warm, so that an agent claims one instead of waiting for setup. Sources: Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22; Alistair Gray, 2026-02-09.
-
Disposable machine for the agent. The agent runs with broad permissions, up to root, on a throwaway machine or virtual machine that has no access to production systems or secrets beyond what development needs. Sources: Granda, 2026-01-02; Harper Reed, 2026-09-22; crawshaw, 2026-02-08.
-
Asynchronous agent work. The agent works on a task while the developer is busy with something else. Sources: Mitchell Hashimoto, 2025-10-11; Granda, 2026-01-02; sankalp, 2026-07-08.
-
Ralph loop. A harness runs the agent in a loop: when one task finishes, the next run starts, until a stop condition such as no new findings or no errors is met. Sources: Nicholas Carlini, 2026-02-05; Thariq Shihipar and Sid Bidasaria, 2026-06-02; Geoffrey Huntley, 2025-07-14.
-
Permission-free mode. The agent's permission prompts are switched off, sometimes inside a container. Sources: Armin Ronacher, 2025-06-12; Jökull Sólberg, 2025-07-03.
-
Unread throwaway code. Code generated for a one-off task is run and thrown away without being read. Sources: Oren Eini, 2026-04-21.
-
Early interruption. The developer stops the agent as soon as it goes in a wrong direction and gives it a correction. Sources: Anthropic; Mikayla Maki, 2026-01-23.
-
HTML instead of Markdown. The agent writes plans, explanations and code reviews as HTML pages instead of Markdown documents. Sources: Thariq Shihipar, 2026-05-20; Thariq Shihipar, 2026-05-20; Nick Keuning, 2026-01-21.
-
Change of approach after repeated failures. After the agent fails at the same problem several times, the developer switches to a different approach. Sources: Mitchell Hashimoto, 2025-10-11; Addy Osmani, 2026-08-14.
-
Delegation of routine tasks. Systematic and time-consuming tasks, from renames to large migrations, are handed to the agent. Sources: Alberto Fortin, 2025-05-15; Raymond Wang, Sam Attard, and Issac G., 2026-09-23; Michael Garfinkle, Mauricio de Meirelles, David Cortes, 2026-10-22. Grew from: Codemods (2008).
-
Repeated rework requests. The developer asks the agent to rework the code as many times as it takes to reach an acceptable result. Sources: Simon Willison, 2025-03-11; Alex Grebenyuk, 2025-06-23.
-
Explainer for a code slice. A person who wants to understand part of a codebase asks the agent to write an explainer for exactly that part. Sources: Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15.
-
Retyping agent code by hand. The agent shows its proposed code in the chat and the developer types every edit into the project by hand. Sources: Ankur Sethi, 2026-08-02.
-
Deliberate practice without agents. An engineer now and then solves a problem without an agent, even one the agent could solve, to keep their own skills. Sources: Saffron Huang, Bryan Seethor, Esin Durmus, Kunal Handa, Miles McCain, Michael Stern, Deep Ganguli, 2025-12-02.
-
Manual refinement of agent output. The developer reworks the agent's implementation by hand after the agent has finished. Sources: Mitchell Hashimoto, 2025-10-11; Conrad Irwin.
-
Critical parts by hand. The developer writes the critical and complex parts of the code and hands the rest to the agent. Sources: Anton Zhiyanov, 2025-09-26.
-
Own draft first. The developer drafts the solution without an agent and then gives it to an agent to review and improve. Sources: Anton Zhiyanov, 2025-09-26.
-
Agent as a pair partner. The developer works with the agent as with a pair partner: thinks a problem through aloud with it, nudges it when needed, then reviews, refactors and tests the result. Sources: Orta Therox, 2025-06-07. Grew from: Pair programming (1998), Rubber duck debugging.
-
Learning with an agent. The developer uses an agent to learn a language or a concept and then applies it when writing code. Sources: Alberto Fortin.
Rules about what an agent may do without a person checking it: how deep the review goes, what the agent may not touch, where it runs. Every practice here also stands in its own section above.
These practices also stand in their own sections above, with their sources.
- Approval bound to a commit. A review approval covers one specific commit, and new commits the system cannot vouch for, such as an agent's push or a hand-resolved merge, require approval again.
- Prompter as a required reviewer. The person who directed the agent counts as one of the required reviewers of its pull request, and an agent's approval never counts as a person's.
- CI workflow files as high risk. The files that define the CI pipeline are treated as high risk, because an agent that can edit the pipeline can weaken the review of its own work.
- Protected test expectations. Test files and expected results that a task should not change are protected from the agent: made read-only, checked in CI for changes, or named in the agent's instructions as inputs to keep.
- Named owner of an agent thread. Every line of agent work has a named person who owns it, and the agent shows user-visible changes to that person with before-and-after screenshots or recordings.
- Risk-based code review. The depth of review for a change depends on its risk: a low-risk change gets a light check or merges automatically, everything else gets full review, and some kinds of code are kept out of automated review.
- Track record before landing without review. A recurring automated source of code changes, such as a fixed prompt that an agent runs again and again, may land its changes without a person reviewing each one only after a clean record over a set period: no incidents, few reverts, few rejections by people and enough landed changes; a source that caused an incident is blocked.
- Quarantine. Agents that read untrusted content, such as public issues or messages, are barred from high-privilege actions, and those actions are done by separate agents.
- Unread throwaway code. Code generated for a one-off task is run and thrown away without being read.
- Agent review of every pull request. A team has an agent review every pull request, and review by a person becomes optional.
- Disposable machine for the agent. The agent runs with broad permissions, up to root, on a throwaway machine or virtual machine that has no access to production systems or secrets beyond what development needs.
- Extra approval for agent pull requests. Pull requests started by an agent or generated by a model must clear a higher bar than other pull requests, such as more human approvals or required tests.
- Critical parts by hand. The developer writes the critical and complex parts of the code and hands the rest to the agent.
- Reading agent-written code. The developer reads the code an agent wrote before accepting it.
- Permission-free mode. The agent's permission prompts are switched off, sometimes inside a container.
Rules that teams and open-source projects set for work with agents.
-
Software factory. People neither write nor review the code: specifications and scenarios drive agents that write the code and run the checks until they pass. Sources: Justin McCarthy, 2026-02-06; Ryan Lopopolo, 2026-02-11; Addy Osmani, 2026-07-20; Dan Shapiro, 2026-01-23.
-
Spec-driven development. Well-crafted requirement specifications serve as the prompts from which coding agents generate the code; in its strictest form the specification is the only thing the developer edits. Sources: GitHub Engineering, 2025-09-30; Liu Shangqi, 2025-12-04. Grew from: Waterfall.
-
Vibe coding (2025). Building software by talking to an agent without reading the code: every change is accepted, errors are pasted back until it works. Sources: Andrej Karpathy, 2025-02-02.
-
Approval bound to a commit. A review approval covers one specific commit, and new commits the system cannot vouch for, such as an agent's push or a hand-resolved merge, require approval again. Sources: Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Maksym Kuzmitskyi, 2026-10-19.
-
Prompter as a required reviewer. The person who directed the agent counts as one of the required reviewers of its pull request, and an agent's approval never counts as a person's. Sources: Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15. Grew from: Pull request (2008).
-
Answer to every review finding. Every finding of the review agent must be fixed or resolved with a stated reason, and a pull request cannot merge while a bug or security finding is open. Sources: Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Addy Osmani, Morgan Westlee Lunt, and Qing Wang, 2026-10-15; Christopher Olsen, 2026-08-06.
-
Volunteer-only review of model-written pull requests. A project assigns pull requests written with a language model only to reviewers who volunteer for them, and such a reviewer may ask the author to redo the change without generated code. Sources: Jynn Nelson, 2026-08-05.
-
Agent review of every pull request. A team has an agent review every pull request, and review by a person becomes optional. Sources: Ryan Lopopolo, 2026-02-11; OpenAI; Dave North, 2026-06-01. Grew from: Pull request (2008).
-
Extra approval for agent pull requests. Pull requests started by an agent or generated by a model must clear a higher bar than other pull requests, such as more human approvals or required tests. Sources: Shrivu Shankar, 2025-11-02; Jynn Nelson, 2026-08-05. Grew from: Pull request (2008).
-
Intent Review. For medium- and high-risk pull requests, an agent guides the engineer through how the change affects the system, with understanding of the change, not approval, as the goal. Sources: Vinay Perneti and Emma Webb. Grew from: Code walkthrough (1974).
-
CI workflow files as high risk. The files that define the CI pipeline are treated as high risk, because an agent that can edit the pipeline can weaken the review of its own work. Sources: Jonathan Wage, 2026-10-13.
-
Named owner of an agent thread. Every line of agent work has a named person who owns it, and the agent shows user-visible changes to that person with before-and-after screenshots or recordings. Sources: Raymond Wang, Sam Attard, and Issac G., 2026-09-23.
-
Ownership of agent controls. Shared agent controls used by many teams, such as skills, commands and root-level instruction files, have an owning team or guild. Sources: Addie Beach, Rui Martins Lacerda, 2026-09-09.
-
Risk-based code review. The depth of review for a change depends on its risk: a low-risk change gets a light check or merges automatically, everything else gets full review, and some kinds of code are kept out of automated review. Sources: Jonathan Wage, 2026-10-13; Spotify Engineering; Chris Adams et al., 2026-06-12.
-
Track record before landing without review. A recurring automated source of code changes, such as a fixed prompt that an agent runs again and again, may land its changes without a person reviewing each one only after a clean record over a set period: no incidents, few reverts, few rejections by people and enough landed changes; a source that caused an incident is blocked. Sources: Chris Adams et al., 2026-06-12; Chris Adams et al., 2026-06-12; Chris Adams et al., 2026-06-12.
-
Agent questions in incident retrospectives. A team's regular incident retrospective adds two questions: whether agent-written code contributed to the incident, and whether the larger volume of change strained review, testing, rollout or observability. Sources: Tyson Singer. Grew from: Retrospective (2001).
-
Analyze, not create. A project lets contributors use language models to answer questions, analyze, check and review their work, but not to create the content they submit. Sources: Jynn Nelson, 2026-08-05; OpenJDK Governing Board.
-
Agents in project spaces only with approval. An agent may comment on or act in shared project spaces only after people approve it or explicitly invoke it. Sources: rnk, 2025-12-17; Wirasm.
-
Contributor review of generated code. A project requires contributors to read and review all generated code or text, and to be able to explain it, before they ask maintainers for review. Sources: rnk, 2025-12-17.
-
Disclosure of agent use. Contributors state in the pull request, commit message or post whether and how a model or agent produced the content. Sources: rnk, 2025-12-17; Jynn Nelson, 2026-08-05.
-
Extractive contribution handling. Maintainers who judge a generated contribution to cost more review time than it is worth reply with a standard request, label it, and stop engaging or close it. Sources: rnk, 2025-12-17; Jynn Nelson, 2026-08-05.
-
Own words in project communication. A project requires issues, pull request descriptions, comments and replies to review to be written in the contributor's own words, not pasted model output. Sources: rnk, 2025-12-17; Jellyfin project.
-
Ban on generated contributions. A project does not accept contributions that include content generated, in part or in full, by language models or similar systems. Sources: OpenJDK Governing Board; Daniel P. Berrangé, 2024-05-16.
-
Build session in the interview. An interview gives the candidate a few hours to build a working prototype with coding agents and tools of their choice. Sources: Applied Intuition, 2026-07-22; DigitalOcean, 2026-06-09.
-
Review of a draft change in the interview. A candidate reviews and improves a colleague's draft pull request in an unfamiliar codebase, with agents allowed. Sources: Sierra, 2026-04-22.
-
Agent session transcripts in the take-home. A candidate submits the transcripts of their sessions with the agent as part of the take-home, next to the code and the demo. Sources: Quentin Rousseau, 2026-02-24.
-
Take-home built for work with agents. A take-home allows agents and is built around a longer problem that an agent does not solve whole, with starter code that leaves the tooling to the candidate. Sources: Tristan Hume, 2026-01-21; Tristan Hume, 2026-01-21.
-
Assessing how a candidate directs agents. Interviewers score how a candidate plans the work, steers the agent and checks what it produced. Sources: Elicit, 2026-03-30; Augment Code, 2026-03-12; Karl Hörnlund, 2025-10-20.
-
Interviews without agents. Some interviews are deliberately held without agents, next to interviews where agents are expected. Sources: Elicit, 2026-03-30; Applied Intuition, 2026-07-22; Anthropic, 2025-07-10.
-
Candidate's own agents in the interview. A candidate may use their own coding agents and tools during an interview, the same ones they would use at work. Sources: Elicit, 2026-03-30; Omnea, 2026-05-26; Simon Newton, 2025-06-11.
See CONTRIBUTING.md: open an issue or a pull request that changes data/entries.json.