Skip to content

About

Agentic coding practices: what agents changed in how software gets built, and what still holds up

Topics

Resources

Contributing

Stars

354 stars

Watchers

13 watching

Forks

Latest commit

 

History

132 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

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 just happens to talk back.

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.

Contents

By SDLC stage

Planning & prototyping

  • 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).

    Example scheme: Self-contained task with proof
  • 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.

    Example scheme: Confidence markers on extracted facts
  • 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.

    Example scheme: Source traceability
  • 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.

    Example scheme: Screenshot iteration
  • 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.

    Example scheme: Plan before code
  • 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.

    Example scheme: Generated prototype
  • 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).

    Example scheme: Vertical slices in agent work plans

Coding & debugging

Tests and verification

Review & release

Cross-stage

Prompts and models

Agent instructions

  • 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.

    Example scheme: Progressive disclosure
  • 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.

    Example scheme: Repeated prompt as a skill
  • 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.

Maintaining the agent setup

Context and memory

  • 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.

    Example scheme: Compaction
  • 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.

    Example scheme: Document & Clear
  • 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.

Parallel work

Unattended runs

Steering the agent

Staying hands-on

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 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.

Teams and projects

Rules that teams and open-source projects set for work with agents.

Approaches

Review rules

Risk and ownership

  • 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.

    Example scheme: Risk-based code 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. Sources: Chris Adams et al., 2026-06-12; Chris Adams et al., 2026-06-12; Chris Adams et al., 2026-06-12.

    Example scheme: Track record before landing without review
  • 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).

Contributions to open-source projects

  • 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.

    Example scheme: Agents in project spaces only with approval
  • 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.

    Example scheme: Extractive contribution handling
  • 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.

Hiring

Contributing

See CONTRIBUTING.md: open an issue or a pull request that changes data/entries.json.

About

Agentic coding practices: what agents changed in how software gets built, and what still holds up

Topics

Resources

Contributing

Stars

354 stars

Watchers

13 watching

Forks

Releases

Packages

Contributors