5 Agentic Coding Suggestions & Tips

5 Agentic Coding Suggestions & 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 strategy to get there’s to cease asking an agent to “construct a function” and begin giving it a workflow it can’t escape.

That workflow ought to drive readability (what modifications), proof (what handed), and containment (what it could actually contact). The ideas under 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 correct 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 mission construction and key entry factors. Hold it below 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 hold 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().mother and father[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]))

from pathlib import Path

INCLUDE_EXT = {“.py”, “.ts”, “.tsx”, “.go”, “.java”, “.rs”}

SKIP_DIRS = {“node_modules”, “.git”, “dist”, “construct”, “__pycache__”}

root = Path(__file__).resolve().mother and father[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 “sizzling” recordsdata, not every part. Instance:

Entry Factors:

api/server.ts (HTTP routing)
core/agent.ts (planning + software calls)
core/executor.ts (command runner)
packages/ui/App.tsx (frontend shell)

Key Conventions:

By no means edit generated recordsdata in dist/
All DB writes undergo db/index.ts
Function flags stay 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 received misplaced.

2. Power Patch-First Edits With A Diff Price range

Brokers derail after they edit like a human with limitless time. Power them to behave like a disciplined contributor: suggest a patch, hold it small, and clarify the intent. A sensible trick is a diff funds, an specific restrict on strains modified per iteration.

Use a workflow like this:

Agent produces a plan and a file record
Agent produces a unified diff solely
You apply the patch
Checks run
Subsequent patch provided that wanted

If you’re constructing your individual agent loop, be certain 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 never line.startswith((“+++”, “—“))) modified = count_changed_lines(diff) if modified > MAX_CHANGED_LINES: increase ValueError(f”Diff too massive: {modified} modified strains”)

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 massive: {modified} modified strains”)

For handbook workflows, bake the constraint into your immediate:

Output solely a unified diff
Exhausting restrict: 120 modified strains whole
No unrelated formatting or refactors
Should you want extra, cease and ask for a second patch

Brokers reply nicely to constraints which are measurable. “Hold it minimal” is obscure. “120 modified strains” is enforceable.

3. Convert Necessities Into Executable Acceptance Checks

Imprecise requests can forestall an agent from correctly modifying your spreadsheet, not to mention arising with correct code. The quickest strategy 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 check that captures the function habits
Run the check to verify it fails for the correct purpose
Let the agent implement till the check 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.enable(“u1”) assert lim.enable(“u1”) assert lim.enable(“u1”) assert not lim.enable(“u1”) time.sleep(1.05) assert lim.enable(“u1”)

import time

from myapp.ratelimit import SlidingWindowLimiter

def test_allows_n_requests_per_window():

lim = SlidingWindowLimiter(restrict=3, window_seconds=1)

assert lim.enable(“u1”)

assert not lim.enable(“u1”)

time.sleep(1.05)

assert lim.enable(“u1”)

Now the agent has a goal that’s goal. If it “thinks” it’s completed, the check decides.

Mix this with software suggestions: the agent should run the check suite and paste the command output. That one requirement kills a complete class of confident-but-wrong completions.

Immediate snippet that works nicely:

Step 1: Write or refine exams
Step 2: Run exams
Step 3: Implement till exams move

At all times embrace the precise instructions you ran and the ultimate check 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 knowledge shapes, time zones, error dealing with, and concurrency. You’ll be able to floor these assumptions with a compelled “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: record 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 usually prevents dangerous architectural commits. It additionally provides you a simple evaluation checkpoint. Should you 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 setting 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:

## Run Recipe Atmosphere: – OS: – Runtime: (node/python/go model) Instructions: 1) <command> 2) <command> Anticipated: – Checks: <summary> – Lint: <summary> – Guide test: <what to="" click="" 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</what></summary> </summary> </command></command>

## 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’t produce a clear run recipe, it most likely has not validated the change.

Wrapping Up

Agentic coding improves quick once you deal with it like engineering, not vibe. Repo maps cease blind wandering. Patch-first diffs hold modifications 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 cut back the agent’s functionality. They sharpen it. Autonomy turns into helpful as soon as it’s bounded, measurable, and tied to actual software suggestions. That’s when an agent stops sounding spectacular and begins transport work you may merge.

Breaking the Host Reminiscence Bottleneck: How Peer Direct Reworked Gaudi’s Cloud Efficiency

LLM Embeddings vs TF-IDF vs Bag-of-Phrases: Which Works Higher in Scikit-learn?

5 Agentic Coding Suggestions & Tips
Picture by Editor

Introduction

1. Use A Repo Map To Stop Blind Refactors

Right here’s a easy generator you may hold 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().mother and father[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 “sizzling” recordsdata, not every part. Instance:

Entry Factors:

api/server.ts (HTTP routing)
core/agent.ts (planning + software calls)
core/executor.ts (command runner)
packages/ui/App.tsx (frontend shell)

Key Conventions:

By no means edit generated recordsdata in dist/
All DB writes undergo db/index.ts
Function flags stay 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 received misplaced.

2. Power Patch-First Edits With A Diff Price range

Use a workflow like this:

Agent produces a plan and a file record
Agent produces a unified diff solely
You apply the patch
Checks run
Subsequent patch provided that wanted

If you’re constructing your individual agent loop, be certain 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 massive: {modified} modified strains”)

For handbook workflows, bake the constraint into your immediate:

Output solely a unified diff
Exhausting restrict: 120 modified strains whole
No unrelated formatting or refactors
Should you want extra, cease and ask for a second patch

Brokers reply nicely to constraints which are measurable. “Hold it minimal” is obscure. “120 modified strains” is enforceable.

3. Convert Necessities Into Executable Acceptance Checks

A light-weight sample:

Write a failing check that captures the function habits
Run the check to verify it fails for the correct purpose
Let the agent implement till the check 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.enable(“u1”)

assert not lim.enable(“u1”)

time.sleep(1.05)

assert lim.enable(“u1”)

Now the agent has a goal that’s goal. If it “thinks” it’s completed, the check decides.

Mix this with software suggestions: the agent should run the check suite and paste the command output. That one requirement kills a complete class of confident-but-wrong completions.

Immediate snippet that works nicely:

Step 1: Write or refine exams
Step 2: Run exams
Step 3: Implement till exams move

At all times embrace the precise instructions you ran and the ultimate check abstract.

If exams fail, clarify the failure in a single paragraph, then patch.

4. Add A “Rubber Duck” Step To Catch Hidden Assumptions

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: record 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

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 setting 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:

## 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’t produce a clear run recipe, it most likely has not validated the change.