Log in
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 co-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:
\
• Clear architecture
• Strong contracts
• Well-defined orchestration
• Deep observability
\ 8. Source Code
The full implementation is available on GitHub:👉 GitHub Repo
\ 9. References
[1] GitHub, Inc. 2026. About issues.
[2] GitHub, Inc. 2026. Creating an issue
[3] Microsoft. 2026. API design best practices
[4] OpenAPI Initiative. 2023. OpenAPI Specification.
[5] Copilot Academy. 2025. Copilot customization workshop.
[6] GitHub, Inc. 2026. Prompt engineering for GitHub Copilot.
