Harnessing the Hype: A Pragmatic Guide to Using AI in Development
Artificial Intelligence is no longer a futuristic concept; it’s another part of our development toolbox. And like any powerful tool, it can be used to build incredible things with great efficiency, or it can create a mess that is difficult to untangle. The key isn’t just using AI; it’s using it with discipline and intent.
So, how can we leverage these powerful new tools without getting burned? Our teams have started developing a framework for interacting with AI, focusing on practices that produce results and establishing guardrails to avoid common pitfalls. This post outlines our current thinking.
Productive Practices (The Dos)
The most effective way to use AI is to treat it as an extremely capable junior developer. It has some basic knowledge, but it lacks context and deep experience. You are still the architect and the lead developer in this relationship.
- Plan First, Then Use AI. You would never ask a developer to start building without a plan, and the same applies to AI. Start with your own design and use AI to help fill in the gaps or explore alternatives. You want to use AI to accelerate your plan, not to create a plan for you.
- Provide Detailed Designs. The quality of AI output is directly proportional to the quality of your input. Provide detailed, structured prompts describing the task. A great practice we’ve found is to include mockups or data structures as context. Push the AI to ask you clarifying questions rather than letting it make assumptions.
- Leverage it for Rapid Iteration. AI is fantastic for tasks where the cost of being wrong is low. Use it to quickly prototype an idea or generate one-time-use code, like a Python script for a simple data conversion. If the output isn’t what you want, you can quickly abandon it and try another approach without losing much time.
Essential Guardrails (The Don’ts)
Understanding a tool’s limitations is just as important as knowing its strengths. An engineer who blindly trusts AI-generated code is abandoning their primary responsibility. Here are some of the hard lines we’ve drawn.
- Don’t Use AI for Architectural Decomposition. We have not had much success using AI for high-level architectural tasks, such as decomposing a system by its volatility. This kind of work requires a deep understanding of business context and long-term strategy that current AI models simply do not have. This MUST remain the responsibility of experienced architects and senior engineers.
- Don’t Commit Unverified Code. This is a critical rule. As the developer, you are accountable for every line of code that enters the codebase. If you cannot justify and explain the code that an AI tool generated, you MUST NOT commit it. Treat AI-generated code as if it came from a Stack Overflow post: a helpful starting point that requires rigorous testing and validation.
- Don’t Let Junior Developers Use it Unsupervised. Giving a junior developer an AI tool without strong mentorship and clear guidance is a recipe for disaster. Junior developers are still building the experience needed to spot plausible but fundamentally flawed code. Senior developers MUST pair with them, using AI as a teaching moment to review and critique the output.
The Path Forward
Ultimately, AI is an amplifier. It magnifies good development practices, like thorough planning and rigorous testing, just as easily as it magnifies sloppy ones. The challenge for us as engineering leaders is to ensure we’re amplifying the right behaviors.
You should approach these tools with the same engineering discipline you would any other part of your work. They are not a shortcut to bypass critical thinking; they are a tool to accelerate it. The developers who master this new skill will not only be more productive; they will become better engineers, using AI to test assumptions and explore solutions more rapidly than ever before.
