From Skepticism to Buy-In: Helping Developers Adopt AI

There’s no question about the impact that AI is having on the software development industry. We’re way past the hype phase, and it’s clear that AI can make developers and teams more productive with the right approach.

Skepticism still exists among developers, though, and rightly so.

If you’re responsible for a team of developers in any way, here’s a guide that’ll dramatically increase your chances of getting everyone on board while maintaining the quality of your product.

The Reason Developers May Be Skeptical

Developers aren’t necessarily skeptical due to fear or ignorance.

Writing code is a craft, and when you’ve spent a lot of time investing in this, loss of craftsmanship is one reason developers don’t want to hand control over to AI. Closely related to this is loss of control.

And what about the skills developers have spent years working on? Skill atrophy is another real concern: if we stop writing or even seeing code daily, will we forget how to write code? Again, this poses several follow-ups: do we even need to write code anymore, and do we need to continue to learn?

While it’s an incredibly exciting space, developers will have to mourn the loss of parts of their craft eventually, and that can be tough.

The Wrong Way to Introduce AI

Jumping in with “we’re now using AI!” without the right process in place is clearly the wrong approach.

You’re bound to fail if there’s no discussion of trade-offs (which there can be), workflow changes, or careful thought around guardrails. If everyone on a team suddenly “uses AI” without any planning in place, you’ll end up with a disjointed product that’s harder to maintain in the future. This is particularly difficult with remote teams or teams with multiple contractors.

Everyone needs to be onboard with the same plan.

You can’t expect immediate productivity gains until there’s a process in place. Simply throwing more code at a codebase doesn’t work. In fact, it usually makes things worse.

Reframing AI: From Replacement to Lever

It’s easy to think of AI as just a code generator, but it’s much more than that.

AI is also:

• A partner to discuss ideas with

• A draft generator if you don’t know how to start

• A code reviewer

Developers have a unique ability to understand problems, formulate solutions, guide systems, architect for the future, all of which are still required to steer AI towards building something solid.

So, you can frame AI as something to help:

• Increase productivity by handling the boring stuff

• Bouncing ideas around

• Quickly generating prototypes

• Helping task initiation paralysis with initial feature drafts

• Getting a code review locally before pushing up to source control

A good developer using AI correctly will always be more productive than a developer who doesn’t.

Start With Friction, Not Features

There’s plenty of friction in software development, and developers are historically pretty good at removing this friction through various methods, but AI brings this to a whole new level.

If you start by framing AI as something that can remove friction, you’ve already sold it. As long as it’s done properly, AI can tackle writing documentation, speeding up code reviews, write comprehensive tests, generating dummy data, and more.

Building features with AI is only part of its usefulness, so start with something else.

Ask your developers what frustrates them most about their daily work and help them adopt AI to ease these frustrations one by one.

Introduce Guardrails First

Not all teams value guardrails. Code quality issues, inconsistency and lack of testing all existed way before AI.

Before your team adopts AI, you need the basics in place. If you’re currently struggling with product quality, AI will compound that, and make your product worse.

The basic guardrails I’d recommend being in place before adopting AI are:

• Linting (the process of ensuring code is formatted consistently)

• Static analysis (automatically checking code for potential bugs, type errors, and unsafe patterns without running it)

• Testing (ideally automated, but at the very least a manual QA testing process)

• Clearly defined feature specs

• Ensuring key decisions like product architecture, standards and philosophy are documented

Once these are in place and everyone appreciates their importance, a team will feel more comfortable letting AI start to take over. Even then, it’s important to frequently monitor these basic guardrails and adjust if needed.

Teach Workflows, Not Prompts

Workflows are the most important knowledge investment when it comes to AI.

Allow your team to brush up on these skills through courses or other resources, and they’ll make a much bigger impact than focusing on how to prompt or use the latest techniques (which are usually short lived).

Workflows teach a developer how to ship features safely, fix bugs and performance issues quickly, or even build entirely new products. Prompts alone can’t do that.

Measure Confidence, Not Just Speed

Everyone wants to ship faster, but shipping faster doesn’t mean your team is confident in what they’re shipping.

It’s actually quite easy to measure confidence once AI is writing code:

• Are we introducing more bugs?

• Are code reviews taking longer?

• Is the product slower?

• Is the code getting harder to reason about?

Code reviews are particularly useful at determining the confidence of shipping. Developers will instantly pick up on huge pull requests (a red flag), bad architecture and inconsistent patterns, all of which AI will do if not used correctly.

If you carefully measure just a few of these, you’ll be able to either slow down, adjust or ramp up AI use. If developers can ship quality code consistently, you’re nearly there.

From Skeptic to Advocate: The Tipping Point

It can take time to realise this, but most developers flip when they see how useful AI can be while still enjoying their craft. AI in software development is a brand new skill, and for some developers this process is as exciting as when they first started learning to code.

AI can save developers time, catch something they missed before pushing code, help them start a feature they didn’t think they could handle, or ship entire products on their own.

It’s perfectly reasonable to be skeptical about AI in software development, but it’s clearly here to stay. Teams that approach it carefully will benefit the most.

(Yes, in case you were wondering, I’m a developer and AI skeptic turned advocate).