DEV Community

Cover image for Elevating Antigravity agent skills, Part 2: Image generation
Google AI profile image James O'Reilly
James O'Reilly for Google AI

Posted on Originally published at linkedin.com

Elevating Antigravity agent skills, Part 2: Image generation

#ai #agentskills #antigravity

By coupling native image generation directly with structured prompt synthesis, you turn your AI agent from a text generator into an image studio producing clean, consistent images grounded in developer specs.

Here is what you will get out of this deep dive:

  • How to use the generate_image tool within agent skills.
  • Prompt tokenization strategies for consistent image generation.
  • Full breakdown of a real-world example skill you can use.
  • BONUS: Three visual asset anti-patterns to avoid in agentic workflows.

📝 About this series: Welcome to Elevating Antigravity Agent Skills series, a 5-part engineering guide to mastering the agent tools that reduce orchestration tax and transform AI agents into autonomous collaborators: ask_question, generate_image, define_subagent + invoke_subagent, send_message and manage_subagents.

Beyond the grey

Many of us building web applications, developer tools, or component libraries have used grey placeholder boxes while waiting for sample visual assets.

This is where the generate_image tool comes in. When an Antigravity agent executes generate_image, it synthesizes text prompts and visual parameters into images saved directly into the conversation artifact storage.

Passing un-processed prompts without structure directly to generate_image leads to inconsistency. By encoding lighting, camera, and scene specifications into your skill's prompt generator, your agent produces images that consistently match your intent.

Native artifact rendering and context storage

Before diving into skill authoring, let's review how Antigravity manages generated media.

When generate_image runs, the system automatically saves the output asset to the conversation's internal artifacts directory (<appDataDir>/brain/<conversation-id>/). The tool returns the absolute file path, allowing your skills to render the asset directly in chat responses using standard markdown syntax: ![Caption](file:///path/to/image.png).

A reference walkthrough of our image generation workflow

To see this architecture in action, let's examine an example generating-mock-images skill. Using a plant and flower e-commerce store as my example, this skill generates mock product assets, displays the resulting image for interactive review, and handles workspace asset persistence.

Mock photos of flowers

Figure 1: When we prompt "Create mock photo of white lilies." or "...Jasmine", or "...multi-colored roses", the generating-mock-images skill is auto-discovered by the agent and read into context. The skill instructs the agent to follow the playbook we created.

.agents/skills/generating-mock-images/
├── SKILL.md
Enter fullscreen mode Exit fullscreen mode

1. Image prompt synthesis

The skill pairs the selected product subject (user provided houseplant or floral arrangement) with hardcoded photography parameters detailed in the skill:

### 1. Synthesize Prompt & Call `generate_image`
Construct the final image prompt by combining subject with photography specifications:

> "Professional studio product photograph of [SUBJECT]. [SCENE: smooth matte light gray surface, seamless background curve with soft infinite horizon, visible water line in vase]. [CAMERA: macro lens photography, sharp focus from front to back, f/11 aperture, crisp details, zero digital noise]. [LIGHTING: three-point soft-diffuse lighting, 48-inch octagonal softbox key light at 45 degrees, gentle fill light, backlit soft ambient glow, no harsh glare, premium e-commerce product catalog style]."
Enter fullscreen mode Exit fullscreen mode

2. Tool execution and artifact rendering

Following the skill instructions, the agent automatically creates and issues a structured tool call to generate_image. The following is a mock representation of what that structured tool call would look like:

{
  "Prompt": "Professional studio product photograph of elegant floral arrangement of fresh seasonal blooms in a clear glass vase filled with crystal-clear water. SCENE: smooth matte light gray surface, seamless background curve with soft infinite horizon. CAMERA: macro lens photography, sharp focus, f/11 aperture, crisp details, zero digital noise. LIGHTING: three-point soft-diffuse lighting, 48-inch octagonal softbox key light at 45 degrees, gentle fill light, backlit soft ambient glow, premium e-commerce catalog style.",
  "ImageName": "mock_flower_plant",
  "AspectRatio": "1:1",
  "toolAction": "Generating floral arrangement mock product image",
  "toolSummary": "Generate mock flower product image"
}
Enter fullscreen mode Exit fullscreen mode

Note, not shown in this example but generate_image natively supports visual composition. Passing up to three absolute file paths into the ImagePaths array parameter instructs the agent to blend existing logos, background textures, or reference wireframes into composite graphics.

Upon receiving the generated image path from generate_image, the agent renders the asset immediately in chat:

![Mock Flower/Plant Product](file://<GENERATED_IMAGE_PATH>)
Enter fullscreen mode Exit fullscreen mode

3. Interactive review loop via ask_question

In my previous post, Elevating Antigravity Agent skills with interactive UI workflows, I established how to convert passive agents into active interviewers using the ask_question tool. By interrogating developers upfront, we eliminated prompt ambiguity.

Rather than assuming the generated asset is immediately production-ready, the agent prompts the developer using ask_question:

Invoke `ask_question` tool:
* Question: "What would you like to do with this generated mock image?"
* Options: ["Keep", "Regenerate", "Exit"]
Enter fullscreen mode Exit fullscreen mode

4. Workspace lifecycle and asset persistence

If the developer approves the asset, the agent copies the file from temporary artifact storage to <workspace>/public/images/<image_filename> and returns a clickable markdown link:

[mock_flower_plant.png](file://<WORKSPACE_ROOT>/public/images/mock_flower_plant.png)
Enter fullscreen mode Exit fullscreen mode

If the developer chooses to delete or regenerate, the agent purges the temporary artifact to prevent uncurated asset accumulation.

If your agent dumps uncurated artifacts directly into production asset paths, you aren't automating design, you're automating visual tech debt.

🎁 Bonus: Three anti-patterns in agent visual asset generation (and beyond)

As you integrate expensive tool calls, like generate_image into automated developer workflows, observe these three rules to maintain consistency and efficiency:

1. Avoid raw prompt injection

Avoid passing raw user inputs directly to generate_image. Build a prompt generator inside your skill that injects specific parameters (such as scene, lighting, camera, and style preferences) to ensure deterministic outputs across runs.

2. Avoid broken links

Use the absolute artifact path returned by generate_image and move approved images to a permanent location. Storing assets in temporary directories (/tmp) causes link decay when context windows clear or workspace sessions restart.

3. Avoid redundant calls

Before triggering generate_image, instruct your skill to check if a valid asset with the target ImageName already exists. Re-running image generation without parameter changes wastes compute budget and slows down workflow execution.

🚀 Builder Challenge: Take this workflow further!

Now that you have mastered parameterized image generation with generate_image, here is an engineering challenge to take your visual asset skills to the next level:

Build an Automated Multi-Aspect Ratio Asset Suite Generator.

Currently, our skill requires the user to include details in their prompt.

Your challenge:

  1. Extend your skill's prompt generator to accept target layout presets (e.g., Hero Banner, Product Card, Mobile Thumbnail) or aspect ratios (e.g. 1:1, 2:1, 4:3, 16:9) using the ask_question tool.

  2. Extend your skill's prompt generator to use pre-made reference images passed into generate_image using ImagePaths param. You can include up to 3 images.

Did you attempt the challenge? Share your skill's strategy in the comments below!

Conclusion

Static text descriptions and broken image icons belong to an earlier generation of developer tooling. By leveraging parameterized asset generation in generate_image, you empower your agents to produce clean, consistent and visually grounded technical artifacts.

Take 15 minutes today to audit your component scaffolding and asset generation skills.

📌 Elevating Antigravity Agent Skills Series Index

  • Part 1: Building interactive UI workflows with ask_question
  • Part 2: Automating Image Generation with generate_image (📍 You are here)
  • Part 3: Invoking Subagents with define_subagent, invoke_subagent
  • Part 4: Inter-Agent Communication with send_message
  • Part 5: Managing Active Agent Lifecycles with manage_subagents

Additional resources

Help others find this post

  • Save this post to find it later.
  • Subscribe to my newsletter and don't miss an article.
  • Share this article across social media.
  • Follow me on LinkedIn or X for more agentic engineering insights.

Thanks for reading!

Top comments (0)