agentic-coding-practices 汇总 127 条智能体编码实践
inmve/agentic-coding-practices
GitHub 项目 inmve/agentic-coding-practices 整理了 127 条用智能体开发软件的实践,每条附有来源作者的原话引用,共 256 个来源、51 个示例方案。
Agentic software development reference
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 talks back.
- Site: https://inmve.github.io/dev-with-agents/ (the same reference with a timeline, 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, 51 example schemes. Preliminary edition: dates are not verified yet.
Inside every section the newest practices come first.
Contents
By SDLC stage
Planning & prototyping
-
Self-contained task with proof. The practice in which 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. The practice in which 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. The practice in which 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 practice in which 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 (DEV Community handle), 2026-06-03.
-
Throwaway editor with export. The practice in which 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 practice in which 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. The practice in which 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. The practice in which, 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 practice in which 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).
Coding & debugging
-
Performance fixes from production traces. The practice in which 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. The practice in which 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. The practice in which 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 practice in which 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. The practice in which 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 practice in which 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 practice in which 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. The practice in which 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. The practice in which code that agents work on is kept simple. Sources: Armin Ronacher, 2025-06-12. Grew from: KISS.
-
Tools built for agents. The practice in which 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 practice in which 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 practice in which 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
-
Tests-as-data. The practice in which 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.
-
Protected test expectations. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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.
-
Agent-readable test output. The practice in which 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 practice in which 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.
Verification
-
Read-only database for the agent. The practice in which 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. The practice in which, 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.
-
Browser checks by an agent. The practice in which 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. The practice in which 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.
-
Manual verification of agent code. The practice in which the developer tests that agent-written code actually works. Sources: Simon Willison, 2025-03-11.
Review & release
-
Agent chain for alert triage. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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 practice in which 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 practice in which 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.
Cross-stage
Prompts and models
- Lookups on smaller subagents. The practice in which 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. A prompting habit in which 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. The practice in which 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. The practice in which 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. The practice in which 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. A prompting habit in which 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. A prompting habit in which 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.
Agent instructions
-
Single source for agent instructions. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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.
Maintaining the agent setup
-
Evals for agent instructions. The practice in which 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. The practice in which, 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. The practice in which 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 practice in which 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. The practice in which, 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. The practice in which 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).
Context and memory
-
Shared experiment log. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which, 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. The practice in which 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 practice in which 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.
Parallel work
-
Ceiling on parallel agent threads. The practice in which 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 practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which one agent holds the plan, hands subtasks to worker agents and merges their results. Sources: Anthropic (engineering blog, no personal byline in saved text), 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. The practice in which 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).
Unattended runs
-
Observable long-running commands. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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 practice in which 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 practice in which 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. The practice in which 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 practice in which 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.
Steering the agent
-
Unread throwaway code. The practice in which code generated for a one-off task is run and thrown away without being read. Sources: Oren Eini, 2026-04-21.
-
Early interruption. The practice in which 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 practice in which 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. The practice in which, 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. The practice in which 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 practice in which 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.
Staying hands-on
- Explainer for a code slice. The practice in which 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 practice in which 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. The practice in which 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 practice in which 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 practice in which 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 practice in which 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 practice in which 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 practice in which the developer uses an agent to learn a language or a concept and then applies it when writing code. Sources: Alberto Fortin.
Teams and projects
Rules that teams and open-source projects set for work with agents.
Approaches
- Software factory. An approach in which 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. An approach in which 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.
Review rules
- Approval bound to a commit. A team rule in which 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. A team rule in which 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. A team rule in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which, 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).
Risk and ownership
-
CI workflow files as high risk. The practice in which 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. A team rule in which 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. The practice in which 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 practice in which 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. The practice in which 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. The practice in which 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).
Contributions to open-source projects
- Analyze, not create. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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.
Hiring
-
Build session in the interview. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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. The practice in which 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.
How far the agent is trusted
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 team rule in which 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. A team rule in which 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 practice in which 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. The practice in which 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. A team rule in which 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 practice in which 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. The practice in which 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. The practice in which 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. The practice in which code generated for a one-off task is run and thrown away without being read.
- Agent review of every pull request. The practice in which a team has an agent review every pull request, and review by a person becomes optional.
- Disposable machine for the agent. The practice in which 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. The practice in which 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 practice in which the developer writes the critical and complex parts of the code and hands the rest to the agent.
- Reading agent-written code. The practice in which the developer reads the code an agent wrote before accepting it.
- Permission-free mode. The practice in which the agent's permission prompts are switched off, sometimes inside a container.
Contributing
See CONTRIBUTING.md. Changes go into data/entries.json; then run python3 scripts/build_readme.py.
来源:GitHub · github.com