5 Agentic Coding Ideas & Methods
Picture by Editor
Introduction
Agentic coding solely feels “good” when it ships appropriate diffs, passes checks, and leaves a paper path you may belief. The quickest approach to get there may be to cease asking an agent to “construct a function” and begin giving it a workflow it can not escape.
That workflow ought to power readability (what modifications), proof (what handed), and containment (what it might probably contact). The ideas under are concrete patterns you may drop into day by day work with code brokers, whether or not you might be utilizing a CLI agent, an IDE assistant, or a customized tool-using mannequin.
1. Use A Repo Map To Stop Blind Refactors
Brokers get generic when they don’t perceive the topology of your codebase. They default to broad refactors as a result of they can’t reliably find the precise seams. Give the agent a repo map that’s quick, opinionated, and anchored within the elements that matter.
Create a machine-readable snapshot of your venture construction and key entry factors. Preserve it beneath a couple of hundred strains. Replace it when main folders change. Then feed the map into the agent earlier than any coding.
Right here’s a easy generator you may maintain in instruments/repo_map.py:
from pathlib import Path
INCLUDE_EXT = {“.py”, “.ts”, “.tsx”, “.go”, “.java”, “.rs”} SKIP_DIRS = {“node_modules”, “.git”, “dist”, “construct”, “__pycache__”}
root = Path(__file__).resolve().dad and mom[1] strains = []
for p in sorted(root.rglob(“*”)): if any(half in SKIP_DIRS for half in p.elements): proceed if p.is_file() and p.suffix in INCLUDE_EXT: rel = p.relative_to(root) strains.append(str(rel))
print(“n”.be part of(strains[:600])) |
Add a second part that names the actual “scorching” information, not the whole lot. Instance:
Entry Factors:
api/server.ts(HTTP routing)core/agent.ts(planning + instrument calls)core/executor.ts(command runner)packages/ui/App.tsx(frontend shell)
Key Conventions:
- By no means edit generated information in
dist/ - All DB writes undergo
db/index.ts - Characteristic flags dwell in
config/flags.ts
This reduces the agent’s search area and stops it from “helpfully” rewriting half the repository as a result of it obtained misplaced.
2. Pressure Patch-First Edits With A Diff Price range
Brokers derail after they edit like a human with limitless time. Pressure them to behave like a disciplined contributor: suggest a patch, maintain it small, and clarify the intent. A sensible trick is a diff price range, an express restrict on strains modified per iteration.
Use a workflow like this:
- Agent produces a plan and a file checklist
- Agent produces a unified diff solely
- You apply the patch
- Checks run
- Subsequent patch provided that wanted
In case you are constructing your personal agent loop, be certain that to implement it mechanically. Instance pseudo-logic:
MAX_CHANGED_LINES = 120
def count_changed_lines(unified_diff: str) -> int: return sum(1 for line in unified_diff.splitlines() if line.startswith((“+”, “-“)) and not line.startswith((“+++”, “—“)))
modified = count_changed_lines(diff) if modified > MAX_CHANGED_LINES: elevate ValueError(f“Diff too giant: {modified} modified strains”) |
For guide workflows, bake the constraint into your immediate:
- Output solely a unified diff
- Laborious restrict: 120 modified strains complete
- No unrelated formatting or refactors
- For those who want extra, cease and ask for a second patch
Brokers reply properly to constraints which can be measurable. “Preserve it minimal” is obscure. “120 modified strains” is enforceable.
3. Convert Necessities Into Executable Acceptance Checks
Imprecise requests can stop an agent from correctly enhancing your spreadsheet, not to mention developing with correct code. The quickest approach to make an agent concrete, no matter its design sample, is to translate necessities into checks earlier than implementation. Deal with checks as a contract the agent should fulfill, not a best-effort add-on.
A light-weight sample:
- Write a failing check that captures the function habits
- Run the check to substantiate it fails for the precise motive
- Let the agent implement till the check passes
Instance in Python (pytest) for a charge limiter:
import time from myapp.ratelimit import SlidingWindowLimiter
def test_allows_n_requests_per_window(): lim = SlidingWindowLimiter(restrict=3, window_seconds=1) assert lim.permit(“u1”) assert lim.permit(“u1”) assert lim.permit(“u1”) assert not lim.permit(“u1”) time.sleep(1.05) assert lim.permit(“u1”) |
Now the agent has a goal that’s goal. If it “thinks” it’s accomplished, the check decides.
Mix this with instrument suggestions: the agent should run the check suite and paste the command output. That one requirement kills a whole class of confident-but-wrong completions.
Immediate snippet that works properly:
- Step 1: Write or refine checks
- Step 2: Run checks
- Step 3: Implement till checks move
All the time embody the precise instructions you ran and the ultimate check abstract.
If checks fail, clarify the failure in a single paragraph, then patch.
4. Add A “Rubber Duck” Step To Catch Hidden Assumptions
Brokers make silent assumptions about knowledge shapes, time zones, error dealing with, and concurrency. You may floor these assumptions with a pressured “rubber duck” second, proper earlier than coding.
Ask for 3 issues, so as:
- Assumptions the agent is making
- What might break these assumptions?
- How will we validate them?
Preserve it quick and obligatory. Instance:
- Earlier than coding: checklist 5 assumptions
- For every: one validation step utilizing current code or logs
- If any assumption can’t be validated, ask one clarification query and cease
This creates a pause that always prevents unhealthy architectural commits. It additionally provides you a straightforward evaluation checkpoint. For those who disagree with an assumption, you may appropriate it earlier than the agent writes code that bakes it in.
A standard win is catching knowledge contract mismatches early. Instance: the agent assumes a timestamp is ISO-8601, however the API returns epoch milliseconds. That one mismatch can cascade into “bugfix” churn. The rubber duck step flushes it out.
5. Make The Agent’s Output Reproducible With Run Recipes
Agentic coding fails in groups when no one can reproduce what the agent did. Repair that by requiring a run recipe: the precise instructions and atmosphere notes wanted to repeat the outcome.
Undertake a easy conference: each agent-run ends with a RUN.md snippet you may paste right into a PR description. It ought to embody setup, instructions, and anticipated outputs.
Template:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | ## Run Recipe
Atmosphere: – OS: – Runtime: (node/python/go model)
Instructions: 1) <command> 2) <command>
Anticipated: – Checks: <abstract> – Lint: <abstract> – Guide test: <what to click on or curl>
Instance for a Node API change:
## Run Recipe
Atmosphere: – Node 20
Instructions: 1) npm ci 2) npm check 3) npm run lint 4) node scripts/smoke.js
Anticipated: – Checks: 142 handed – Lint: 0 errors – Smoke: “OK” printed |
This makes the agent’s work moveable. It additionally retains autonomy sincere. If the agent can not produce a clear run recipe, it in all probability has not validated the change.
Wrapping Up
Agentic coding improves quick while you deal with it like engineering, not vibe. Repo maps cease blind wandering. Patch-first diffs maintain modifications reviewable. Executable checks flip hand-wavy necessities into goal targets. A rubber duck checkpoint exposes hidden assumptions earlier than they harden into bugs. Run recipes make the entire course of reproducible for teammates.
These tips don’t cut back the agent’s functionality. They sharpen it. Autonomy turns into helpful as soon as it’s bounded, measurable, and tied to actual instrument suggestions. That’s when an agent stops sounding spectacular and begins delivery work you may merge.