Augment Code

The top 3 requests?
🧠 "error" (35%)
✅ "test" (21%)
✨ "improve" (18%)

AI isn’t starting from a blank file.

It’s jumping into messy code and making sense of it.

The real value? Debugging, refining, and unblocking.

Most people think devs use AI to write code from scratch.

But we analyzed 81 million developer chats — and that’s not what’s happening.

Here's what we found 👇

Agent prompting = engineering communication.

Don’t think “prompt engineering.” Think “design doc + task breakdown + pair programming.”

Good prompts are good collaboration.

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.

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 👇🧵

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.

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

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...

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

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

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.

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.

Failure is feedback.

It tells you:
– What the Agent misunderstood
– What you didn’t explain
– What to clarify next

Don’t bail—refine.

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.

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.

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.

TL;DR:

🛠️ Tools help
📁 File paths help
🧠 Rationale helps
📌 Examples help

Agents don’t need perfect prompts.

They need complete ones.

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.

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.

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.

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 👇

Guess now we can predict Asia's lunch time 💀