# How Coding Agents Change Software Development Forever Hailong Zhang | AI Engineer Summit 2025 | 08:50 Source: https://www.youtube.com/watch?v=EUHx5ooJHuQ Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/how-coding-agents-change-software-development-forever Published: 2025-02-22 Tags: agents, code-generation, coding-agents, evals, human-in-the-loop ## TL;DR - Coding agents will handle routine tasks such as entry-level coding, debugging, testing, and operating, while people continue to handle product design, architecture, and difficult problems. - Software teams will use synchronous agents inside tools such as GitHub Copilot and Cursor alongside asynchronous agents that complete repository tasks without constant human attention. - Guru generates and manages unit tests from pull requests, and in production more than 50% of its generated pull requests have been accepted and merged by humans. ## Summary Hailong Zhang describes a future workflow in which people and coding agents work together. Synchronous agents such as GitHub Copilot and Cursor operate inside the IDE while a developer types. Asynchronous agents run from a workflow trigger, complete a task, and submit a deliverable without needing constant attention. Zhang presents Guru, an agent that detects whether a pull request needs new or changed unit tests, writes and runs those tests, then submits a pull request for review. More than 50% of Guru's generated pull requests have been merged by humans, and Guru handles around 80% of the unit testing in its own repository. He explains that building useful agents requires a concrete problem, evaluation data, an evaluation harness, suitable models, task-specific context, and an orchestration framework. Guru uses different models for different stages and gathers repository information such as issues, reviews, commits, and code. ## Key ideas ### Routine software work will move to agents while people keep creative and difficult work [00:23](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=23s) Zhang expects AI to handle routine parts of software development, including entry-level coding, debugging, testing, and operating. He draws a boundary around product design, architecture design, and difficult issues, which still need human involvement. His proposed workflow has people and agents collaborating on the same problems. Agents take on repeatable work so developers can spend more time on decisions that require design judgment and deeper problem solving. ### Synchronous and asynchronous agents work in different parts of the development process [00:49](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=49s) Zhang separates coding agents into synchronous and asynchronous types. Synchronous agents live inside the IDE and work at the same time as the developer. He names GitHub Copilot and Cursor as examples, with suggestions appearing while someone types. Asynchronous agents are newer and behave more like bots inside a workflow. They can be triggered manually or automatically, work without human attention, and submit a deliverable when they finish. ### Future repositories will contain small agents for many stages of delivery [02:05](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=125s) Zhang imagines many agents living inside repositories and workflows, with each one handling a specific task. The examples he gives include writing unit tests, fixing bugs, writing documents, submitting code reviews, and releasing software. This division lets a team assign routine stages to agents while people focus on the parts of development that require creative decisions. The workflow depends on using several kinds of agents together rather than relying on one assistant for every task. ### AI-generated code makes unit tests more necessary and harder to keep up with [02:57](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=177s) Zhang argues that unit tests matter more as AI generates more code. Tools such as Cursor can produce multiple lines in several parts of a file from a tab completion, which makes it difficult for a developer to inspect every generated change. Faster coding also makes it easier to introduce bugs. Developers generally dislike writing unit tests, so Zhang's team built Guru to write and manage them as part of the development workflow. ### Guru turns a pull request into a reviewable unit-test change [03:43](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=223s) Guru can start manually or automatically when a pull request is submitted. It examines the code changes and decides whether new tests are needed or existing tests must change. It then writes the tests, runs them, and prepares another pull request with a test summary and coverage improvement information. A human still reviews the generated pull request and decides whether the tests are good enough to merge into the repository. ### Guru is useful in production even though humans reject many generated pull requests [04:54](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=294s) In the production data Zhang shows, over 50% of Guru's pull requests are accepted and merged by humans. He describes that rate as meaningful while also saying there is room to improve. Guru handles around 80% of the unit testing in its own repository, where the team uses it every day. Zhang also says Guru has become the first contributor in the team's commit counts, and he expects more agents to become contributors in repositories during 2025. ### An agent needs a narrow problem and an evaluation system before model work begins [05:43](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=343s) Zhang says the first step in building an agent is defining a clear, concrete, doable problem. Unit testing qualifies, while software engineering is too broad. After defining the problem, the team builds datasets and an evaluation harness. They then work on the language models and the context, followed by an agent operating system or framework that orchestrates the parts. This order gives the team a way to measure whether the agent solves the task. ### Guru chooses models and context for each stage of a task [06:38](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=398s) Guru works with frontier models from OpenAI, Anthropic, DeepSeek, and Google. Zhang says the team evaluates models across scenarios and can use different language models for different stages of the same job. The team also fine-tunes models, including GPT-4 trained with human-labeled unit-test code to improve test generation. For context, Guru gathers information from the language and framework, GitHub issues, code reviews, commits, pull requests, the README, and the code itself, then filters it before putting it into the task context. ### An agent operating system can make more software agents practical to build [07:59](https://www.youtube.com/watch?v=EUHx5ooJHuQ&t=479s) Zhang's vision extends beyond unit tests to tasks such as refactoring and end-to-end testing. Building every agent from scratch would be impractical, so his team is creating a framework they call an agent operating system, or agent OS. Different tasks can share runtime components, tools, and context. Abstracting that common infrastructure lets the team build more agents for software engineering tasks at a faster pace. ## Notable quotes - "We believe a lot of the routine works will be handled by AI, including entry-level coding tasks, debugging, testing, and operating." (00:23) - "The coding speed is really really fast, but it also easy to generate bugs." (03:21) - "Over 50% of the pull requests are merged and accepted by humans." (04:54) - "A clear, concrete, and a doable problem is crucial." (05:43) - "Different tasks may share similar run time, similar tools, similar context." (07:59) ## Tools & references mentioned - GitHub Copilot - Cursor - GitHub - Guru - Gru.ai - OpenAI - Anthropic - DeepSeek - Google - GPT-4 ## Who should watch - You are deciding where synchronous IDE assistants and asynchronous repository bots fit into a development workflow. - Your team wants to automate unit-test work while keeping human review before generated changes enter the repository. - You are building a coding agent and need a practical approach to problem definition, evaluation, model selection, context construction, and shared infrastructure. ## Related talks - [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46) - [The Emerging Skillset of Wielding Coding Agents](https://aietalks.com/talks/the-emerging-skillset-of-wielding-coding-agents) (Beyang Liu, Sourcegraph / Amp, 35:06) - [The Agent Awakens: Collaborative Development with Copilot](https://aietalks.com/talks/the-agent-awakens-collaborative-development-with-copilot) (Christopher Harrison & John Peck, GitHub, 1:04:06) - [Making Codebases Agent Ready](https://aietalks.com/talks/making-codebases-agent-ready) (Eno Reyes, Factory AI, 15:33) - [Agentic Engineering: Working With AI, Not Just Using It](https://aietalks.com/talks/agentic-engineering-working-with-ai-not-just-using-it) (Brendan O'Leary, Kilo Code, 27:03)