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.
- 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
Inside every section the newest practices come first.
Contents
- By SDLC stage: Planning & prototyping · Coding & debugging · Tests · Verification · Review & release
- Cross-stage: Prompts and models · Agent instructions · Maintaining the agent setup · Context and memory · Parallel work · Unattended runs · Steering the agent · Staying hands-on
- Teams and projects: Approaches · Review rules · Risk and ownership · Contributions to open-source projects · Hiring
- How far the agent is trusted
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.
- 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.
- Source traceability. The practice in which every fact the agent extracts from legacy code carries a file:line reference back to that code.
- 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.
- 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.
- 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.
- Generated prototype. The practice in which a project starts with a quickly generated prototype that shows whether the key requirement can be met.
- 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.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Simple code for agents. The practice in which code that agents work on is kept simple.
- Tools built for agents. The practice in which the tools an agent calls are made to respond quickly, report errors clearly and withstand misuse.
- Developer-defined structure. The practice in which the developer gives function signatures, an outline or scaffolding, and the agent fills in the implementation.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
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.
- 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.
- 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.
- 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.
- Manual verification of agent code. The practice in which the developer tests that agent-written code actually works.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Agent self-review. The practice in which the agent reviews its own code before a person reviews it.
- Reading agent-written code. The practice in which the developer reads the code an agent wrote before accepting it.
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.
- Push for bolder attempts. A prompting habit in which the agent is told to take more risks and try more ambitious ideas.
- 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.
- 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.
- 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.
- “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.
- Several options with trade-offs. A prompting habit in which the model is asked for several approaches with the pros and cons of each.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- Context priming with code. The practice in which a session starts by placing existing code into the context, and changes are made from there.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- Orchestrator and workers. The practice in which one agent holds the plan, hands subtasks to worker agents and merges their results.
- 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.
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.
- 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.
- 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.
- 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.
- 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.
- Asynchronous agent work. The practice in which the agent works on a task while the developer is busy with something else.
- 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.
- Permission-free mode. The practice in which the agent's permission prompts are switched off, sometimes inside a container.
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.
- 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.
- HTML instead of Markdown. The practice in which the agent writes plans, explanations and code reviews as HTML pages instead of Markdown documents.
- 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.
- Delegation of routine tasks. The practice in which systematic and time-consuming tasks, from renames to large migrations, are handed to the agent.
- 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.
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.
- 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.
- 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.
- Manual refinement of agent output. The practice in which the developer reworks the agent's implementation by hand after the agent has finished.
- 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.
- 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.
- 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.
- 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.