Knowledge base

Practitioner practices

As of October 2026, practitioners hand agents whole tasks with the tools to see the delivery cycle and ask for proof instead of steering each step: the plan goes into a committed file, failed attempts are discarded instead of patched, questions state the goal rather than the method, and exact repeated operations go into scripts.

Written by

Benedikt Stemmildt Founder & Co-CEO

Updated: 27 October 2026

Getting Started 2

Our position. We put deterministic operations into scripts, so the agent does not improvise them.

How do practitioners work with coding agents day to day?

The “Robots versus Iron Men” framing distinguishes autonomous agents from augmentation tools and concludes augmentation beats autonomy because feedback loops stay tight; collaboration interfaces are still single-player, so parallel bots collide and merges get ugly, and of the three context strategies (fine-tuning, bigger context windows, RAG) only RAG showed promise at the time; the best teams optimize developer happiness rather than raw productivity by routing toil like tests and docs to AI (How Engineering Teams use AI (opens in a new tab), March 2025). Individual capability compounds when agents are involved: 37signals reports a single agent-accelerated engineer cutting the P1 request floor from 4ms to under 0.5ms across 12 PRs and ~2,500 lines (The Pragmatic Engineer - The impact of AI on software engineers in 2026 (opens in a new tab)).

Single-practitioner loops show the far end of delegation: one documented workflow generates PRDs with the Taskmaster MCP, stores them as GitHub issues, wires memory and documentation MCPs into the agent, and compresses roughly a week of work into a few hours with the human acting purely as code reviewer, down to a closing “we’re done” prompt that triggers branch, PR, multi-agent review, and merge (DevOps Toolkit - My Workflow With AI: How I Code, Test, and Deploy Faster Than Ever (opens in a new tab)). Intercom institutionalizes the same progression as a flywheel: give agents problems, not tasks; automate your work, turn the automation into a shared skill, then optimize the environment for agents, with session transcripts archived and skill-invocation telemetry feeding the loop (Intercom talk - Doubling engineering throughput (opens in a new tab)).

A 15-day solo SaaS build is the cautionary counterpart: AI agents regenerate code without preserving coherence, forgetting why decisions were made, which surfaced as silently bypassed row-level security, double-encrypted OAuth tokens, silently reverted environment variables, and a production app pointed at the dev database. The practices that held were building the full UI first to stabilize drift (models understand English and UI flows better than backend architecture), Socratic verification (making the model reason rather than produce), and treating documentation as disaster-recovery insurance rather than hygiene, all against a model tendency to agree with everything and almost never say “I don’t know” (Sentient Notes – What Vibecoding a Real SaaS Taught Me About AI (opens in a new tab), December 2025). For organizing the knowledge around the work, PARA remains the standard personal system: Projects, Areas, Resources, and Archives, sorted by actionability rather than subject, on the principle that a system has to give you time, not take time (Forte Labs - The PARA Method (opens in a new tab)).

A working list from an engineer on the Amp coding agent hands the agent the whole delivery cycle (How I work with Agents (opens in a new tab), October 2026). The agent runs what it builds end to end, reads production logs, watches the rollout, flips feature flags and triages bug reports, on the reasoning that an agent invents what it cannot see. Instead of trying one idea after another in conversation, the agent builds the means to compare: twenty variations plus a small page to combine and test them, or four theories on why something is slow, each of them checked. The list asks for proof the person cannot dispute, such as end-to-end walkthroughs, demo videos and before/after numbers, and puts a line into AGENTS.md telling agents what does not count as evidence. Knowledge files get the same test: blind agents run with and without a file, as control and treatment, to show whether agents use it at all.

The same list moves the person’s attention out of the conversation. Agents get larger tasks to run asynchronously, and scheduled check-ins, such as a log check two hours after a release, let the agent wait on the person instead of the reverse. Context size is left to automatic compaction, with one thread per task. Review narrows to code with a high blast radius, fewer than five central files plus database migrations, while naming and duplication no longer get a look (How I work with Agents (opens in a new tab), October 2026). The list is one practitioner’s experience without measurement. Its claim that accumulated agent output no longer makes a codebase unmaintainable stands against the drift the 15-day SaaS build above recorded in December 2025.

What does the community pattern catalog record?

Augmented Coding Patterns is a community catalog that sorts practitioner experience into three kinds of entry. As of October 2026 it holds 15 obstacles, 13 anti-patterns and 63 patterns, published under CC BY 4.0 (Augmented Coding Patterns (opens in a new tab)). An obstacle is a limit of the model that prompting cannot remove. An anti-pattern is a mistake the person makes. A pattern is a practice that answers one or both. Typed links join the entries (solves, uses, enables, extends, similar, alternative, causes), so a reader who starts from a symptom lands on the practices that address it. The entries are experience reports from working practitioners, most of them without measurement. Read a pattern as a practice to try, and go to a primary source for any number.

How do you treat the plan as the asset?

One group of entries treats the plan as the asset and the code as disposable.

Knowledge checkpoint

Pattern.

Context. Implementation is about to start on a planned change.

Problem. Without a saved plan, a failed attempt costs a second planning session.

Therefore. Before implementation starts, put the plan into a file and into a commit, so a failed attempt costs a reset (Augmented Coding Patterns - Knowledge Checkpoint (opens in a new tab)).

Watch for. An agent eager to start implementing. Interrupt it and have it save the plan to a file first.

Sunk cost

Anti-pattern.

Context. An attempt has failed, and the person keeps asking the agent to patch it.

Problem. The catalog puts the point of diminishing returns at the third or fourth iteration, after which each fix adds errors (Augmented Coding Patterns - Sunk Cost (opens in a new tab)).

Way out. Discard the attempt and restart with a sharper prompt, or break the problem into pieces small enough for the agent.

Watch for. Time pressure. It strengthens the urge to push for one more fix.

Happy to delete

Pattern.

Context. An attempt has missed the requirement, and the code it produced is cheap to regenerate.

Problem. People treat that code as if it had taken hours to write and patch a flawed implementation instead of starting again.

Therefore. Commit before the agent changes anything, revert a failed attempt, and retry with what the failure taught about the prompt (Augmented Coding Patterns - Happy to Delete (opens in a new tab)).

Watch for. A revert asked for in vague terms. Without an explicit git reset instruction, the agent tends to rewrite the original code from memory.

Parallel implementations

Pattern.

Context. The approach to a change is uncertain.

Problem. The agent’s output is non-deterministic, so the first attempt is often not the one you want, and sequential retries cost your time.

Therefore. Run three to five attempts in parallel from the same checkpoint, then keep the best one or combine parts of several (Augmented Coding Patterns - Parallel Implementations (opens in a new tab)).

Watch for. The trade is tokens for your time. Each attempt needs its own working directory, such as a git worktree.

Related. Knowledge checkpoint, Happy to delete.

How does the question shape the agent’s answer?

A second group is about how the question shapes the answer.

Answer injection

Anti-pattern.

Context. A person asks the agent a question or gives it a task.

Problem. A question that already names a solution limits the agent to that solution, and a fixed count (“give me three questions”) makes it invent items or drop real ones.

Way out. State the goal and leave the method out (Augmented Coding Patterns - Answer Injection (opens in a new tab)).

Watch for. Answers that confirm your idea instead of exploring alternatives. The narrowing is invisible to the person who asked.

Related. Silent misalignment, Sunk cost.

Silent misalignment

Anti-pattern.

Context. The agent works from its own view of the code.

Problem. It keeps complying with instructions that make no sense in that view, and each change builds on the wrong reading.

Way out. Make the agent show what it sees. In the catalog’s example the agent was asked to colour the layout blocks under discussion, and the colours landed on the wrong blocks. Ground rules that let the agent flag instructions it cannot make sense of surface the gap earlier (Augmented Coding Patterns - Silent Misalignment (opens in a new tab)).

Watch for. Confident agreement followed by changes that do not work. The agent says “Sure thing” and keeps guessing.

Related. Answer injection.

Offload deterministic

Pattern.

Context. A task needs counting, parsing or another exact operation that repeats.

Problem. The agent is non-deterministic, so each time it performs the operation itself, it may get it wrong.

Therefore. The agent writes a script once, and the script runs every time after that (Augmented Coding Patterns - Offload Deterministic (opens in a new tab)).

Watch for. A script nobody tested. Test and adjust it until it does what you want before you rely on it.

Effective beginner practices: the habits that come before these sequences.
The disciplined compounding loop: a fixed cycle that writes every lesson back into the repository.
The agent loop: how the loop around the model creates its reliability.
Prompt Engineering: how to structure a request so the agent does not guess.
Where gains and losses occur: where faster individual work stops paying off.

Resources

Pattern catalogs

Augmented Coding Patterns (opens in a new tab) - Community catalog of 15 obstacles, 13 anti-patterns and 63 patterns for working with coding agents, linked by typed relationships, CC BY 4.0.

Practitioner accounts

How I work with Agents (opens in a new tab) - Practitioner list from October 2026 on handing coding agents the whole delivery cycle, from proof requests to blast-radius review.