The Future of Coding: My Experience with GPT-5 and GitHub Copilot
I’ve spent a lot of time testing Vibe Coding in VS Code, particularly with GitHub Copilot’s Agent Mode. In my previous demos, I compared the performance of two prominent language models, ChatGPT 4.1 and Claude Sonnet 4.0, on a complex task: building a C# API application for a deck of cards, complete with a SQL backend. The results were telling—the premium Claude model offered a significant advantage in both speed and accuracy. This led me to a simple question: What happens when we introduce a new, even more powerful player to the field?
Today, I want to share my experience with the brand-new GPT-5 model. Using the same coding prompt, I ran a fresh test to see if this new iteration of GPT could deliver on its promise. What I found was nothing short of a revolution in efficiency and capability.
Take a look at the related video below.
The Challenge: A Full-Stack Deck of Cards App
The task was a comprehensive one. I asked the AI agent to create a complete C# API application that could manage a deck of cards. This wasn’t just about writing a few lines of code; it required a full-stack solution, including:
- API Layer: The core of the application, handling requests for creating new decks, drawing cards, and checking remaining cards.
- Database Model: A SQL Server backend to manage the state of the deck, ensuring persistence and data integrity.
- Automated Testing: A Postman collection to test all API endpoints and confirm functionality.
- Deployment Scripts: Scripts to handle the creation and setup of the database.
This is a real-world task that typically requires a developer to spend hours on planning, coding, and testing. It’s the perfect benchmark for assessing the true power of an AI coding agent.
The GPT-5 Workflow: Seamless and Lightning-Fast
I started with a clean slate—a new, empty folder in Visual Studio Code. After selecting the GPT-5 model in GitHub Copilot Agent Mode, I entered my prompt. The agent’s first step was to generate a detailed, well-structured plan, breaking down the entire project into manageable components.
Setting OpenAI GPT-5 in GitHub Copilot
The most impressive part was what happened next. After I approved the plan, the agent took off. It worked autonomously, building the application from the ground up with incredible speed. I watched in awe as it generated files for the API controller, data access layer, and service logic. It was working at a pace that no human developer could match, completing the bulk of the coding in just minutes.
Self-Correction and End-to-End Success
What truly sets the GPT-5 model apart is its ability to handle errors and self-correct. During the execution, I noticed it ran a series of unit tests and, when it encountered a bug or a missing dependency, it automatically fixed the issue. This self-sufficiency is a massive time-saver and a huge step towards a more reliable AI-powered development workflow. While the other models did this as well, they did not always get it correct.
GPT-5 Fixes Errors
The output was exactly what I had hoped for.
The agent successfully:
- Created the DeckOfCards database with all three required tables.
- Generated the stored procedures for creating and drawing cards.
- Wrote a complete C# API application that compiles and runs flawlessly.
- Provided a ready-to-use Postman collection that passed all tests on the first try.
Unlike some of my previous tests, where I had to intervene manually or the database creation failed, GPT-5 handled the entire process end-to-end without a single hiccup. It was a perfect execution.
See the full prompt below to run this on your own!
GitHub Copilot Agent Mode Prompt
## AI Agent Prompt: Deck of Cards API with .NET 8 and MS SQL
**Objective:**
Build a .NET 8 API application (C#) that simulates a deck of cards, using a local MS SQL database for persistence. The solution folder should be named `DeckOfCards`. Before coding, generate and present a detailed project outline for review and approval. Once the plan is approved, do not request additional approvals. Proceed to create all required items without interruption, unless an explicit approval is essential for compliance or technical reasons. This ensures a smooth, uninterrupted workflow.
---
### 1. Project Outline
* Create an outline detailing each step to build the application, covering data modeling, API design, error handling, and testing.
* Pause and present the outline for approval before proceeding. No further review is required after approval.
* If you encounter any blocking issues during implementation, stop and document the issue for review.
---
### 2. SQL Data Model
* Design an MS SQL data model to manage multiple unique decks of cards within a `DeckOfCards` database (running locally).
* The model must support:
* Tracking cards for each unique deck.
* Creating a new deck (with a Deck ID as a GUID string without dashes).
* Drawing a specified number of cards from a deck.
* Listing all unused cards for a given deck, with a count of remaining cards.
* Treat Deck IDs as strings at all times.
* Define any variables within the relevant stored procedure.
* Enforce robust error handling for cases such as invalid Deck IDs or attempts to draw more cards than remain.
* Return detailed error messages to the API caller.
* Apply SQL best practices in naming, procedure structure, and artifact organization.
* Atomatically create and deploy the database and scripts using the local SQL server. Create the database called DeckOfCards in Server Localhost, then create the tables and procedures. Otherwise, provide a PowerShell script to fully create the database, tables, and procedures.
---
### 3. API Layer
* Create a new API project with the following endpoints, each with comprehensive unit tests (covering both positive and negative scenarios) and proper exception handling:
* **NewDeck** (GET): Returns a new DeckGuid (GUID string without dashes).
* **DrawCards** (POST):
* Inputs: DeckGuid and NumberOfCards as query parameters.
* Output: JSON array of randomly drawn cards for the specified deck.
* **CardsUsed** (GET):
* Input: DeckGuid as a query parameter.
* Output: JSON array of cards remaining in the deck, including the count of cards left.
* Implement the API using C#, connecting to SQL in the data layer for each method.
* Inside the Tests project, generate unit tests for each stored procedure
* Make sure to check for running out of cards, not able to draw anymore cards, and invaid Deck ID. Create a case for each of these.
* Inside the Tests project, generate unit tests for each API methods.
---
### 4. Application Configuration and Best Practices
* Update the `.http` file to document the three new APIs. Remove any references to the default WeatherForecast API.
* Ensure the APIs are configured to run on HTTP port 5000. Include a correct `launchSettings.json` file.
* Update `Program.cs` for the new API, removing all WeatherForecast-related code.
* Use asynchronous programming (`async/await`), store connection strings securely, and follow .NET and C# best practices throughout.
---
**Note:**
If you cannot complete a step (such as database deployment), clearly document the issue and provide a workaround or an alternative script (e.g., PowerShell for setup).
Once complete, run all unit tests to ensure everything is working.
Postman will be used for testing. Provide a inport file to be used with PostMan to test each of the three APIs. Ensure to use the HTTP endpoint.Conclusion: The Pro Subscription is a Must-Have
My experiment confirms it: the new GPT-5 Preview model in GitHub Copilot Pro is a game-changer. It’s not just faster; it’s smarter, more reliable, and capable of handling complex, multi-component projects from start to finish.
If you’re serious about maximizing your productivity as a developer, a GitHub Copilot Pro subscription is no longer a luxury—it’s a necessity. The ability to generate a full-stack application, complete with a database and testing scripts, from a single prompt is truly the future of software development.
If you want to see the full demo and the amazing speed of GPT-5 in action, be sure to check out the video on my YouTube channel.
Recent Comments