Google Engineers Explain How to Use AI to Improve Software Development

In 2024, AI code writing has permeated all walks of life, profoundly affecting the entire life cycle of software. So the question is, AI code tools have used people say good, but why do we usually use the software does not feel much progress? Is it because we are using AI in the wrong way?

Recently, Addy Osmani, Google's head of engineering and an Amazon bestselling author, revealed to us what AI-assisted coding really looks like in frontline development, as he shared the challenges and opportunities that AI tools present in real-world development.

How do engineers use AI?

In general, there are two different models for teams to develop with AI: 'bootstrappers' and 'iterators'. Both models are helping engineers (and even users with weak technical backgrounds) to shorten the distance from idea to actual code.

Bootstrappers

This category includes AI tools such as Bolt, v0, and screenshot-to-code, which are characterized as:

• Start with a design drawing or rough concept;
• Use AI to generate a complete initial code base;
• Ability to get a working prototype in a few hours or days;
• Focused on quickly validating the feasibility of ideas

The workflow is impressive. For example, an independent developer can use Bolt to turn a Figma design into a working web application in no time at all. Not quite production level, but good enough to get initial user feedback.

Iterators

This category is primarily responsible for the day-to-day development workflow, including Cursor, Cline, Copilot and WindSurf Tools such as these are not as "flashy" as the above, but are more practical, for example:

• Automate code completion, provide code suggestions;
• Perform complex code refactoring tasks;
• Generate test code and documentation;
• "Twinning Programming Partners" as a solution to programming problems

While both methods can speed up development considerably, as the saying goes, "there's no such thing as a free lunch."

The Hidden Costs of "AI Speed"

Used by senior engineers Cursor maybe Copilot AI tools such as this can build the basic framework for an entire feature in minutes, complete with the appropriate tests and documentation - it's like magic.

But a closer look reveals that while referring to AI recommendations, senior engineers do the following:

• Refactor AI-generated code into smaller modules;
• Add handling of various extreme situations;
• Optimize type definition and interface design;
• Add comprehensive error handling mechanism;
• Even questioning the architectural solutions given by the AI.

In other words, they are applying years of accumulated engineering savvy to shape and limit the output of AI. AI is responsible for accelerating the implementation of the code, but human expertise ensures that the code is maintainable, and you can't have one without the other.

However, junior engineers tend to overlook these critical steps. They are more likely to accept the AI's output in its entirety, leading to what is known as "house of cards code" - something that looks complete on the surface but can easily fall apart under real-world stress.

intellectual paradox

So, in fact, AI is better at helping experienced developers than beginners -- which is somewhat counterintuitive.

Senior engineers use AI to quickly prototype ideas (to understand requirements), generate basic implementations (to facilitate subsequent improvements), explore alternative solutions to known problems, and more;

Instead, beginners often directly adopt incorrect or outdated solutions given by the AI, ignore critical security and performance issues, don't know how to debug the code generated by the AI, and end up building a fragile system they don't fully understand.

70% Question

Non-engineers who write code using AI often run into a frustrating dilemma: they can do 70% of work surprisingly quickly, but the last 30% of work is exceptionally painful.

The "70% Problem" reveals the current state of AI-assisted development, which starts out as if it's a godsend but then gets "rubbed in the face" by reality.

The reality is usually:

• Trying to fix a small bug -->
• AI proposes a seemingly reasonable change -->
• This change breaks the rest of the code -->
• Ask AI to fix emerging issues -->
• Two new bugs have been created -->
• infinite loop

This cycle is especially painful for non-engineers who lack the specialized knowledge to understand what really went wrong.

Experienced developers who encounter bugs can infer potential causes and solutions based on years of experience and pattern recognition. Without this background knowledge, you're basically "gophering" with code you don't fully understand, and the problems are endless.

learning paradox

There's also a deeper problem: giving non-engineers access to AI code-writing tools may actually hinder their learning.

The code is generated and runs, but the "developers" don't understand the underlying principles. They miss the opportunity to learn basic programming patterns, develop debugging skills, and reason about architectural decisions that will need to be maintained and extended in the future.

As a result, "developers" are constantly turning to AI to solve problems without developing the expertise to handle them on their own.

The best way for non-engineers to use AI code writing tools is probably "mixed mode":

1. Rapid Prototyping with AI
2. Take some time to understand how the generated code works
3. Learn basic programming concepts and how to use AI
4. Build your knowledge base step by step
5. Using AI as a learning tool, not just a code generator

But it takes patience and dedication, the opposite of what many people use AI tools for in the first place; they just want a quick fix.

The "70% problem" shows that current AI is not the "perfect AI" that many people expect. At the end of the day, 30%'s job (making software usable in a production environment, maintainable, etc.) still requires real engineering knowledge that can't be completely replaced by AI.

best practice

Addy Osmani, after observing dozens of teams, has summarized some of the best ways to practice:

• "AI first draft" model
  Let AI generate the basic implementation of the code; manually review and perform modular refactoring; add comprehensive error handling; write comprehensive test cases; and document key decisions.
• "Continuous Dialogue" model
  Start new AI conversations for each different task; keep the context focused and concise; review and commit changes often; and keep a tight feedback loop.
• "Trust but verify" model
  Use AI to generate initial code; manually review all critical paths; automate tests for various boundary cases; and conduct regular security audits.

The real future of AI?

Despite these challenges, the authors are optimistic about the role of AI in software development. The key is to capitalize on the true benefits of AI:

• Acceleration known
  AI excels at helping us realize patterns we already know, like a twinned programming partner with infinite patience and fast typing speed.
• Explore the possibilities
  AI is great for quickly prototyping ideas and exploring different approaches, like a sandbox in which we can quickly test concepts.
• automation routine
  AI dramatically reduces the amount of time we spend on sample code and everyday programming tasks, allowing us to focus on more interesting problems.

If you're just starting to experiment with AI-assisted development, the authors' advice is to start small: use AI for uncoupled, well-defined tasks, scrutinize every line of code you generate, and then gradually build larger features.

Maintain modularity in the development process: break everything down into small, well-focused documents, maintain clear interfaces between components, and document module boundaries.

The important point is to trust your own experience: AI is used to accelerate development, but it can't replace your judgment; be willing to question when something doesn't feel right; and always maintain your engineering standards.

Agent Emergence

The landscape of AI-assisted development is changing dramatically as we move into 2025. While current tools have changed the way we prototype and iterate, we are at the beginning of an even more important transformation: the rise of AI agent (Agent) software engineering.AI agents will not only be able to respond to commands, but will also be able to plan and execute solutions with an increasing degree of autonomy.

Anthropic, for example. Claude Have direct access to a computer, or Cline It is possible to launch the browser and run tests automatically.

During the debugging process, the AI agent not only suggests fixes for bugs, but also: proactively identifies potential issues, launches and runs test suites, examines UI elements and captures screenshots, suggests and implements fixes, and verifies that the solutions work.

The next generation of tools will be able to seamlessly integrate visual understanding (UI screenshots, models, diagrams), verbal language conversations, and environmental interactions (browsers, terminals, APIs).

The AI of the future is not about replacing developers, but about becoming an increasingly powerful collaborative partner that can take on tasks proactively while respecting human guidance and expertise.