Contents
TL;DR
Most AI agent failures don’t come from bad code. They come from bad assumptions.
In Antigravity, the /grill-me command forces the agent to stop executing… and start thinking.
Instead of generating code immediately, the agent:
- asks questions,
- clarifies requirements,
- identifies blind spots,
- challenges technical decisions,
- validates the architecture before writing a single line of code.
And honestly?
It’s probably one of the best habits you can adopt when working with AI agents.
🤖 The Real Problem With AI Agents
Modern AI agents are impressive.
You tell them:
“Build me a PrestaShop module with API synchronization and an admin dashboard.”
And they immediately start building.
The problem: they often start moving… in their own direction.
Why?
Because an AI agent:
- fills in the blanks,
- interprets intent,
- assumes constraints,
- invents business behaviors.
The result: you sometimes end up with:
- the wrong architecture,
- incorrect business assumptions,
- an unwanted tech stack,
- unmaintainable technical decisions,
- or simply… something that doesn’t match your real need.
The worst part?
The code can still be technically good.
But completely off target.
🔥 /grill-me Completely Changes the Dynamic
The /grill-me command changes how the agent behaves.
Instead of:
“I’ll start coding immediately.”
The agent switches to:
“First, I need to fully understand what you want.”
It becomes a technical interrogation.
The agent starts to:
- ask targeted questions,
- request examples,
- clarify edge cases,
- verify constraints,
- identify ambiguities,
- validate priorities,
- anticipate architectural problems.
And that changes everything.
🧠 Why This Approach Is Extremely Powerful
1. It Reduces Business Hallucinations
AI agents rarely hallucinate syntax.
They mostly hallucinate:
- intent,
- requirements,
- workflows,
- implicit business rules.
/grill-me drastically reduces this problem.
2. It Forces Requirement Clarification
Most projects start with vague specifications.
And very often: even the human developer hasn’t fully clarified the need yet.
/grill-me then acts like:
- an architect,
- a Product Owner,
- a tech lead,
- a functional challenger.
The agent becomes a requirement refinement tool.
3. It Prevents Bad Starts
A bad AI-driven start is expensive:
- refactoring,
- rewrites,
- context loss,
- technical debt,
- fragile architecture.
A few minutes of intelligent questioning can save hours of corrections later.
⚙️ A Concrete Example
You ask:
“Build me an ERP synchronization system for PrestaShop.”
Without /grill-me, the agent could:
- choose the wrong sync strategy,
- assume real-time flows,
- ignore scalability constraints,
- create a non-scalable architecture,
- forget retries,
- ignore data conflicts.
With /grill-me, the agent could ask:
- What is the source of truth?
- Is synchronization bidirectional?
- What is the product volume?
- Real-time or batch processing?
- Conflict resolution strategy?
- Expected SLA?
- Multi-store support?
- Target PrestaShop compatibility?
- REST or SOAP API?
- Retry management?
- Queue system?
- Is idempotency required?
- Failure tolerance expectations?
And suddenly: we’re no longer just talking about “generating code”.
We’re talking about: designing a system correctly.
🚀 Other Essential Commands in Antigravity
/goal
/goal is basically the opposite of /grill-me.
Here: the agent receives a final objective and operates autonomously until the task is complete.
Example:
/goal Fix all broken tests and stabilize the CI pipeline
The agent:
- plans,
- executes,
- fixes,
- iterates,
- validates.
Without asking for intermediate approvals.
This is extremely powerful for:
- refactoring,
- CI/CD fixes,
- migrations,
- repetitive tasks,
- well-scoped workflows.
/schedule
This command allows background task scheduling.
Typical use cases:
- scheduled jobs,
- delayed execution,
- recurring automations,
- AI cron jobs.
Example:
/schedule Analyze logs every night at 2 AM
Very useful for:
- monitoring,
- automated QA,
- audits,
- technical watch,
- proactive maintenance.
/browser
This command explicitly forces the use of the web browsing sub-agent.
The agent can then:
- navigate websites,
- interact with pages,
- test interfaces,
- perform research,
- inspect rendering.
Example:
/browser Test the mobile checkout flow
Very useful for:
- frontend QA,
- scraping,
- UI debugging,
- SEO verification,
- automated user testing.
🏗️ The Real Shift: From Prompting to Orchestration
Developers who perform best with AI agents are no longer just people who “write good prompts.”
They are people who know how to:
- orchestrate,
- frame problems,
- break down tasks,
- supervise,
- validate assumptions,
- control context.
/grill-me is interesting because it formalizes this mindset.
The developer does not become less important.
Quite the opposite.
Their role evolves toward:
- arbitration,
- clarification,
- architecture,
- strategic supervision.
The agent executes. The human pilots.
✅ When To Use /grill-me
Use it systematically for:
- complex architectures,
- e-commerce modules,
- business workflows,
- API integrations,
- multi-service systems,
- migrations,
- AI projects,
- automation pipelines,
- anything where bad assumptions are expensive.
❌ When Not To Use /grill-me
It’s unnecessary for:
- a tiny isolated function,
- a trivial bug fix,
- a highly constrained task,
- a simple mechanical operation.
In those situations:
/goal will usually be faster.
🎯 Conclusion
The biggest risk with AI agents is not that they code poorly.
It’s that they code fast… in the wrong direction.
/grill-me acts like an intelligent safeguard:
- it intentionally slows down the beginning,
- to massively accelerate everything afterward.
And the more autonomous agents become, the more critical this clarification phase becomes.
Because in the end:
A very fast AI agent with bad assumptions is still… an error accelerator.
— Nicolas Dabène
