Profile
Back to NewsBack
GitHub Trending 23 min
Reader Mode
inmve/awesome-ai-coding-techniques: An open reference of software development practices, from code inspection to work with coding agents

inmve/awesome-ai-coding-techniques: An open reference of software development practices, from code inspection to work with coding agents

Agentic software development reference

Practices for coding agents, and the older ones that still hold 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]](https://x.com/karpathy/status/2015883857489522876) 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]](https://claude.dev/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models/)

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]](https://www.omnea.co/blog/ai-in-our-programming-interviews) 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.

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). Example scheme: Self-contained task with proof
  • 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. Example scheme: Confidence markers on extracted facts
  • 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. Example scheme: Source traceability
  • 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. Example scheme: Screenshot iteration
  • 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. Example scheme: Plan before code
  • 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. Example scheme: Generated prototype
  • 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). Example scheme: Vertical slices in agent work plans

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. Example scheme: Performance fixes from production traces
  • 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. Example scheme: Hill climbing on a metric
  • 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. Example scheme: Hypotheses from disjoint evidence
  • 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. Example scheme: CLI tools instead of MCP
  • 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). Example scheme: Agent feedback loop
  • 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. Example scheme: Generated code in place of dependencies
  • 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. Example scheme: Simple code for agents
  • 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. Example scheme: Tools built for agents
  • 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). Example scheme: Stable libraries

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. Example scheme: Tests-as-data
  • 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. Example scheme: Protected test expectations
  • 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). Example scheme: Tests before agent code
  • 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. Example scheme: Mutation testing of agent-written tests
  • 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. Example scheme: Agent-readable test output
  • 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. Example scheme: Known-good oracle

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. Example scheme: Read-only database for the agent
  • 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. Example scheme: Before-and-after recording of a fix
  • 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. Example scheme: Browser checks by an agent
  • 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. Example scheme: Cap on CI rounds per agent run
  • Manual verification of agent code. The practice in which the developer tests that agent-written code actually works.
Sources: Simon Willison, 2025-03-11. Example scheme: Manual verification of agent code

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. Example scheme: Agent chain for alert triage
  • 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. Example scheme: First investigation of an alert by an agent
  • 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. Example scheme: Category-specific bug hunting agents
  • 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). Example scheme: Agent-controlled feature flags
  • 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. Example scheme: One verifier per rule
  • 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. Example scheme: Voted review findings
  • 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. Example scheme: Adversarial review
  • 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. Example scheme: Agent self-review
  • 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. Example scheme: Reading agent-written code

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. Example scheme: Progressive disclosure
  • 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. Example scheme: Harness engineering
  • 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). Example scheme: Agent session log review

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. Example scheme: Compaction
  • 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. Example scheme: Document & Clear
  • 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. Example scheme: Ceiling on parallel agent threads
  • 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. Example scheme: Task claiming by agents
  • 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). Example scheme: Parallel attempts
  • 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. Example scheme: Orchestrator and workers
  • 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. Example scheme: Quarantine
  • 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. Example scheme: Ralph loop
  • 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. Example scheme: HTML instead of Markdown
  • 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

Chat with me