Kayode Faturoti is an internet entrepreneur and co-founder of Liners, Breet, Cardtonic, Stack Directory, and Homevy.
A good software developer using AI resembles Iron Man in his suit. The machine provides speed and strength, but the person inside still chooses the destination.
That distinction matters because code output alone no longer defines a developer’s value. Today’s AI models can generate code in more languages than most developers will use. They can suggest libraries, compare implementations and draft tests before a person has finished a first version.
However, software development requires more than code. Teams need people who understand the system, spot missing context and take responsibility for what reaches production. Developers with those skills can use AI to extend their reach.
I use coding models often and have found that the biggest gains come when developers understand the models’ common failure points and give them work they can assess. Here are four practices that work for me and may work for you.
1. Know enough to challenge the model.
AI can produce a technically valid solution that’s wrong for a specific system. It may add an abstraction the team doesn’t need, miss a constraint buried in an old decision or optimize a part of the application that causes few problems.
An experienced developer recognizes those mistakes. They can tell the model, “This works, but it’s wrong for our architecture.” They can provide business rules and technical history that didn’t appear in the prompt. They can also reject an elaborate answer when 10 clear lines of code will solve the problem.
Your knowledge doesn’t need to match AI’s speed or volume. Your job is to give the model direction. The clearer your mental model of the system is, the more useful the assistant becomes.
2. Remove repetitive work without removing thought.
Skilled developers don’t prove their competence by typing every line themselves. Let AI draft repetitive code and tests, explain unfamiliar modules and compare possible implementations.
Use the saved time for decisions that require judgment. Examine how a feature affects the rest of the system. Ask what happens when a dependency times out, a user submits the same action twice or an old client calls a new API. Consider how a rollback will work after the new version has already written data.
AI gives developers time to compare more options before they commit to one. Developers can use it to trace failures across unfamiliar code. Security engineers can ask it to challenge a design before an attacker finds its weakness.
The model handles more of the searching and typing. The developer focuses on the consequences.
3. Use AI as a critic.
Many developers ask AI for an answer and accept its first response. Strong developers also ask it to challenge that answer.
Before implementation, I ask the model to list its assumptions and identify missing information. I request a simpler option and a safer option and then compare the trade-offs. After implementation, I ask it to find failure scenarios, concurrency problems and gaps in the tests. I treat its output as another reviewer’s perspective, not as a verdict.
The model may identify a real risk, but it may also invent a risk that doesn’t apply. Engineering judgment must decide which is which.
A short routine makes this process repeatable:
• Describe the problem and its constraints in your own words.
• Ask for two approaches and the risks of each.
• Choose an approach and review every meaningful change.
• Add at least one test for a risk you identified yourself.
This routine keeps the developer in control.
4. Take responsibility for the result.
AI assistants make mistakes. Whether or not a tool can open a pull request or trigger a deployment, accountability remains with the developer and the team.
The model may misunderstand the task or introduce a subtle bug. If you provide poor context, accept its first response and ship the result without a proper review, you still own the outcome. Code submitted under your name remains your responsibility, regardless of who or what typed it.
Strong developers delegate code production, not accountability. They review the changes, test the edge cases and make sure they can explain each decision to a colleague. If a change causes an incident, they investigate it instead of blaming the tool.
AI gives strong developers more reach. It helps them test more ideas, inspect more code and spend less time on mechanical tasks. Their advantage comes from the knowledge and responsibility they bring to the work.
As AI writes more code, developer judgment becomes more valuable, not less.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
