iiinova — where your digital self keeps evolving

Agent prompting = engineering communication. Don’t think “prompt engineering.” Think “design doc + task breakdown + pair programming.” Good prompts are good collaboration.

020

Ask for a plan before action. “I need to expose time zone settings. First, suggest a plan—don’t write code yet.” This gives you control. And gives the Agent a checkpoint to align.

Don’t cram it all in at once. ❌ “Read ticket, build UI, write tests, update docs” ✅ Break into steps: - Read ticket - Build UI - Write tests - Update docs Let the Agent finish before moving on.

Point the Agent to the right files. ❌ “Add JSON parser to chat backend” ✅ “Add JSON parser in LLMOutputParsing (services/ folder). It’ll be used to extract structured output from chat completions.” Precision = performance.

Give references to code, tests, or docs. ❌ “Write tests for ImageProcessor” ✅ “Write tests for ImageProcessor.Follow structure in test_text_processor.py” The Agent learns better by example.

Include why, not just what. ❌ “Use events instead of direct method calls” ✅ “Reviewers flagged tight coupling in SettingsWebviewPanel.statusUpdate(). Let’s refactor to events to improve modularity.” Reasoning aligns the Agent with your intent.

❌ “Fix bug in login handler” ✅ “Login fails with 500 on incorrect passwords. Repro: call /api/auth with wrong creds. Check auth_service.py. Add test if possible.” Agents need context like humans do.

Augment Code @augmentcode.com · 11/07/2025

Most Agent failures aren’t about bad models. They’re about bad prompts. Here’s how to write prompts that actually work—based on thousands of real dev-Agent interactions 👇🧵

130

Thanks for the feedback, Michael - agree we were overzealous here. We'll go ahead and delete all your info so you don't hear from us again.

000

Introducing Augment Rules

Ready to make your agent work the way you do? Create a .augment/rules/ folder in your repository and start customizing. 🔗 www.augmentcode.com/changelog/in...

augmentcode.com

The most powerful AI software development platform with the industry-leading context engine.

010

Already using .augment-guidelines.md? No changes required—your setup remains supported. But Augment Rules offers even greater flexibility and control.

Three flexible ways to use Rules: 1️⃣ Always: Attach rules to every query automatically 2️⃣ Manual: Select rules per query as needed 3️⃣ Auto: Describe your task—the agent intelligently selects the most relevant rules

100

Get started in seconds: 🧠 Smart Rule Selection: Agent Requested mode finds what’s relevant for each task 🚀 Seamless Migration: Import rules from other tools, or use your existing Augment guidelines 🧩 Flexible Organization: Use any file name or structure to match your workflow

100

Every project, team, and workflow is unique. Augment Rules empower you to specify exactly how your agent should behave. Simply add instruction files to .augment/rules/ and your agent will adapt.

100

With Augment Rules, your software agent can build just like your team does.

Stay in-session. Build context. Correct it like you would a teammate: “This is close—just fix the null case.” “Leave the rest as-is.” You’ll be surprised how far a few nudges go.

000

Failure is feedback. It tells you: – What the Agent misunderstood – What you didn’t explain – What to clarify next Don’t bail—refine.

100

Let it write and run tests. Then iterate: “Tests failed—what went wrong?” “Fix the off-by-one error in test 3.” “Rerun and confirm.” Quick cycles beat careful guesses every time.

100

The best Agent workflows look like test-driven development: Write → run → fix → rerun. You’re not aiming for a perfect prompt—you're building momentum.

100

Prompt. Wait. It messes up. Start over? Not if you build a feedback loop. Here’s how to make Agents actually useful 👇

PS: That’s why we built Prompt Enhancer —it auto-pulls context from your codebase and rewrites your prompt for clarity. Available now in VS Code & JetBrains: just click ✨ and ship better prompts, faster.

010

TL;DR: 🛠️ Tools help 📁 File paths help 🧠 Rationale helps 📌 Examples help Agents don’t need perfect prompts. They need complete ones.

100

Examples work too—but only if they’re scoped: ❌ “Implement tests for ImageProcessor.” ✅ “Implement tests for ImageProcessor. Follow the pattern in text_processor.py.” Now it knows what “good” looks like.

100

A high-context prompt answers the silent questions: - Where should I look? - What else is relevant? - Are there examples I can follow? - What’s the user really trying to do? Agents don’t ask. So you have to pre-answer.

100

Here’s what a low-context prompt looks like: “Enable JSON parser for chat backend.” Sounds fine, right? Until the Agent: - Picks the wrong file - Misses the LLMOutputParsing class - Uses a config that doesn’t exist Because you didn’t ground it.

100

Prompting isn’t about being clever. It’s about giving the Agent everything it needs to not guess. That means: - Clear goals - Relevant files - Helpful examples - Precise constraints Agents don’t hallucinate randomly—they hallucinate from missing context.

Most Agent failures aren’t model problems. They’re context problems. If you give vague or incomplete info, the Agent will fill in the blanks—and usually get them wrong. Here’s how to write high-context prompts that actually work 👇

Augment Code @augmentcode.com · 02/07/2025

Guess now we can predict Asia's lunch time 💀

000

Agents don’t need praise. They need signal. So next time something’s close? Don’t just delete and retry. Nudge. Reinforce. Keep building.

000

Why this works: - Encouragement makes prompts more grounded - Corrections become more specific - The model anchors on what not to change It’s the difference between rewriting from scratch… vs. iterating like a teammate.

100

You can also course-correct gently: “Almost right. But this loop doesn’t handle timezones. Try again with that in mind.” The agent takes the correction and retains the confidence. That balance matters.

100

When something works, say so: “Nice — this covers the main use case. Let’s just handle the null edge case too.” This encourages continuation, not correction. It keeps momentum high — and quality stable.

100

Agents don’t “learn” like humans. But they do respond to signals in the prompt history — especially in long sessions. That means your feedback helps shape what comes next.

100

Agents respond to feedback — just not how you think. The fastest way to improve output quality over time? ✅ Reinforce what works ✅ Redirect what doesn’t ✅ Keep the feedback loop tight Here’s how smart feedback makes agents smarter 👇

100

AI for software doesn’t just mean “smarter” — it has to mean faster, too. If you’re building context-aware systems at scale, this is what it takes under the hood. Full blog here: www.augmentcode.com/blog/repo-sc...

030

With this system in place, we cut retrieval latency by over 40% on our hardest codebases — without changing a single input or output for users. ANN gives us performance at scale without breaking the contract of precision.

130

The best part? All of this happens invisibly. - If ANN isn’t available, we fall back. - If part of the index is stale, we blend modes. - If the codebase is small, we skip it entirely. Users never have to configure or wait. It just works.

But fast search isn’t enough — codebases change constantly. So we built a smart indexing pipeline that matches a live snapshot of your codebase… …and transparently falls back to full search for new/changed code while a new index is built.