Six months ago, I was skeptical about AI coding tools. Today, I use them daily. This shift didn't happen because AI got dramatically better—it happened because I finally understood what these tools actually are and, more importantly, what they're not.
Let's talk honestly about AI coding assistants, the anxiety they're causing among developers, and what this technology actually means for our careers.
The Elephant in the Room
Every developer I know in Nairobi has asked this question: "Will AI replace me?" It's a legitimate concern. When you see GitHub Copilot write entire functions from a comment, or watch ChatGPT debug code in seconds, the anxiety is real.
Here's what I've learned after months of using these tools: AI won't replace developers. But developers who use AI will replace developers who don't.
That's not a threat—it's an opportunity. Let me explain.
What AI Coding Tools Actually Do Well
Boilerplate Code Generation
This is where AI shines. Need a React component with state management? A CRUD API endpoint? Form validation? AI can generate the skeleton code almost instantly.
I recently built a dashboard that required about 15 similar components. Instead of copying and pasting code for an hour, I described what I needed to Copilot and had working templates in minutes. Did I need to review and modify them? Absolutely. But the time saved was massive.
Code Explanation and Learning
This is underrated. When I encounter unfamiliar code—maybe I'm working with a new library or maintaining legacy code—I can paste it into ChatGPT and get an explanation in plain English.
Last week, I had to work with a complex regex pattern in a project. Rather than spending 30 minutes decoding it, I asked ChatGPT to explain it. Two minutes later, I understood it completely and could modify it for my needs.
Debugging Assistance
Here's a real scenario from yesterday: I had a bug in a React component. The state wasn't updating correctly, and I couldn't figure out why. I described the issue to ChatGPT, pasted my code, and it immediately identified that I was mutating state directly instead of using the setter function.
Could I have found this myself? Yes, probably in 20-30 minutes of debugging. The AI found it in 30 seconds.
Documentation and Comments
Let's be honest: most developers (including me) hate writing documentation. AI is actually good at this. Point it at a function, and it can generate clear documentation explaining what it does, what parameters it takes, and what it returns.
What AI Coding Tools Do Poorly
Architecture Decisions
AI can't design your application architecture. It doesn't understand your business requirements, your scale considerations, or your team's capabilities. Should you use microservices or a monolith? What database fits your access patterns? These decisions require human judgment.
When I'm architecting a new project, AI is useless. These decisions come from experience, understanding trade-offs, and knowing the context that AI simply doesn't have.
Creative Problem Solving
Give AI a well-defined problem, and it does great. Give it a novel problem that requires creative thinking, and it struggles.
Recently, I needed to optimize a data-heavy dashboard for slow connections (a real issue in Kenya). The solution required understanding the user's context, creatively implementing progressive loading, and making UX trade-offs. AI couldn't do this—it required human creativity and contextual understanding.
Understanding Business Context
AI doesn't understand why you're building something. It doesn't know your users, your market, or your constraints. When a client asks for a feature, AI can't tell you if it's a good idea or suggest a better approach based on their actual needs.
Code Quality and Standards
AI-generated code often works but isn't always good code. It might be inefficient, insecure, or violate your team's coding standards. You still need to review, refactor, and improve it.
I've seen AI suggest code with security vulnerabilities, performance issues, and accessibility problems. A junior developer using AI without code review could ship major issues.
The Real Impact: Productivity, Not Replacement
After using AI tools for six months, my productivity has genuinely increased—I estimate by about 30-40%. But it hasn't made me a better developer. It's made me a faster developer.
There's a difference.
What I'm faster at:
- Writing boilerplate code
- Debugging syntax errors
- Learning new libraries
- Converting designs to code
- Writing tests
What I still need to be good at:
- Understanding requirements
- Designing solutions
- Making architectural decisions
- Code review and quality assurance
- Performance optimization
- Security considerations
- Team collaboration
- Problem decomposition
How I Actually Use AI Tools
GitHub Copilot
I have this enabled in VS Code. It's like pair programming with someone who's seen a lot of code but doesn't really understand your project.
I use it for:
- Auto-completing repetitive patterns
- Generating test cases
- Writing common functions (date formatting, data validation, etc.)
I don't blindly accept its suggestions. I read every line it proposes.
ChatGPT
This is my debugging partner and learning assistant.
I use it for:
- Explaining unfamiliar code
- Debugging specific issues
- Learning new concepts
- Generating example code for experiments
I don't use it to write production code wholesale. Every piece of AI-generated code goes through my review and testing.
My Workflow
- Understand the problem (human work)
- Design the solution (human work)
- Write critical logic myself (human work)
- Let AI help with boilerplate (AI + human review)
- Review and refactor (human work)
- Test thoroughly (human work)
Notice that the most important steps are still 100% human.
The Skills That Matter More Than Ever
With AI handling more of the routine coding, certain skills have become even more valuable:
Code Review
You need to be able to quickly assess if code is good, secure, and maintainable. This is critical when working with AI-generated code.
System Design
AI can't design systems. This skill is now more valuable because it's one of the things that genuinely separates senior developers from juniors.
Problem Decomposition
Breaking complex problems into smaller, solvable pieces is a skill AI doesn't have. The better you are at this, the better you can utilize AI for the individual pieces.
Communication
Understanding client needs, explaining technical concepts, collaborating with teams—these human skills are now differentiators.
Domain Knowledge
Understanding the problem space—whether it's fintech, e-commerce, or healthcare—is something AI doesn't have. This context is crucial for building the right solution.
For Junior Developers: A Warning and Opportunity
If you're a junior developer, AI is both a threat and an opportunity.
The threat: If your value is just writing basic CRUD operations and following tutorials, AI can do that. Companies might need fewer junior developers to do routine work.
The opportunity: AI can accelerate your learning dramatically. You can ask questions without feeling stupid. You can get explanations instantly. You can experiment faster.
But—and this is critical—you need to actually learn, not just copy-paste. Use AI to understand concepts, not to avoid understanding them.
Bad approach: "I need a login function" → paste AI code → deploy → move on
Good approach: "I need a login function" → ask AI for explanation → understand the approach → write it yourself → use AI to check your work
The Accessibility Angle
Here's something positive: AI is democratizing coding knowledge. In Kenya, where access to quality programming education can be limited, AI tools provide a form of mentorship that wasn't available before.
A student in Kisumu can get the same quality of code explanation as someone in Silicon Valley. That's powerful.
But it also means competition is increasing. Developers worldwide now have access to similar tools, so the bar for what's considered "good" is rising.
The Ethics Question
We need to talk about this: most AI coding tools were trained on publicly available code, including open-source projects. There are legitimate questions about whether this is fair use, especially when AI reproduces code nearly identically.
As developers, we need to be mindful:
- Review AI-generated code for potential license violations
- Don't assume AI-generated code is free to use commercially
- Be aware of your company's policies on AI-generated code
- Give credit where appropriate
Looking Forward: 2026 and Beyond
AI coding tools will keep improving. But I don't think they'll replace developers anytime soon. Here's why:
Software development isn't just about writing code—it's about solving problems. AI is a tool for writing code faster, but it's not a replacement for problem-solving skills.
The developers who thrive will be those who:
- Embrace AI as a productivity tool
- Focus on skills AI can't replicate (system design, architecture, communication)
- Maintain strong fundamentals (you can't review AI code if you don't understand it)
- Stay curious and keep learning
My Honest Take
Am I worried about AI? No. Am I adapting to it? Absolutely.
AI coding assistants are like calculators for math. Calculators didn't make mathematicians obsolete—they made them more productive and allowed them to focus on more complex problems.
Similarly, AI won't make developers obsolete. It will make us more productive and allow us to focus on harder, more interesting problems.
The developers who resist AI will be at a disadvantage. But the developers who blindly rely on AI without understanding what it produces will be equally disadvantaged.
The sweet spot is using AI as a powerful assistant while maintaining your skills and judgment.
Practical Recommendations
If you're not using AI tools yet:
- Start small: Try GitHub Copilot for a month (it has a free trial)
- Experiment with ChatGPT for debugging and learning
- Review everything: Never deploy AI-generated code without understanding it
- Learn from it: When AI suggests something, understand why it works
- Maintain fundamentals: Keep strengthening your core programming skills
If you're already using AI:
- Audit your usage: Are you learning or just copy-pasting?
- Set boundaries: Use AI for assistance, not replacement
- Focus on skills AI can't do: Architecture, system design, problem-solving
- Share knowledge: Help others learn to use these tools effectively
Final Thoughts
The future of software development will be human developers working alongside AI tools. Not humans alone. Not AI alone. Both together.
The developers who succeed will be those who can effectively leverage AI while bringing uniquely human skills to the table: creativity, empathy, contextual understanding, and strategic thinking.
So is AI a threat or a superpower? It's both, depending on how you approach it.
My advice? Learn to use it, but don't become dependent on it. Use it to get faster, but keep getting better.
Want to discuss how you're using AI in your development workflow? Get in touch. I'm always curious to hear how other developers are adapting to these tools.