AI Coding Agents and the Changing Craft of Software Engineering

The first wave of AI coding tools suggested the next few lines as you typed. The research behind them, such as OpenAI's Codex paper, which introduced the HumanEval benchmark, showed that large language models trained on public code could solve many self-contained programming problems. That alone changed daily work for millions of developers.

The second wave is agentic. Instead of completing a line, an agent receives a task, fix this failing test, add pagination to this endpoint, explores the codebase, edits multiple files, runs commands and iterates until checks pass. As of 2025, most major developer platforms offer some form of coding agent, and engineering teams are working out how to fold them into real delivery processes.

I have been building Django services and APIs for years, and mentoring developers through BuildWithMMO. Both perspectives inform how I see this shift: it is a genuine productivity change, and it raises the bar on judgement rather than lowering it.

The model

At the core is a large transformer language model trained on code and natural language, then refined with instruction tuning and reinforcement learning to follow tasks and use tools.

The loop

An agent runs a loop of reasoning and acting, an idea formalised in research such as ReAct. It reads files, searches the repository, proposes an edit, runs tests or a linter, observes the result and decides what to do next. The quality of the tools it is given, file search, code navigation, a sandboxed shell, test runners, matters as much as the model.

Context engineering

Repositories are larger than any context window. Agents rely on retrieval, code search, symbol indexes and summaries to bring the right files into view. Project-level instruction files that describe conventions, commands and architecture significantly improve results.

Evaluation

Benchmarks have moved from isolated functions to real-world tasks. SWE-bench asks models to resolve genuine GitHub issues from popular Python repositories, verified by the projects' own tests, and has become a widely cited measure of agent capability.

• Boilerplate collapses. Serializers, migrations, CRUD endpoints, test scaffolding and configuration are generated in seconds. A controlled experiment reported by Peng and colleagues found developers with access to an AI pair programmer completed a defined task considerably faster than a control group, though real-world gains vary widely by task and codebase.
• Exploration gets cheaper. Trying three approaches to a problem used to be expensive; now it is often an afternoon.
• Legacy code becomes approachable. Agents explain unfamiliar modules, trace call paths and write characterisation tests before refactoring.
• Review becomes the bottleneck. When code is cheap to produce, reading, understanding and verifying it is where human time goes.
• Specification matters more. Clear acceptance criteria, good tests and well-described issues dramatically improve agent output. Writing a precise ticket is now a high-leverage engineering skill.

• Plausible but wrong code. Generated code often compiles and passes shallow tests while mishandling edge cases, concurrency or error paths.
• Security regressions. Models may reproduce insecure patterns, such as SQL built by string concatenation, missing authorisation checks or weak cryptography. Agents that read untrusted content, issues, web pages or dependencies, are also exposed to prompt injection, a risk highlighted in the OWASP Top 10 for LLM Applications.
• Hallucinated dependencies. Models sometimes suggest packages that do not exist, which attackers can register with malicious code. Verify every new dependency.
• Architectural drift. Agents optimise locally. Without guidance, a codebase can accumulate inconsistent patterns and duplicated logic.
• Skill atrophy. Junior developers who never debug without help may struggle to build deep intuition. This is the concern I raise most often with mentees.
• Licensing and data handling. Understand your provider's data retention terms before sending proprietary code, and respect licence obligations for generated code.

1. Invest in tests and CI first. Agents are only as safe as the checks around them. A strong test suite, type checking and linting turn agents from risky to productive.
2. Write repository instructions. Document setup commands, conventions, architecture boundaries and forbidden patterns in a file the agent reads.
3. Keep humans accountable. Every agent-generated change should be reviewed by an engineer who could explain it. Make you merge it, you own it an explicit norm.
4. Sandbox execution. Run agents in containers or isolated environments with scoped credentials. Never give an agent production secrets.
5. Start with well-bounded tasks. Bug fixes with reproducible tests, dependency upgrades, test coverage and documentation are good first targets.
6. Measure honestly. Track lead time, change failure rate and review load, not just lines of code produced.
7. Keep learning the fundamentals. Data structures, system design, databases, networking and security are what let you judge whether generated code is right.

For developers in Nigeria and across Africa, I see an opportunity here. AI tools reduce the advantage of sheer headcount, and a small, skilled team with strong engineering discipline can now ship what used to require a much larger one.

The question I get most from mentees is whether it is still worth learning to code. My answer is yes, but learn differently. Use AI to explain, quiz and review you. Write code by hand while you are learning a concept, then compare it with what the AI suggests. Read a lot of code, including code the AI generates, and practise spotting what is wrong with it. Build real projects end to end, deploy them, and debug them when they break. The developers who will be most valuable are those who can define problems clearly, decompose them, verify solutions and take responsibility for systems in production.

Above all, cultivate curiosity about why things work. An agent can produce a working caching layer in minutes; understanding when that cache will serve stale data, or collapse under load, is what makes you the engineer people trust with production systems.

• Coding tools have evolved from autocomplete to agents that explore codebases, edit files and run tests in a loop.
• Tool design, context engineering and strong test suites determine agent quality as much as the underlying model.
• Review and verification become the main bottleneck; precise specifications are a high-leverage skill.
• Watch for insecure patterns, hallucinated dependencies, prompt injection and architectural drift.
• Fundamentals matter more, not less: engineers must be able to judge and own what agents produce.

1. Evaluating Large Language Models Trained on Code — arXiv
2. SWE-bench: Can Language Models Resolve Real-World GitHub Issues? — arXiv
3. The Impact of AI on Developer Productivity: Evidence from GitHub Copilot — arXiv
4. ReAct: Synergizing Reasoning and Acting in Language Models — arXiv
5. OWASP Top 10 for Large Language Model Applications — OWASP Foundation

Cover image: original illustration created for this article. Cited works remain the property of their respective authors and publishers.