Victor

Posted on May 3

Rethinking Developer Responsibility in AI-Assisted .NET Applications

#ai #programming #productivity #tutorial

Introduction

Modern .NET applications are increasingly distributed, integrating APIs, background services, and external AI systems. With the rise of AI coding tools such as GitHub Copilot and frameworks like the Microsoft Agent Framework, developers can now generate large portions of application logic.

This raises a question: When AI can generate much of the code, what becomes the core responsibility of a .NET developer?

This article will answer you the above question by sharing a practical case study of that shift—highlighting how architecture, contracts, and observability via Aspire - As systems become more dynamic and AI-driven, observability and orchestration become just as important as implementation.

To explore this in an easy-to-understand way, I built a simple full-stack e-commerce application (“flowershop”) using:

• Vue.js (frontend)
• ASP.NET Core Web API (backend)
• Microsoft Agent Framework (agent orchestration)
• .NET Aspire (distributed tracing and system visibility)
• GitHub Copilot (AI-assisted development)

Now, let’s explore!

1. System Overview
The application includes features:
• Product browsing and checkout
• AI-powered chat assistant
• Automated product description generation
• End-to-end observability using .NET Aspire

This is final UI (Vue.js + AI Assistant)

Figure 1. Vue.js frontend with product listing, admin form, and AI assistant.

The frontend communicates with ASP.NET Core APIs, which orchestrates AI agents and external services.

2. Architecture: Orchestrating AI in .NET
Sales Assistant Flow

Figure 2. Sales Assistant architecture (Vue.js → ASP.NET Core API → Agent → LLM).

In this architecture:
• The Vue.js client sends requests to the API
• The API routes requests to a Sales Agent
• The agent interacts with the LLM and backend tools

Writer Flow

Figure 3. Writer flow for generating product descriptions.

When a product image is uploaded:

The API forwards the request to an agent
The agent interacts with LLM for image understanding
Additional context is retrieved
A final description is generated

Observability and Orchestration with .NET Aspire

Figure 4. .NET Aspire tracing of LLM interactions and tool calls.

Using .NET Aspire, I was able to:

Trace full request flows:
- Vue.js → API → Agent → LLM → Tool calls
Inspect tool usage:
- GetFlowerDetails
- PlaceOrder
- SearchFlowersByOccasion
Monitor:
- Latency
- Token usage
- Execution paths

This is essential because:
AI systems are non-deterministic—without observability, their behavior is difficult to understand and debug.

3. Implementation Challenges
During implementation, I encountered several challenges:

Ambiguous Specifications
Initial GitHub issues were short and informal. This led to:
• Misinterpreted requirements
• Inconsistent outputs

AI requires structured and explicit instructions.

Loss of Control
AI-generated pull requests often:
• Ignored coding conventions
• Required heavy revision

Effort shifted from writing code to reviewing and testing it manually.

Debugging Complexity

AI-generated logic was difficult to trace and fix.
AI accelerates generation, but not understanding

4. Evolving the Development Approach
To address these challenges, the process was refined.

Structured Issue Definition
Issues were rewritten using Markdown, clear requirements, and acceptance criteria, improving clarity and reducing ambiguity [1][2].

API Contract Design
Explicit API contracts were introduced to align frontend and backend components, ensuring clear interfaces and predictable integration [3][4].

Contracts become critical when AI generates both sides of a system.

Instruction and Agent Design
Custom instructions and configurations were used to guide coding conventions, architecture, and workflow [5][6].

Figure 3: Setup GitHub Copilot in project

Continuous Learning
Improving outcomes required continuous learning from official documentation and evolving frameworks [7][8].
AI amplifies—not replace the need for technical knowledge.

5. Key Lessons for .NET Developers
• Design before generating code
• Be explicit across the system
• Treat AI as a junior engineer
• Invest in observability (Aspire is critical)

6. Discussion: The Shift in Developer Responsibility

AI does not remove responsibility—it redistributes it to a higher level.

Key questions remain:

• Which responsibilities should remain human-controlled?
• Who is accountable for AI-generated code?
• How might teams adapt workflows to integrate AI effectively?
• What skills are required to remain effective in this new paradigm?

7. Conclusion

AI-assisted development in .NET is not just about generating code—it is about building systems that integrate AI reliably.
With tools like GitHub Copilot, Microsoft Agent Framework, and especially .NET Aspire, developers gain new capabilities—but also new responsibilities.

Success depends on: