What Is Gemini 3.7 Flash? I Tested Its Design Capabilities

Google has introduced Gemini 3.7 Flash, a model positioned around fast agentic workflows, coding, and increasingly capable UI generation. Marketing claims are easy to make — what matters is how the model performs on a real product.

I tested it inside an agentic development environment on an actual application redesign, and the results revealed something more important than the model itself: AI-generated design quality depends heavily on context, constraints, and prompting.

The First Test: Redesigning an Existing Application

For the first test, I gave the agent an application that had already been built and asked it to modernize the UI.

The redesign was fast — roughly ten minutes, using only a small portion of the available usage budget. But the final result wasn't particularly impressive.

The problem wasn't necessarily the model's design capability. The application already had an established design system — its own colors, spacing, component patterns, visual language. Instead of challenging that system, the model largely inherited and extended what already existed.

That produced a cleaner version of the existing interface, not a genuinely new design direction.

The lesson: if you ask an AI agent to redesign an existing application while keeping its current architecture and design system, the model will usually optimize within those constraints. That's useful when you want consistency. It's less useful when you want creative exploration.

If you want the model to propose something significantly different, you need to explicitly give it permission to reconsider the visual direction.

The Second Test: Building From Scratch

The second experiment was more interesting. Instead of an existing application, I started with an empty project and asked the agent to build a modern resume generator — with instructions to ask questions whenever it needed clarification.

That single instruction changed the interaction significantly. Instead of immediately generating a random interface, the agent asked about:

• Visual theme
• Resume structure
• Template style
• User experience
• Design preferences
• How the generated resume should be presented

It presented options instead of forcing a single interpretation. That's an important characteristic of a good agentic workflow.

Don't Let the Model Guess When You Can Make It Clarify

A coding agent shouldn't always try to solve an ambiguous requirement immediately.

Take a request like "build me a modern resume generator." There are hundreds of possible interpretations:

• Minimal or highly visual?
• Light or dark?
• Professional or creative?
• Single-page or multi-page?
• ATS-focused or portfolio-oriented?
• Template-driven or fully customizable?

A strong agent reduces this uncertainty by asking targeted questions before implementation, rather than committing to one interpretation and hoping it lands.

The First Design Wasn't Good Enough

The first version used a glassmorphism-inspired visual direction. Personally, I didn't like it.

Instead of accepting the first output, I asked the agent to return to the alternative directions it had proposed earlier. The second version was much better — a cleaner light theme, a more practical interface, and useful interactions including:

• Customizable colors
• Live resume preview
• Zoom controls
• Editing
• Sharing
• Template-oriented workflows

This is where AI-assisted design gets interesting: the model wasn't generating a static screenshot, it was generating a functional interface with real interaction logic behind it.

That distinction matters. A beautiful mockup is easy to appreciate. A production-quality interface needs to be usable, responsive, accessible, consistent, maintainable, performant, secure, and actually functional.

The Biggest Lesson: Your Prompt Matters

After testing both approaches, the biggest takeaway wasn't that Gemini 3.7 Flash can generate good UI.

It was that the quality of the specification strongly influences the quality of the result.

A vague prompt gives the model too much freedom in the wrong places. A well-structured prompt gives it enough context to make better engineering and design decisions. Three practices worth adopting:

1. Don't Write the Design Prompt Blindly

You can use another AI model to help build the specification your coding agent will actually execute, instead of jumping straight to "make this application look modern."

For example, ask an assistant to help draft a detailed UI/UX and engineering specification covering visual direction, typography, color system, spacing, component hierarchy, responsive behavior, accessibility requirements, interactions, empty states, loading states, error states, edge cases, mobile behavior, and animation guidelines — without writing implementation code.

That creates a useful separation:

Idea → Specification → Implementation

rather than:

Idea → AI generates everything

That distinction gets more important as projects grow.

2. Start From Scratch When You Want Creative Exploration

If the goal is exploring genuinely different design directions, starting from a blank project usually beats asking an agent to modify an established interface.

An existing project comes with constraints. Those constraints are valuable for production work, but they can also limit exploration. A better workflow:

Explore
   ↓
Generate multiple directions
   ↓
Choose one
   ↓
Create design system
   ↓
Implement
   ↓
Review
   ↓
Iterate

This mirrors how a human product team might work — the AI becomes a design exploration partner rather than just a code generator.

3. Tell the Agent to Ask Questions

One of the simplest improvements to an AI coding prompt: instruct it to ask clarifying questions before implementation rather than making major product or UX assumptions, with particular attention to edge cases, user flows, responsive behavior, permissions, empty states, error states, validation, and accessibility.

That shifts the agent's posture from "I need to produce code immediately" to "I need to understand the requirements before producing code" — a major difference for real software projects.

AI Design Has a Common Failure Mode

One of the biggest mistakes developers make with AI-generated interfaces is judging the result only from the first visual impression.

A UI can look impressive while still having serious problems underneath:

• Visual quality — does it look good?
• UX quality — can users understand what to do?
• Engineering quality — is the implementation maintainable?
• Accessibility — can users with different abilities interact with it?
• Performance — does it stay responsive on slower devices?
• Reliability — what happens when an API fails?
• Security — are user-generated documents, uploads, and sharing links handled safely?
• Responsive behavior — does it still work properly on mobile?

A production UI needs all of these — not just attractive colors and animations.

Gemini 3.7 Flash vs Other Coding Agents

Is Gemini 3.7 Flash automatically better than Claude or Codex? Not necessarily — it depends heavily on the task.

For UI exploration and rapid prototyping, this experiment's results were promising. But comparing AI coding systems properly requires more than looking at one generated interface. You'd need to evaluate:

Capability	What to evaluate
UI generation	Visual quality and consistency
Coding	Correctness and maintainability
Reasoning	Handling complex requirements
Agentic execution	Tool use and task planning
Debugging	Ability to identify and fix failures
Refactoring	Preserving behavior while improving code
Context handling	Working with large existing codebases
Testing	Creating and maintaining meaningful tests
Security	Avoiding unsafe implementation patterns
Speed	Time-to-working-feature

A model that produces a beautiful landing page isn't necessarily the best model for maintaining a large production codebase.

What Is Google Antigravity?

Google Antigravity is an agent-oriented development environment built around AI-assisted software development and Gemini models.

The interesting part isn't the editor itself — it's the agentic workflow. Instead of manually writing every file, you give the agent a higher-level task and let it understand the project, plan the implementation, modify files, run commands, inspect results, iterate, and fix problems.

That moves AI coding closer to software engineering orchestration than simple autocomplete. But developers still need to review the generated work — an agent can make technically valid changes that are still wrong for the product.

The Future of AI-Assisted Design

AI-generated UI is moving beyond simple code completion. The workflow is increasingly:

Natural language
      ↓
Product requirements
      ↓
Design exploration
      ↓
Component generation
      ↓
Implementation
      ↓
Testing
      ↓
Iteration

This doesn't make designers and software engineers unnecessary — it changes where their time goes. Instead of manually building every component, engineers can spend more time on architecture, product decisions, security, performance, accessibility, data modeling, testing, reliability, user experience, and code review.

AI can accelerate implementation, but engineering judgment remains the bottleneck.

Conclusion

Gemini 3.7 Flash showed promising results in this experiment, especially when starting from scratch and allowing the agent to ask clarifying questions.

But the biggest lesson wasn't "this AI makes amazing designs." It was: better context produces better AI output.

If you want creative results, give the model room to explore. If you want consistent results, give it a strong design system. If the requirements are ambiguous, let it ask questions.

And if you're building production software, don't stop at visual quality. Review the generated system for architecture, security, accessibility, performance, testing, and maintainability. AI can generate the interface — you're still responsible for the system underneath it.