Since the release of tools like ChatGPT and GitHub Copilot, the way developers work has shifted dramatically. What began as simple autocomplete in the early versions of Copilot has quickly evolved into agentic programming, where AI agents can take on entire development tasks, with mixed results.
For many developers, this shift feels both exciting and unsettling. Supporters argue that AI will supercharge productivity, while skeptics warn it could threaten the profession and eventually replace human developers altogether.
What’s clear is that new tools have lowered the barrier to building software. In 2024, GitHub CEO Thomas Dohmke predicted that by 2030, one billion people will be able to develop software with the help of AI. This year, he returned to expand on that vision, focusing on the rise of agentic programming, so with this in mind we’re going to explore the topic further and what it means for developers.
From Copilot to Coding Agents
When GitHub Copilot first launched, it was reported that developers were 55% more productive, and around 40% of the code they were checking in was AI-generated and unmodified.
Now, AI has developed to the point where we see two distinct modes of agents: the ones that sit in your IDE and work alongside you (like Copilot in its traditional sense), reasoning through problems step by step, and the ones that run in the background like virtual teammates, taking care of repetitive tasks with a sense of autonomy.
This evolution shows how quickly the development landscape is shifting. Given the known issues that AI has (ie hallucinations, biases, mistakes and inconsistencies), developers look to mitigate them with rule files and MCP.
Concerns about replacing developers aside, it’s certainly useful to offload repetitive chores to an LLM, freeing developers up to spend more time on problem solving. In a technical sense but also from an organisational perspective, keeping the human in the loop is essential, too. Human developers now increasingly spend time reviewing, validating, and steering what the agents produce, rather than manually writing syntax themselves.
Why Developers Should Care About Agentic Programming
The rise of agentic programming - an approach where autonomous software agents collaborate with humans and each other - represents a fundamental change in how we build software. It offers enormous productivity gains by automating routine work, but it also demands new skills.
Knowing how to guide an agent with clear prompts, evaluate its output critically, and keep projects aligned with security and performance standards is now as important as learning a new language or framework, and arguably far more important than actually understanding syntactic conventions for the language you’re writing (the agent will likely get this correct, or close-to).
In many ways, this new model of AI programming feels like adding a junior developer to your team. The agent can move quickly, draft solutions, and even catch errors, but it needs your oversight. Treating agents as collaborators, with some autonomy but significant guidance, is the key to unlocking their value.
Getting Started with Agentic Coding
For developers curious about stepping into this world, the best approach is to start small. Instead of throwing your main project at an agent, try it out on tasks where mistakes are cheap and the stakes are low.
You’ve likely heard horror stories of agents deleting entire applications when left to their own devices, so starting out with something simple is probably the best way to go. Migrating test frameworks, updating configuration files, or drafting documentation are good first steps, because at least you can figure out where issues occur without the results being too disastrous if it all goes awry.
As you gain confidence, focus on how you review the output. Think of yourself as the senior developer on the team: run the tests, read the diffs carefully, and question any design decisions the agent makes. If you’re working in GitHub, using pull request reviews remains as important as ever, except now you may be reviewing code drafted by an agent rather than a human colleague.
It’s also worth experimenting with both synchronous and asynchronous modes. Synchronous agents run directly in your IDE, reasoning step by step in front of you. They feel a lot like pair programming with a collaborator, you see their thought process, approve commands before they run, and guide them in real time.
By contrast, asynchronous agents work in the background. They behave more like contractors: you assign them a task, they go off to do the work in a separate environment, and eventually they return with a draft pull request. Of course this second approach requires you to trust the agents, so properly understanding how to corral them is essential.
Understanding when to lean on one or the other is part of becoming an effective agentic developer. Most importantly, though, you need to stay hands-on with your code.
There’s a common misconception that agents eliminate the need to understand programming languages. In reality, your technical foundation becomes even more critical. Without the ability to reason about software, you won’t be able to judge whether the agent’s solution is safe, efficient, or maintainable. The tools will accelerate your work (though even this is debatable), but without a human it’s just a matter of time until things go wrong.
Looking Ahead
For developers, the rise of agentic programming is not just a passing trend but a structural change in how software gets built, and what the role looks like. The sooner you begin experimenting, the sooner you’ll develop the instincts to guide agents effectively, so even if you’re an AI cynic we’d suggest you dive in and see what all the fuss is about, and be sure to let us know how you get on.
To hear more about this topic, we’d encourage you to go watch GitHub CEO Thomas Dohmke’s session from the World Congress 2025, Agents for the Sake of Happiness, where he talks about how humans will orchestrate teams of agentic programmers and envisions a world where one billion developers, supported by an army of agentic programmers build software we cannot even imagine today.
