The speed of change is the first challenge
Software development has always evolved quickly, but teams used to have years to absorb a new language, framework, or way of working. With AI tools, an approach can become outdated only weeks after a company starts introducing it.
This makes the current period both exciting and uncertain. Teams can choose from countless models, agents, and workflows without knowing which ones will remain useful. The essential question is therefore not how to try everything, but which problem is genuinely worth solving better.
Faster code does not automatically mean a faster project
A polished website or prototype can now appear in half an hour. A secure, maintainable system delivered to a client still requires much more than code: teams must understand the business need, design the behaviour, test it, deploy it, and remain able to explain every important decision later.
AI also produces larger changes and much more code at once. Traditional code review can easily become a bottleneck because asking another developer to inspect a huge agent-generated change line by line does not scale. The workflow itself needs smaller verifiable milestones, explicit expectations, and automated quality controls.
Developer and project manager responsibilities are converging
As AI handles more of the technical implementation, correctly understanding the problem becomes more valuable. A strong developer must know not only how to implement a feature, but how a client will use it, what business value it creates, and how it affects the wider system.
Project managers are moving closer to technical decisions as well. Defining a list page, for example, is not just a matter of naming fields. It also means considering filters, sorting, performance, and the shortest route to the action users perform most often. AI reduces implementation effort, but it does not remove the need for sound decisions.
AI fails differently, so it needs different controls
Current models make fewer simple typing errors and automatically apply many basic patterns that people may forget. They are not infallible, however. They can pursue the wrong direction, copy outdated patterns from a legacy codebase, or lose track when the goal and context change repeatedly.
Four practical principles emerge from the discussion:
- Give the agent a clear objective and verifiable milestones.
- Describe project-specific rules and preferred patterns explicitly.
- Restart oversized or redirected work with a clean context.
- Keep a person accountable for the result, backed by testing and professional review.
Fewer developers or more ideas brought to life?
AI can indeed let fewer people complete the same task. That does not necessarily leave less work to do. Internal tools, custom automations, and small applications that once cost too much to justify can now be worth building.
The podcast therefore does not frame the change as a simple story of redundancies. Development work is being redistributed: less time goes into mechanical coding and more into business thinking, planning, verification, communication, and knowledge sharing. Each professional needs to decide how they will continue creating value in this new balance.
Junior developers face a harder path
It is particularly difficult to build deep knowledge when AI presents a finished solution before a beginner has struggled with the problem. Reading a solution does not create the same understanding as trying, failing, correcting the work, and discovering the relationships independently.
Fundamentals therefore become more important, not less. Someone who understands systems, recognises flawed patterns, and can break down problems independently can use AI as an amplifier. Someone who only accepts finished answers risks being left with confident but shallow knowledge.
The outcome matters more than the typing
The value of software has never come from the number of keystrokes or lines of code. What matters is whether it solves the client's problem, operates safely, and remains adaptable next week or next year.
AI makes this principle impossible to ignore. Producing code is becoming cheaper and faster, while choosing the right goal, designing a coherent system, and taking responsibility for decisions cannot yet be fully automated. Fewer developers may create more software, but it only becomes more value if people retain understanding and control.