5 Agentic Coding Ideas & Tips
Picture by Editor
Introduction
Agentic coding solely feels “sensible” when it ships appropriate diffs, passes exams, and leaves a paper path you may belief. The quickest solution to get there’s to cease asking an agent to “construct a function” and begin giving it a workflow it can not escape.
That workflow ought to pressure readability (what adjustments), proof (what handed), and containment (what it might contact). The guidelines beneath are concrete patterns you may drop into each 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 not reliably find the fitting seams. Give the agent a repo map that’s quick, opinionated, and anchored within the components that matter.
Create a machine-readable snapshot of your mission construction and key entry factors. Hold it below a number of hundred traces. 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 preserve 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] traces = []
for p in sorted(root.rglob(“*”)): if any(half in SKIP_DIRS for half in p.components): proceed if p.is_file() and p.suffix in INCLUDE_EXT: rel = p.relative_to(root) traces.append(str(rel))
print(“n”.be a part of(traces[:600])) |
Add a second part that names the true “scorching” information, not every part. 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 - Function flags reside 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 bought misplaced.
2. Drive Patch-First Edits With A Diff Funds
Brokers derail after they edit like a human with limitless time. Drive them to behave like a disciplined contributor: suggest a patch, preserve it small, and clarify the intent. A sensible trick is a diff finances, an specific restrict on traces modified per iteration.
Use a workflow like this:
- Agent produces a plan and a file listing
- Agent produces a unified diff solely
- You apply the patch
- Checks run
- Subsequent patch provided that wanted
In case you are constructing your individual agent loop, make sure 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: increase ValueError(f“Diff too giant: {modified} modified traces”) |
For handbook workflows, bake the constraint into your immediate:
- Output solely a unified diff
- Laborious restrict: 120 modified traces whole
- No unrelated formatting or refactors
- If you happen to want extra, cease and ask for a second patch
Brokers reply properly to constraints which can be measurable. “Hold it minimal” is imprecise. “120 modified traces” is enforceable.
3. Convert Necessities Into Executable Acceptance Checks
Obscure requests can stop an agent from correctly enhancing your spreadsheet, not to mention developing with correct code. The quickest solution to make an agent concrete, no matter its design sample, is to translate necessities into exams earlier than implementation. Deal with exams as a contract the agent should fulfill, not a best-effort add-on.
A light-weight sample:
- Write a failing take a look at that captures the function habits
- Run the take a look at to substantiate it fails for the fitting cause
- Let the agent implement till the take a look at passes
Instance in Python (pytest) for a price 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 take a look at decides.
Mix this with instrument suggestions: the agent should run the take a look at 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 exams
- Step 2: Run exams
- Step 3: Implement till exams cross
At all times embrace the precise instructions you ran and the ultimate take a look at abstract.
If exams 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 information 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?
Hold it quick and necessary. Instance:
- Earlier than coding: listing 5 assumptions
- For every: one validation step utilizing present 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 offers you a simple assessment checkpoint. If you happen to disagree with an assumption, you may appropriate it earlier than the agent writes code that bakes it in.
A typical win is catching information 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 person can reproduce what the agent did. Repair that by requiring a run recipe: the precise instructions and surroundings 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 embrace 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> – Handbook test: <what to click on or curl>
Instance for a Node API change:
## Run Recipe
Atmosphere: – Node 20
Instructions: 1) npm ci 2) npm take a look at 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 preserve adjustments reviewable. Executable exams 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 methods don’t scale 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.
