AI Agents in Software Development: How to Work Successfully with Copilot

AI agents are transforming software development. They assist with analyzing codebases, handle implementation tasks, and automate repetitive steps. However, using them productively requires a well-thought-out development workflow: tasks should be divided sensibly, results should be reviewed, and code quality should be consistently ensured. It is crucial not to delegate responsibility for architecture, technical decisions, and maintainability to the agents. The following article shows how GitHub Copilot can be integrated into existing development processes, what role instructions, skills, and prompts play, and why human oversight remains indispensable, especially in production environments.

The use of coding agents does not necessarily mean rebuilding the entire development process from scratch. Often, the basic steps remain the same—from defining the task through planning and implementation to review and acceptance. What changes is the support provided within these steps.

A good place to start is by analyzing the codebase. AI agents can identify relevant files and code sections, discern relationships, and assist in preparing for implementation. However, the business-side classification of the problem and the fundamental technical decisions should remain the responsibility of the developers.

For implementation, it is advisable to break down larger tasks into smaller, clearly defined subtasks. These can be specifically assigned to the agents and then reviewed individually. Small changes make it easier to monitor the process and identify errors or unintended consequences.

A practical guideline based on development experience is to limit changes and pull requests to approximately 200 lines. This is not a universal threshold. The key is to keep the scope manageable so that the changes can still be understood in a focused manner.

Implementation should be followed by a review. If necessary, the agent can make revisions based on the feedback. Only once the acceptance criteria have been met and the changes have been verified should they be merged. AI can also assist with creating commit messages and pull request descriptions. However, the results should not be accepted without verification.

Spec-Driven Development (SDD) can help describe complex tasks in a structured way and guide their implementation by AI agents. However, not every change requires an extensive specification.

Especially for smaller tasks, the additional effort required for documentation and coordination can slow down the actual development process. Furthermore, a detailed specification does not guarantee correct implementation. Ultimately, what matters is the code that is actually executed.

A pragmatic approach, therefore, is to tailor the scope of the requirements to the complexity of the task. Small changes often require only a clear task description and defined acceptance criteria. For more complex projects, additional specifications and planning steps may be useful.

In any case, it remains important not only to verify whether the stated requirements have been met. Architecture, extensibility, and maintainability must also be taken into account. A solution can be functionally correct and still result in technical debt.

A major risk associated with the use of coding agents lies in the quality of the generated implementation. Unspecified details leave room for interpretation. The agent may meet the immediate acceptance criteria, but upon closer inspection, the solution may be difficult to maintain or only partially extensible.

An interesting point of reference in this regard is SlopCodeBench. Among other things, the study examines how code quality evolves during iterative work with coding agents. It illustrates that an increasing success rate in problem-solving does not automatically mean that code quality also improves. In the scenarios examined, models are increasingly successful at solving tasks, while certain quality metrics stagnate or deteriorate.

This has an important implication for practice: coding agents should not be left entirely to their own devices when making prolonged or repeated changes. The results must be reviewed and adapted to existing architectural and quality standards.

AI-generated code is by no means automatically inferior. When used correctly, agents can also improve software quality—for example, by creating and running tests, maintaining documentation, performing security checks, hunting for bugs, or analyzing logs. It is precisely with such tasks that they can enable significant efficiency gains.

For coding agents to work consistently, they need sufficient context. This context can be provided at various levels.

Personal instructions define individual preferences for collaboration. These include, for example, guidelines on code structure, clean code principles, comments, and communication. Clear instructions help tailor the results to the developers’ working styles and avoid unnecessarily lengthy responses.

Skills are suitable for specialized knowledge and recurring processes. For example, they can map technical specifics, customer-specific requirements, or certain solution paths that the agent should take into account when handling relevant tasks.

Prompts are useful when specific tasks or workflows are repeated regularly. Instead of reformulating recurring instructions each time, they can be provided as reusable templates.

The agent should also be provided with the necessary information at the repository level. Three elements are particularly helpful here:

• AGENTS.md: Describes the repository, its structure, important conventions, and available commands. This file provides the agent with the necessary project context.
• REVIEW.md: Contains additional guidelines for code reviews. This allows for the systematic consideration of recurring checks and project-specific quality requirements.
• Verification tasks: The agent should be able to verify its own implementation. This includes, for example, tests, linting, and other project-related checks. Whatever is checked in a CI pipeline should, if possible, already be verifiable during implementation.

It is crucial not to make these tools overly complex from the outset. It makes more sense to identify recurring requirements step by step and develop instructions, skills, or prompts based on them. These should then be further refined based on actual results.

The approach of an AI-friendly architecture also illustrates what a suitable project structure for collaboration with coding agents might look like.

Vibe Coding—that is, the largely autonomous implementation of code by AI agents without continuous human oversight—can be useful for certain use cases. The key factors are, above all, the risk and the expected lifespan of the code.

For small, low-risk tasks, this approach is well-suited for prototypes, proofs of concept, or one-time utility scripts, for example. If the code serves only a limited purpose and does not require long-term maintenance afterward, a largely autonomous implementation can save time.

The situation is different for production applications, sensitive data, or business-critical systems. The higher the risk and the larger the scope of the application, the more thoroughly the implementation and results must be reviewed. Especially for applications that will undergo long-term development, it is important that developers understand the structure and functionality of the code.

The line between Vibe Coding and traditional, closely supervised development is not binary. It depends on the specific task at hand. As soon as the code is read, understood, and, if necessary, adapted by the developer, the development goes beyond purely autonomous Vibe Coding. For production systems, this human connection to the code should be a given.

Based on experience with AI-powered software development, five practical recommendations can be derived:

1. Keep tasks manageable

Larger projects should be broken down into smaller, clearly defined changes. This makes it easier to maintain control and reduces the risk of errors slipping unnoticed into the codebase.

2. Build automation incrementally

Instructions, skills, and prompts should be derived from specific requirements encountered in day-to-day development. An incremental approach prevents unnecessary complexity and enables continuous improvement of the tools.

3. Minimize context switching

Having multiple agents working in parallel does not automatically lead to higher productivity. Even with AI agents, every switch between tasks costs time and attention because the agent must re-establish the relevant context. A clear focus can therefore be more efficient than working on many tasks simultaneously.

4. Adapt the workflow to your own working style

There is no universally correct agent workflow. The tools and processes used should be tailored to the project’s requirements and the development team’s working style. It makes sense to refine existing processes in a targeted manner rather than replacing them entirely with a rigid AI framework.

5. Understand the code before accepting it

Responsibility for the code remains with the developers—regardless of whether it was written by them or generated by an agent. Anyone who commits code should be able to understand what they are doing and why the chosen solution makes sense.

Coding agents can significantly speed up software development. However, their greatest benefit does not lie in generating as much code as possible as autonomously as possible. The key is to integrate them strategically into a well-thought-out development workflow.

The combination of clearly defined tasks, an appropriate project context, automated verification, and human review makes it possible to use AI support productively without losing sight of code quality. Especially for larger and business-critical applications, human responsibility for architecture, security, and maintainability remains indispensable.

A good agent workflow does not emerge all at once. It evolves gradually alongside the models used, the project requirements, and the experiences of the development teams.