Managing AI in Software Development: How to Guide Non-Technical Colleagues Who Want to Write Code

As AI tools continue to make waves in the software development world, many non-technical colleagues—such as product managers (PMs) and designers—are eager to jump on the bandwagon and explore how they can use these tools to write code.

With the promise of simplifying the development process, particularly for creating UI components or prototypes, it’s no surprise that non-developers see these AI tools as a shortcut to rapid product development.

However, as any experienced software engineer knows, writing high-quality, maintainable code is far more complex than generating simple UI elements with AI.

When these discussions arise, it can be difficult to know how to respond, especially when non-technical peers are keen on using AI tools in the development process.

Recently, a software engineer posed this very question on Reddit, seeking advice on how to handle non-technical colleagues eager to use AI to write code for UI components. In the ensuing discussion, experienced developers shared valuable insights on how to address this growing concern.

In this article, we’ll explore the key takeaways from that conversation, offering a balanced approach to managing these discussions with non-technical staff while ensuring that AI tools are used appropriately in the development process.

The Context: Non-Tech Colleagues Eager to Use AI for Code

The question that sparked the Reddit discussion came from a software engineer grappling with non-technical peers who wanted to experiment with AI tools for writing code, particularly UI components.

Many non-developers are increasingly exposed to marketing materials that promise AI-generated code as an easy way to streamline development. While these tools can indeed simplify tasks such as creating landing pages or basic UI components, they also raise concerns about code quality, integration with existing systems, and the overall complexity of software development.

The software engineer sought advice on how to engage in these conversations and push back against the idea that non-technical team members could take on development tasks, even in the early stages of a project.

Their concern wasn’t that AI tools are entirely useless—after all, AI can generate simple UI components—but rather that relying too heavily on these tools without proper understanding could lead to poor-quality code, missed opportunities for collaboration, and future technical debt.

The Consensus: Let Them Try, but Ensure Proper Code Review

One of the most common pieces of advice shared by experienced developers in the Reddit thread was to let non-technical colleagues try using AI tools, but with the understanding that any code they generate will need to go through thorough code reviews. This approach is rooted in the idea that experience is often the best teacher—especially when it comes to understanding the complexities of software development.

1. Let Non-Tech Colleagues Gain Firsthand Experience

The key benefit of allowing PMs or designers to try AI tools themselves is that it gives them a hands-on experience of the challenges developers face daily. By experimenting with these tools, non-technical team members may begin to appreciate the difficulties involved in writing good, maintainable code. For example, even if they can generate a simple UI component, they may quickly run into problems when the component needs to interact with the broader application or integrate with other systems.

When non-technical peers attempt to use AI tools in a real-world scenario, they may run into issues like:

• Poor Code Quality: AI-generated code is often rough, inefficient, or not up to the standards expected in a production environment.
• Integration Problems: Without understanding the larger codebase, non-technical users might produce code that doesn’t fit well with existing patterns or frameworks, resulting in broken functionality.
• Maintenance Challenges: Even if the code appears to work initially, its lack of proper structure or documentation can make future changes or debugging difficult.

This hands-on experimentation can be an enlightening experience for non-technical colleagues, helping them realize the depth of expertise required to produce high-quality software.

2. Establish a Robust Code Review Process

While letting non-technical colleagues experiment with AI-generated code can be a great learning opportunity, it’s critical that their contributions are subjected to thorough code reviews. As experienced developers pointed out, AI tools are unlikely to produce production-ready code, especially when it comes to integration, debugging, or solving business-specific problems.

Code reviews are an essential part of maintaining the quality of any software project. They ensure that all code—regardless of its origin—meets the team’s standards, integrates well with the rest of the application, and avoids introducing bugs or inefficiencies. When non-technical colleagues contribute AI-generated code, it’s crucial that this code goes through the same rigorous review process as any other developer-written code.

In practice, this might look like:

• Assessing Code Quality: Reviewing whether the code adheres to coding standards, is efficient, and is easy to maintain.
• Ensuring Proper Integration: Ensuring the AI-generated code integrates well with the existing codebase and works within the context of the larger project.
• Identifying Potential Issues: Spotting bugs, inefficiencies, or potential security risks in the AI-generated code before it reaches production.

By treating AI-generated code like any other contribution, you can prevent the project from suffering due to low-quality or poorly integrated code while still allowing your non-technical peers to experiment with AI tools.

The Bigger Picture: Collaboration and Learning

The overarching theme in the Reddit discussion was that AI tools can play a valuable role in collaboration between technical and non-technical team members. Instead of viewing AI as a threat to developers, the conversation shifted to how these tools can be used to enhance teamwork and accelerate certain aspects of the development process.

For instance, AI tools can be an excellent way for non-technical team members to prototype quickly or create simple UI elements without waiting for developers to implement them. This can speed up the design and iteration process and help non-technical colleagues see their ideas come to life more rapidly.

However, it’s essential to remember that AI tools are not a substitute for the deep technical expertise that developers bring to the table. Developers are responsible for ensuring that code is scalable, maintainable, and well-integrated with the broader system. AI tools may help with the initial stages of development, but developers remain essential for ensuring the long-term success of a project.

Conclusion: A Pragmatic Approach to AI in Development

The key takeaway from the Reddit discussion is a balanced approach to incorporating AI tools into the development process. While non-technical colleagues may want to experiment with these tools, developers should set clear expectations about the limitations of AI-generated code. Allowing non-technical peers to try their hand at writing code with AI can be a valuable learning experience, but it’s crucial to ensure that all code—whether written by a developer or generated by AI—undergoes thorough review before being integrated into the product.

By fostering a collaborative environment where AI tools are used to complement, rather than replace, developers’ expertise, teams can take advantage of the speed and efficiency AI offers while maintaining high standards of code quality and long-term maintainability. This balanced approach will help teams navigate the evolving landscape of AI in software development while ensuring that their products remain robust, scalable, and successful.