A Manager’s Guide to Sustainable AI-Powered Development

Sep 23, 2025 · 6 mins read

Artificial Intelligence is no longer a futuristic concept; it’s a daily tool in our development workflow. The promise is exhilarating: team members, regardless of their technical background, can now create functional applications with a few well-phrased prompts. This new capability can unlock unprecedented speed and innovation.

But what happens after the initial “wow” moment? What happens when the AI-generated prototype needs to evolve into a scalable, maintainable product?

Recently, our team encountered a project that served as a powerful lesson. It was built entirely by a non-technical individual using AI coding assistants. On the surface, it was an impressive achievement, a working first version that accomplished its core task. However, when our developers stepped in to make improvements and fix bugs, they discovered a different story.

The codebase was tricky to maintain. Hidden issues lurked beneath the surface: inconsistent data, duplicate entries created by flawed logic, and a confusing structure filled with unused test scripts and hardcoded values. While the AI had successfully executed a series of commands, it lacked the architectural foresight of an experienced developer.

The project couldn’t scale. To move forward, a significant portion had to be rewritten, applying consistent engineering standards. This experience highlighted a critical challenge for every manager today: How do we empower our teams to use AI without accumulating massive technical debt?

Based on our internal discussions and experiences, we’ve developed a framework for guiding teams toward a more strategic and sustainable use of AI.

1. Prioritise Planning Over Prompting

The biggest pitfall of using AI is the temptation to jump straight to a solution. The “dopamine hit” of seeing code magically appear can cause teams to bypass the most critical phase of development: planning.

We encourage our teams to use AI not as a code generator, but as a thinking partner. Instead of asking, “Write code that does X,” start by asking, “Let’s plan how to build X.”

The “plan mode” approach involves a back-and-forth dialogue with the AI. Describe the goal, the constraints, and the existing context. A great practical tip is to end your initial prompt with, “Ask me clarifying questions before you propose a solution.” You’ll be surprised by the blind spots the AI can help you uncover. This collaborative planning phase ensures the final approach is sound before a single line of code is written.

2. Focus on the ‘What,’ Not the ‘How’

Managers should guide their teams to describe the problem, not prescribe the implementation. When we approach an AI with a rigid idea of how something should be built, e.g.: “Use this specific library to build this specific function”, we limit its potential.

By focusing on the “what” (the goal) and the “why” (the context), we allow the AI to suggest more creative or efficient solutions we may not have considered. It can propose better architectures, alternative tools, or simpler paths to the same goal. The true power of these models lies in their ability to explore the solution space, but only if we give them the freedom to do so.

3. Foster a Learning Mindset, Not a Black Box Mentality

AI should be a tool for upskilling, not just for output. When a team member, regardless of their technical experience, uses AI to generate code, they should be encouraged to understand what’s being produced.

This means taking the time to learn the basics of the programming language, the data structures being used, and the overall architecture. AI can be an incredible tutor if prompted correctly (“Explain this code to me,” “What are the trade-offs of this approach?”). A team that learns as it builds is a team that will eventually outgrow its reliance on AI for simple tasks and begin using it for more complex, strategic challenges.

4. Implement a Human Review Process

This is non-negotiable for any AI-generated code that will become part of a real product. Things might appear to work, but without a knowledgeable eye, you risk building on a shaky foundation.

Just as we use pull requests for human-written code, we must apply the same rigour to AI-generated code. Having a developer review the output ensures that it adheres to best practices, is maintainable, and doesn’t introduce subtle, hard-to-find bugs. This simple step is the most effective safeguard against the kind of unscalable mess we encountered.

A Tiered Approach to AI Use

Not all tasks are created equal. We’ve found it helpful to think about AI assistance in three tiers:

• Simple Tasks: For small, self-contained fixes or boilerplate code, a “one-shot” prompt is often sufficient. The developer has full context and can easily verify the output.
• Medium Tasks: For building a new feature or refactoring a component, a thorough, well-structured prompt is key. This might involve a brief planning session before letting the AI generate the code.
• Hard Tasks: For complex architectural changes or tackling brand-new problems, the process should be almost entirely dialogue-based. Use the AI to brainstorm, debate trade-offs, and map out a comprehensive plan. In many cases, an experienced developer will then implement the plan themselves, using the AI as a consultant rather than the coder.

AI is a revolutionary tool that is fundamentally changing how we build software. The most successful teams will be those that embrace AI’s power while respecting the fundamental principles of good software development. By fostering a culture of planning, continuous learning, and collaborative review, we can guide our teams to use AI to build better, smarter, and more sustainable products for the future. We can empower our entire team to build not just quickly, but wisely.