Software Practices

An open reference of software development practices, from code inspection to work with coding agents.
For each practice: a definition, when it appeared, where it grew from, and the sources that describe it.

Site: https://inmve.github.io/software-practices/ (the same data, with a timeline and quotes on hover)
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

85 entries, 64 sources, 38 of them with a verbatim quote stored in the data. Preliminary edition: dates are not verified yet.

Inside every section the newest entries come first; practices from before coding agents come last.

Approaches
Planning
UI & Prototype
Coding
Debugging
Testing & QA
Review
Across stages: Prompting
Across stages: Context and memory
Across stages: Sessions and parallel work
Across stages: Models and budget
Across stages: The human's part
Concepts: Agents and tools
Concepts: Context and tokens
Concepts: Risks and failures
Concepts: Ideas and maturity models

Approaches

Software factory (2026). An approach in which a team agrees that people neither write nor review the code: the team states the intent, and evals control the quality.
Agentic engineering (2026). An approach in which production software is built with agents under engineering discipline: specifications, reviews, evals and a harness.
Grew from: Software engineering.
Dark factory (2026). An approach in which the development process works as a black box that turns specifications into software, and people do not write the code.
Explore, plan, code, commit (2025). An approach in which the agent first reads the relevant code, then makes a plan, then implements it and commits.
Sources: Indragie Karunaratne, 2025-07-01; Anthropic.
Grew from: Extreme Programming.
Spec-driven development (2025). An approach in which the specification is the source of truth: the developer edits the specification, and the agent generates the code from it.
Sources: GitHub Engineering; Anton Zhiyanov; Simon Willison, 2025-03-11.
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.
Agile (2001). Developing in short iterations with frequent feedback instead of a detailed upfront plan.
Led to: Early interruption.
Extreme Programming (1999). An agile method: pair programming, tests before code, continuous integration, frequent releases.
Led to: Explore, plan, code, commit.
Waterfall (1970). A development model where stages run strictly in order: requirements, design, code, testing, deployment.
Led to: Spec-driven development.

Planning

Agent War (2026). The practice in which two agents are instructed to disagree by default and to agree only on claims that can be proven.
Stable libraries (2025). The practice in which the developer picks established libraries that existed before the model's training cutoff.
Sources: Simon Willison, 2025-03-11.
User story (1999). A short requirement written from the user's side: who, what they want, and why.
Led to: Feature sessions.

UI & Prototype

Generated prototype (2025). 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.
Grew from: Plan to throw one away.
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: Anthropic; David Crawshaw; Anthropic.
ASCII wireframes. The practice in which the agent is asked to draw the layout as ASCII art before the interface code is written.
Plan to throw one away (1975). The principle that the first version of a system is a pilot and is planned to be replaced.
Led to: Generated prototype.

Coding

Tools built for agents (2025). 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.
Simple code for agents (2025). The practice in which code is kept plain: descriptive function names, no inheritance, no clever constructs.
Sources: Armin Ronacher, 2025-06-12.
Grew from: KISS.
Generated code in place of dependencies (2025). 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.
Rollback points. The practice in which a known working state is saved before a risky change, so that it can be restored.
Grew from: Feature branch.
Feature branch (2005). A separate version-control branch per feature, merged into the main branch when ready.
Led to: Parallel agents, Feature sessions, Rollback points.
Pair programming (1999). Two people work on the same code: one types, the other watches and thinks ahead.
Led to: Agent as a pair partner.
KISS (1960). A design principle: a simple system is more reliable than a complex one.
Led to: Simple code for agents.

Debugging

Agent feedback loop (2025). 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; Simon Willison, 2025-10-05.
Grew from: Continuous integration.
Logs for agent debugging (2025). 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.
Rubber duck debugging (1999). Finding a bug by explaining the code line by line out loud to anyone, even a rubber duck.
Led to: Agent as a pair partner.

Testing & QA

Tests before agent code (2025). The practice in which tests are written first and shown to fail, and the agent then writes the implementation until they pass.
Sources: Chris Dzombak, 2025-08; Anthropic.
Grew from: Test-driven development.
Manual verification of agent code (2025). The practice in which the developer runs agent-written code and confirms that it works, without relying on the agent's own report about tests.
Sources: Simon Willison, 2025-03-11.
Grew from: Test-driven development.
Eval pyramid (2025). The practice in which eval coverage is split into three layers: automated assertions, scoring by a language model and spot checks by people, from the cheapest and most numerous to the most expensive and rarest.
Eval suite (2024). The practice in which a team keeps a versioned set of inputs with expected results and runs it automatically after each change of a prompt, a model or tools.
LLM as judge (2023). The practice in which a language model scores the output of another agent or model against stated criteria.
Test-driven development (2002). Write a failing test first, then the minimal code to pass it, then refactor.
Led to: Manual verification of agent code, Tests before agent code.
Continuous integration (1991). Merging changes into the shared branch often, with an automatic build and tests on every merge.
Led to: Agent feedback loop.

Review

Adversarial review (2026). 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.
Grew from: Code inspection.
Agent self-review (2025). The practice in which the agent reviews its own code before a person reviews it.
Sources: Chris Dzombak, 2025-08.
Grew from: Code inspection.
Reading agent-written code (2025). 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; Chris Dzombak, 2025-08.
Grew from: Code inspection.
Edits in the diff (2025). The practice in which the developer reviews the changes in a diff view and types corrections into the diff before committing.
Sources: Chris Dzombak, 2025-08.
Grew from: Code inspection.
Agent code as a pull request. The practice in which the developer reviews agent-written code the way a colleague's pull request is reviewed: leaves comments for the agent to address and does not edit the code by hand.
Sources: HN Discussion.
Grew from: Pull request.
Subagent verification. The practice in which the agent starts subagents to verify details or to investigate separate questions.
Sources: Anthropic.
Grew from: Code inspection.
Code inspection (1976). A formal checklist-driven review of code by peers before testing.
Led to: Adversarial review, Subagent verification, Agent self-review, Reading agent-written code, Edits in the diff.

Across stages: Prompting

Open questions (2025). A prompting habit in which the model is asked for pros and cons, alternatives and missing points, instead of being asked to confirm an opinion.
Sources: Jesse Vincent, 2025-10-05.
“More beautiful” prompt (2025). 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.
Several options with trade-offs (2025). 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.
Developer-defined structure (2025). 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; Between the Prompts.
Perspective simulation prompt. A prompting habit in which the model is asked what a group of experienced people would say about a question, instead of what the model itself thinks.
Sources: Andrej Karpathy.
Emphasis words in prompts. A prompting habit of marking critical rules with IMPORTANT, NEVER or ALWAYS so the model does not skip them.
Understanding check. A prompting habit in which the agent is asked to restate the task before it starts the implementation.

Across stages: Context and memory

Harness engineering (2026). 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.
Context priming with code (2025). 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 (2025). 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.
Context reset between tasks. The practice in which the agent's context is cleared before an unrelated task begins.
Sources: Anthropic.
Single source for agent instructions. The practice in which one instruction document is canonical and the documents of other agent tools point to it through a pointer line, a symlink or an include.

Across stages: Sessions and parallel work

Autoresearch (2026). The practice in which an agent runs experiments in a loop against a measurable result: it proposes a change, runs the check, keeps the change if the result improved and discards it otherwise.
Fan-out and fan-in (2026). The practice in which a task is split into independent parts, several agents do the parts in parallel, and a coordinator merges the results.
Orchestrator and workers (2026). The practice in which one agent holds the plan, hands subtasks to worker agents and merges their results.
Permission-free mode (2025). The practice in which permission prompts are switched off for tasks whose changes the developer would accept anyway.
Sources: Armin Ronacher, 2025-06-12; Jökull Sólberg.
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; Armin Ronacher; Anthropic.
Grew from: Feature branch.
Asynchronous agent work. The practice in which the agent works on a task while the developer is busy with something else.
Sources: Mitchell Hashimoto.
Feature sessions. The practice of keeping each feature or task in its own agent session so the context does not bloat.
Grew from: Feature branch, User story.

Across stages: Models and budget

Tokenmaxxing (2026). The practice of getting more work out of a fixed token budget through caching, summarization, context pruning and running tool calls from code.
Stronger model for planning. The practice in which requirements and the plan are worked out with a more capable model or a higher reasoning level than the one used for the implementation.
Model choice per task. The practice in which the model and its reasoning level are chosen for each task by modality, context length, tool-call reliability, latency and cost.
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.

Across stages: The human's part

Manual refinement of agent output (2025). The practice in which the developer reworks the agent's implementation by hand after the agent has finished.
Sources: Mitchell Hashimoto, 2025-10-11.
Change of approach after repeated failures (2025). 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.
Critical parts by hand (2025). 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 (2025). The practice in which the developer drafts the solution without an agent and then gives it to an agent to review and improve.
Sources: Alberto Fortin; Anton Zhiyanov, 2025-09-26; Mitchell Hashimoto.
Delegation of routine tasks (2025). The practice in which systematic and time-consuming tasks, from renames to large migrations, are handed to the agent.
Sources: Alberto Fortin; Colton, 2025-08-05.
Agent as a pair partner (2025). The practice in which the developer explains a problem to the agent, gets its feedback and works out the solution together with it.
Sources: Orta Therox, 2025-06-07.
Grew from: Pair programming, Rubber duck debugging.
Repeated rework requests (2025). 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.
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.
Grew from: Agile.
Learning with an agent. The practice in which the developer uses an agent to learn a language or a concept and then writes the code without it.
Sources: Alberto Fortin.

Concepts: Agents and tools

Harness (2026). Everything around a model that makes it an agent: the system prompt, tools, hooks, memory files, evals, the sandbox and the loop that connects them.
Plan before code (2025). 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; Jesse Vincent, 2025-10-05; Mitchell Hashimoto, 2025-10-11.
Memory file (2025). 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.
Subagent (2025). An agent started by another agent for a subtask, usually with its own context window, so that its work does not fill the parent's context.
Agent (2024). A program that uses a language model to take actions (read files, run commands, call tools, edit code) in pursuit of a stated goal, repeating until the goal is met or the work is stopped.
Pull request (2008). A request to merge changes that hosts the discussion and review.
Led to: Agent code as a pull request.

Concepts: Context and tokens

Token budget (2026). The maximum number of tokens an agent may spend on a session, a task or a goal.
Context window. The text a model can see at one time: the prompt, the files, tool outputs and earlier turns. It is measured in tokens; when it fills, older content is summarized or dropped.

Concepts: Risks and failures

Sycophancy (2026). The tendency of a model to agree with the framing the user gave, including when the user is wrong.
Context poisoning (2025). A failure in which a long agent session accumulates outdated assumptions, earlier errors or stale file contents in its context, and they keep affecting later answers.
Prompt injection (2022). An attack in which content the agent reads (a web page, an email, a file) contains instructions that redirect the agent away from what the user asked.

Concepts: Ideas and maturity models

Five levels (2026). A scale that describes how much of development is handed to agents, from autocomplete at the lowest level to the dark factory at the highest.
Software engineering (1968). Treating software development as an engineering discipline with processes, stages and quality control.
Led to: Agentic engineering.

Contributing

See CONTRIBUTING.md. Changes go into data/entries.json; then run python3 scripts/build_readme.py.

awesome-ai-coding-techniques