Will AI Replace Software Engineers Before You Finish Learning? An Honest Take

No. AI will not replace software engineers before you finish learning. It will not replace them after you finish learning either. But it will replace certain kinds of software work, and if you are not deliberate about which skills you build, you could end up trained for the part of the profession that is shrinking.

That is the real risk. Not that software engineering disappears. That you spend months learning the wrong slice of it.

Here is the short version of why the job survives: software engineering has never been primarily about typing code into a file. It is about understanding what needs to be built, why, for whom, under what constraints, and then making thousands of small decisions that no specification document captures. AI can generate code. It cannot decide what code should exist.

And here is the part most "will AI replace developers" articles miss: AI tools are not neutral. They have biases baked into their training data. They default to Western infrastructure, Western assumptions, and Western user patterns. If you are building software for African markets, AI is a powerful assistant that does not understand your users, your payment systems, or your connectivity constraints. That makes you more essential, not less.

The rest of this article breaks down exactly what AI can do, what it cannot, why African-market developers have a structural advantage, and what you should actually do about all of this.

Honesty requires acknowledging that AI code generation has gotten genuinely good at specific tasks. Pretending otherwise would insult your intelligence. Here is what current AI tools (Copilot, Claude, Cursor, ChatGPT) handle well:

• Boilerplate generation. Standard CRUD endpoints, form components, configuration files, Docker setups, CI/CD pipelines. If the pattern exists in thousands of open-source repos, AI reproduces it quickly and accurately.
• Code translation. Converting a Python function to JavaScript, migrating a REST endpoint to GraphQL, or porting CSS to Tailwind. When the logic is straightforward, AI handles the mechanical conversion.
• Simple feature implementation. "Add a search bar that filters this list by name." "Create a login form with email and password validation." These are well-defined, self-contained tasks. AI produces working code on the first or second attempt.
• Test generation. Given existing code with clear inputs and outputs, AI writes unit tests competently. It is particularly good at generating edge-case tests that a tired developer might skip.
• Documentation and explanation. AI explains code, writes docstrings, generates README content, and summarises pull requests. This is one of its strongest applications.
• Rapid prototyping. Spinning up a working proof-of-concept in minutes instead of hours. For exploring ideas and testing assumptions, AI is genuinely useful.

None of this is trivial. A developer using these tools well ships faster than one who refuses to use them. The productivity gain is real, and it is why AI coding tools have been adopted faster than almost any previous developer tooling.

But notice the pattern in everything listed above: these are all tasks with clear inputs, well-known patterns, and limited context. The moment any of those three conditions breaks down, AI starts struggling. And in real software engineering, all three break down constantly.

This is where the "AI replaces engineers" narrative falls apart. Software engineering is mostly the work that happens around the code, and AI is bad at nearly all of it.

Understanding local market context

Ask an AI to build a payment integration and it will give you Stripe. Every time. It does not know that your users in Nairobi pay with M-Pesa, that your users in Lagos prefer Paystack, or that your users in Kampala split between MTN Mobile Money and Airtel Money. It does not know that "payment" in many African markets means a USSD prompt on a feature phone, not a credit card form in a browser. Market context is not in the training data. It lives in the heads of developers who have built for these users.

Integrating complex African payment systems

M-Pesa's Daraja API has quirks that AI consistently gets wrong. The OAuth token flow, the STK Push callback validation, the passkey generation format, the reconciliation patterns for handling timeouts when Safaricom's servers are slow. We see AI-generated Daraja code that compiles, passes a syntax check, and breaks the moment real money touches it. The same applies to Africa's Talking USSD session management, Paystack webhook verification for Nigerian Naira transactions, and Airtel Money's disbursement API. The training data for these systems is thin compared to Stripe's mountain of Stack Overflow answers and blog posts.

Debugging production failures across system boundaries

Your M-Pesa webhook stopped firing. Is it your server? Safaricom's callback infrastructure? A firewall rule your hosting provider changed? A certificate expiry on the callback URL? A rate limit you hit because your retry logic is too aggressive? This kind of debugging requires understanding multiple systems, their failure modes, and how they interact. AI can suggest possibilities. It cannot methodically trace the actual cause across systems it has no visibility into.

Building for USSD on 2G

USSD applications have strict constraints: 182-character screen limits, session timeouts, no back button (on most carriers), and users on devices with no internet connection. AI generates USSD menus that look correct but violate carrier-specific character limits, mishandle session state across multiple screens, and assume connectivity patterns that do not exist. Building good USSD requires understanding the user, the device, and the carrier. AI understands none of those.

Handling cultural and regulatory nuance

Kenya's eTIMS tax compliance system, Nigeria's data residency requirements, Rwanda's electronic billing mandates. These are local, recent, and poorly documented in the English-language codebases AI was trained on. A developer who has implemented eTIMS integration knows the edge cases. AI hallucinates them.

Talking to a client who does not know what they want

Half of software engineering is translating "I want an app for my business" into something buildable. The client does not know what a database is. They do not know what an API is. They have a vague idea and a budget. Turning that into a working product requires empathy, patience, clarifying questions, and the ability to say "that will cost three times your budget, but here is what we can do instead." AI cannot have that conversation.

The pattern: AI is strong where the problem is well-defined and the solution is well-known. Software engineering lives in the space where problems are ambiguous and solutions depend on context. That gap is not closing any time soon.

Here is the thesis, stated plainly: AI tools default to Western tooling and assumptions. They suggest Stripe, not M-Pesa. They generate English UIs, not USSD menus. They assume reliable broadband, not intermittent 3G. A developer who pairs local-market skill with AI fluency is made more valuable by AI, not replaced by it.

We call this local-market skill "the African Stack." It includes:

• M-Pesa and mobile money integration (Safaricom Daraja, Airtel Money, MTN MoMo)
• USSD application development via Africa's Talking and carrier-specific APIs
• WhatsApp Business API for customer service, order management, and lead capture in markets where WhatsApp is the primary communication channel
• Low-bandwidth architecture for users on 2G/3G connections with intermittent connectivity
• Local compliance like Kenya's eTIMS, Nigeria's data residency laws, and mobile money regulation

The argument is not "AI is bad" or "African developers are special because they are African." The argument is structural: AI models learn from existing code, and the existing code for African market infrastructure is a fraction of the volume that exists for Western systems. Stripe has millions of integration examples in public repos, blog posts, and documentation. M-Pesa's Daraja API has a few thousand, many of them outdated or incomplete.

That training data gap means AI produces confident, plausible, and wrong code for African integrations. A developer who knows the real patterns can use AI to speed up the generic parts (React components, Node.js server setup, database queries) and then handle the African Stack parts with genuine expertise that AI cannot replicate.

This is not a temporary advantage that disappears when AI "catches up." New African fintech APIs launch regularly. Mobile money providers update their systems. Regulators introduce new compliance requirements. The African Stack is a moving target, and it moves faster than AI training data can follow. The developer who stays current with these systems maintains their edge indefinitely.

Consider a concrete example. A Nairobi-based startup needs a checkout system that accepts M-Pesa, handles STK Push timeouts gracefully, sends WhatsApp order confirmations, and falls back to SMS for users without WhatsApp. An AI tool given that prompt will produce something. A developer who has actually built and maintained that system in production knows the fifteen things the AI will get wrong: the timeout handling, the callback retry logic, the WhatsApp template approval process, the SMS cost optimization for bulk sends via Africa's Talking. That developer uses AI to write the Express server boilerplate in ten minutes and then spends their real expertise on the parts that actually matter.

That developer is not threatened by AI. They are amplified by it.

The honest answer includes acknowledging that some developers are at risk. Here is the profile of the developer who should be worried:

The generic CRUD developer. Their entire job is taking a specification that says "create a user table with these fields, expose these endpoints, add basic authentication" and writing that code. They work with well-documented Western APIs. Their code follows patterns that exist in thousands of tutorials. They do not talk to users. They do not make product decisions. They do not debug complex production failures because their systems are simple enough that failures are straightforward.

AI does that job now. Not perfectly, but well enough that a senior developer with AI tools can produce the same output without a junior handling the implementation. That is real, and it is already happening at companies that previously hired large teams of implementation-focused developers.

Notice what makes this developer vulnerable: their skills are entirely replicable by pattern matching. Everything they know, AI also knows, because they learned from the same tutorials and documentation that AI was trained on.

Now compare that to a developer who:

• Understands M-Pesa's STK Push flow well enough to debug why a callback is failing at 2 AM when a client's payment system goes down
• Can build a USSD menu that works on every major Kenyan carrier and handles session edge cases gracefully
• Knows that WhatsApp Business API template messages need pre-approval and plans the notification architecture around that constraint
• Has opinions about how to architect a system for users who lose connectivity mid-transaction
• Uses AI to generate boilerplate, write tests, and draft documentation, saving hours every week on the mechanical parts of the job

That second developer is not replaceable by AI. They are the person who directs AI. Their market-specific knowledge and system-level thinking are the things AI cannot do, and the AI tools make their existing expertise more productive.

The takeaway is uncomfortable but clear: if you are learning to code and your entire plan is "learn to write CRUD apps in React and Node.js," you are training for the shrinking part of the market. If your plan is "learn to build real products for real markets, understand the systems AI gets wrong, and use AI as a power tool," you are training for the growing part.

The strategy is not complicated. It has two parts, and you need both.

Part 1: Become genuinely fluent with AI tools

This does not mean "learn prompt engineering" as a standalone skill. It means integrating AI into your actual development workflow so thoroughly that using it becomes second nature. Specifically:

• Learn context engineering: how to structure the information you give an AI model so it produces useful output instead of plausible garbage.
• Use AI coding assistants (Copilot, Cursor, Claude) daily while building real projects. Develop intuition for when to accept AI suggestions and when to reject them.
• Understand how to build AI agents that reason, call external tools, and complete multi-step tasks. This is the direction AI engineering is heading, and developers who can build and integrate agents have skills most companies are actively hiring for.
• Learn to read and evaluate AI-generated code critically. AI writes confident-looking code that sometimes has subtle bugs. Your ability to catch those bugs is what separates you from someone who just copies and pastes AI output.

The goal is not to depend on AI. It is to become the kind of developer who makes AI useful, rather than the kind who is made redundant by it.

Part 2: Build deep expertise in something AI does not know

For developers in African markets, the African Stack is the obvious choice. Not because it is the only option, but because the gap between AI's knowledge and the real-world requirements is widest here.

• Build real M-Pesa integrations. Not tutorial versions. Real ones that handle timeouts, retries, reconciliation, and the specific ways Safaricom's API behaves in production.
• Build USSD applications. Understand session management, carrier constraints, and the UX patterns that work on a feature phone screen.
• Build with the WhatsApp Business API. Understand template message approvals, session windows, media handling, and the difference between what the documentation promises and what actually works.
• Understand low-bandwidth architecture. How do you design a system that works when the user's connection drops mid-transaction? How do you handle eventual consistency when the network is unreliable?

When you combine both parts, you become a developer who ships faster than anyone using AI alone (because you have the domain knowledge to direct AI effectively) and faster than anyone using domain knowledge alone (because AI handles the mechanical work). That combination is the most employable profile in the African tech market right now.

This is exactly the thesis behind McTaba's Software & AI Engineering program. The 30-week curriculum teaches both sides in parallel: AI engineering (agents, RAG, context engineering) alongside African Stack integrations (M-Pesa, WhatsApp Business API, USSD, Airtel Money). The program exists because we believe that combination is what the market rewards, and the early career outcomes of our graduates support that belief.

This is the counterintuitive part that most "will AI replace developers" discussions miss entirely.

AI is a multiplier. It multiplies what you can do. If you can do nothing, multiplying by zero still gives you zero. If you can think through a problem, architect a solution, and understand the systems involved, AI multiplies that ability dramatically. You ship in days what used to take weeks. You prototype in hours what used to take days. You maintain codebases that would have required a team of three.

That means the gap between a skilled developer and a non-developer is widening, not narrowing. Before AI, a skilled developer might be 3x more productive than a beginner. With AI, that skilled developer might be 10x more productive, because AI amplifies existing skill while doing little for someone who lacks the foundation to direct it.

For someone considering whether to learn: the return on investment of genuine software engineering skill has gone up, not down. The skills that matter have shifted (more system thinking, more AI fluency, more domain expertise, less rote memorization of syntax), but the value of having those skills is higher than it has ever been.

Three things are true at the same time:

1. AI can write code that used to require a junior developer.
2. A junior developer who can direct AI is more productive than a mid-level developer from five years ago.
3. The number of things worth building with software is expanding faster than AI is eliminating the need for developers.

That third point is critical. Every time the cost of building software drops (because of frameworks, cloud services, no-code tools, and now AI), the number of problems worth solving with software increases. More African businesses can afford custom software. More startups can build their first product. More organizations need developers who understand their specific market. The pie gets bigger.

The worst time to learn software engineering would be right before AI achieves full autonomous development, where it handles everything from requirements to deployment without human involvement. That is not where we are. We are in the period where AI handles the tedious parts and amplifies human judgment. That is the best possible time to enter, because you get the amplification from day one while building the judgment that AI cannot replace.

AI does not know how to integrate M-Pesa. It does not understand USSD. It defaults to Stripe every single time. That is exactly why developers who know the African Stack are getting more valuable, not less.

Try it yourself. Open any AI coding tool and ask it to build a checkout flow for a Kenyan e-commerce site. Watch what happens. It will generate a Stripe integration with a credit card form. Your users pay with M-Pesa on their phones. The AI does not know that. You do.

Now ask it to build a USSD application for customer self-service. It will produce something that looks reasonable and violates three carrier-specific constraints in the first five lines. You know those constraints because you have tested on Safaricom, Airtel, and Telkom. The AI has not.

That knowledge is your edge. AI makes you faster at the parts that are generic. Your local-market expertise handles the parts that are specific. Together, you are more productive than either AI alone or a developer alone. That is not a consolation prize. That is a genuine competitive advantage in a market that is growing.

If you want to start building that combination of skills, there are a few places to begin. Create a free McTaba Academy account to explore the curriculum and see what the learning path looks like. Or join the Discord community and ask developers who are already working with both AI tools and the African Stack what their experience has been. If you want the full picture of the program that teaches both, read the Software & AI Engineering program overview.