x.com/i/article/203250327776…

How do you hire engineers when agents write 99% of the code? Recognizing that the craft of engineering is moving up the abstraction stack led us to a simple question: In an AI-native environment, what capabilities actually separate exceptional engineers from good ones? Here are the 6 criteria we landed on: augmentcode.com/blog/how-we-…

No Figma file? No problem. Code to Canvas fixes that in one prompt. Capture your live website into @figma, make edits, then sync the changes back to code. All from the same app. Set up the official Figma remote MCP in Intent in a few clicks:

@augmentcode I’ve used dozens of IDEs and CLIs, but I’ve never seen anything as professional or as precise as Augment Code. With a few million credits, I feel like I could save the world.

Code review may be one of the first outer-loop engineering tasks where agents beat the average human reviewer. In production: Augment led to 1.03 bugs fixed per PR. Human reviewers: 0.54. True-positive rates were comparable (45% vs 50%).

Even with strong context retrieval, review quality depends heavily on the design of the agent system. We found that four parts of the system had the biggest impact on review quality: 1. The tools the agent uses to gather context and post reviews 2. The system prompt that defines the review philosophy 3. The model–prompt pairing 4. The guardrails around the agent’s behavior to prevent comment flooding

We wrote up the full breakdown: how we built the context layer, designed the prompt, chose the model, and set up eval loops. Read it here → augmentcode.com/blog/how-we-…

Intent is truly one of the best coding tools I have used.

The IDE was built for an era when developers worked at the level of code: syntax highlighting, autocomplete, debuggers. Intent is built for a world where developers define what should be built and delegate the execution to agents.

Staff Engineer @sambreed breaks down how Augment Intent's multi-agent team actually works under the hood. No hidden system prompts. You can see and edit everything driving the agents.

“In January I realized we weren’t AI-native enough.” @VinayPerneti VP of Engineering at @AugmentCode: “I started asking the team how they were using agents, and something had clearly shifted.” “Several senior engineers told me they were no longer writing code themselves.” “These are staff-plus engineers with 20+ years of experience.” “They said they couldn’t keep up with models like Opus and Codex.” “The models were producing high-quality code and working across multiple parts of the codebase at once.”

Free GPT-5.4 is ending tomorrow, March 11, at 3pm PT. It's an amazing model for agent coordination, especially in our ADE, Intent. Try it for free while there is still time: augmentcode.com/product/inte…

Tired of AI workflows that only work in demos? We’re going over the shoulder with @Wattenberger (ex‑Principal Research Engineer @ GitHub, now Partner @ Sutter Hill + Product Lead for Intent). Live session topics will include: · structuring specs before code · how/why she uses worktrees · wiring Figma MCP → Intent to speed up designer/dev workflows Casual livestream. Real setup. Ideas you can test immediately after we end. Register now: luma.com/747xtxzq?utm_source…

Judgment doesn't scale with tooling. Your AI agent can ship a feature before you've decided whether it's the right feature. The doing got faster. The thinking didn't.

x.com/i/article/203124820836…

x.com/i/article/203079697252…

AI breakthroughs are happening so fast that what feels like magic today becomes the minimum tomorrow. Every breakthrough resets the baseline before we’ve even adapted.

Spec-driven development fails for the same reason every documentation-first initiative fails. It asks humans to do continuous maintenance work that nobody sees and nobody rewards. The fix is making the spec bidirectional: both humans and agents read from it and write to it.

3. Skills and files: how the agent works on *this* project This layer is where you add context that's specific to your project, team, or domain. At Augment, we support multiple customization mechanisms that compose together. - Templates: pre-built behavioral for common use cases; for example, “prototyper” - Workspace guidelines: project-specific conventions - User rules: personal preferences and coding style - Skills: reusable capabilities in XML format (following the agentskills.io spec) Unlike the system prompt (which is general) or tools (which are specific to capabilities), guidelines and skills are knowledge, conventions, and reusable capabilities scoped to a narrower domain or context (your project, a certain circumstance, a directory, etc).

1. System prompts: your agent's identity The system prompt is your foundation. It defines who the agent is, its core behavioral patterns, and what matters most. We’ve also found that critical instructions should go at the beginning and get reinforced at the end. This takes advantage of primacy and recency effects. LLMs pay more attention to what comes first and what comes last.

2. Tools: what the agent uses and when Tools are a fundamental part of how you prompt the agent. At Augment, each tool has three components that influence agent behavior: - Name: what the tool is called (should be self-explanatory) - Description: what it does and when to use it (shown to the model) - Input schema: what parameters it accepts, with descriptions for each The more specific and directive your tool descriptions, the better the agent will understand when to use each tool.

We’ve found that there are four main layers when it comes to prompting ↓

4. The user message: the actual request The user message is where the rubber meets the road: the immediate task, plus runtime context and metadata. They might be plain text requests, like "Fix the authentication bug,” but they can also include: - Structured nodes: Text, images, tool results, code snippets - Context markers: Canvas IDs, file references, linked documents - Metadata: Silent messages, timestamps, conversation threading

x.com/i/article/202966781153…

GPT 5.4 just dropped. Live demos and Q&A with OpenAI team x.com/i/broadcasts/1qxoNeYvN…

We’re going live with @OpenAI today at 11:30 AM PT to talk about GPT-5.4 and Intent workflows. Join the livestream if you’d like to see it in action and ask your questions: luma.com/3xpr4rbd

Agent orchestration is becoming the real bottleneck in AI workflows. Models can generate code quickly. But plans drift, tool state gets lost, and multi-agent work falls apart halfway through. GPT-5.4 is the first model we’ve used that feels built for this moment.

In our testing, GPT-5.4 is noticeably better at staying on plan. It updates the plan when constraints change and finishes the loop with verification instead of restarting mid-run. The difference we’ve seen: - fewer tool-state failures - fewer “re-derive the approach” turns - smoother coordination across agents This is exactly where Intent workflows benefit.

GPT-5.4 is now the default model in Augment, and it’s free for a limited time.

It’s also a strong daily driver. On harder tasks like complex refactors, multi-file reasoning, and architectural planning, we’re seeing ~18–20% fewer tokens in our testing. Try GPT-5.4 in Intent today: augmentcode.com/product/inte…