My First 24 Hours with GPT-5 in Cursor, & I'm Not Sure I'm the Same Coder Anymore
Alright, so the day finally came. After months of rumors, speculation, & a few not-so-subtle hints from Sam Altman, GPT-5 is officially here. It dropped on August 7, 2025, & honestly, the dev world has been buzzing ever since. I’ve been hearing whispers about its crazy new reasoning skills & its ability to basically build entire apps from a single prompt. So, naturally, I had to take it for a spin.
For the past year or so, my go-to coding environment has been Cursor, the AI-first IDE that’s basically a supercharged fork of VS Code. If you've used it, you know it's already a pretty powerful tool. It’s got this deep integration with AI that makes things like refactoring or understanding a new codebase SO much easier. But the idea of pairing it with GPT-5? That felt like a whole new level.
So, I cleared my schedule, grabbed a fresh cup of coffee, & dove in. Here's a rundown of my first 24 hours with what feels like the future of coding.
The Setup: Getting GPT-5 Running in Cursor
First things first, getting it all hooked up. Cursor has always been pretty good about integrating the latest models, & this was no exception. They had support for GPT-5 rolled out almost immediately. If you've ever added an API key in Cursor, it's the same straightforward process. A quick trip to the settings, pop in the new key, & I was good to go.
I was immediately greeted with a few model options:
,
, &
. For this experiment, I decided to go all out & stick with the full-power
. I wanted to see what this thing could
really do.
For those who don't know, Cursor is designed from the ground up to be an AI-native environment. It’s not just a plugin like GitHub Copilot; it’s a whole IDE built around the idea of an AI pair programmer. It can read your entire codebase, understand the context, & even run commands for you. So, pairing this with OpenAI's latest & greatest felt like unlocking a new skill tree for myself.
The First Task: Building a "Vibe" I Couldn't Quite Describe
I decided to start with something a bit abstract. I’ve had this idea for a personal project floating around in my head for a while: a simple, aesthetically pleasing French learning app. I didn't have a full spec sheet or anything, just a vibe. I wanted something clean, with a bit of a game-like feel to it.
I opened up Cursor’s chat panel, gave it access to an empty project folder, & typed something like:
"Hey, can you help me build a simple French learning app? I want it to be a web app. The design should be really clean & modern, lots of white space. It should have a feature where it shows you a word in English & you have to type the French translation. Maybe some simple sound effects for correct & incorrect answers. Let's use React & Tailwind CSS."
This is where things got… weird, in the best way possible. I’ve used GPT-4 in Cursor for similar tasks, & it’s always been pretty good. It would generate a decent file structure & some boilerplate code. But GPT-5 was different.
Within MINUTES, it had not only created the entire file structure but had also written most of the frontend components. The code was clean, well-commented, & actually… beautiful. It had made design choices that I hadn’t even thought to specify, like subtle animations on the flashcards & a really nice color palette. It even scaffolded a simple backend with a JSON file to hold the vocabulary.
The most impressive part was the iteration speed. I could say things like, "Actually, let's make the 'correct' sound a bit more satisfying," & it would just... do it. It wasn't just generating code; it felt like it was collaborating on the design with me.
Diving Deeper: Letting the Agent Take the Wheel
Cursor has this feature called "Agent mode" where it can take a high-level goal & break it down into smaller tasks, executing them one by one. It’s always been a powerful feature, but with GPT-5, it feels like it finally has the brain it deserves.
For the French app, I decided to push it. I gave it a new prompt:
"Okay, this is great. Now, can you add a new page that tracks the user's progress? I want to see a list of words they've learned, their accuracy for each word, & maybe a simple chart showing their progress over the last week. Also, deploy this to a free hosting service."
This is where I expected it to stumble. This task involves multiple files, state management, some data visualization, & even interacting with a hosting provider's CLI.
But GPT-5, working through Cursor's agent, just started working. It broke the task down into a checklist:
- Create a new component.
- Update the router to include the new page.
- Implement state management to track user scores.
- Add a simple charting library.
- Create the chart component.
- Update the main app to save progress.
- Add a script to deploy the app.
It worked through each step, showing me the diffs for approval. It chose a lightweight charting library, wrote the code to track the stats, & then, to my astonishment, it actually generated the command-line instructions to deploy the app. I had to give it my credentials, of course, but it handled the rest.
Honestly, watching it work was a little humbling. It felt like I was supervising a very, very fast junior developer who just happened to know everything.
The Power of Context: A Refactoring Nightmare Made Easy
One of the biggest challenges with AI coding assistants has always been context. They might be good at writing a single function, but they often struggle to understand the architecture of a large, complex project. This is where the combination of Cursor’s codebase indexing & GPT-5's massive context window really shines.
I have a side project, a messy, sprawling codebase I’ve been tinkering with for years. It’s a mix of different patterns, with some legacy code that I’m frankly too scared to touch. I decided to give GPT-5 a real test.
I opened the project in Cursor, let it index the entire thing, & then picked a particularly nasty part of the code: a giant, ten-year-old module that handled payment processing. It was a monolith of spaghetti code, & I had no idea how it all worked.
I opened the chat & asked:
"Can you explain what this module does? And then, can you suggest a way to refactor it into smaller, more manageable services without breaking anything?"
GPT-5 came back with a detailed explanation of the module's functionality that was clearer than any documentation I had. It identified the different responsibilities that were all tangled together & then proposed a step-by-step refactoring plan. It suggested creating separate microservices for payment processing, receipt generation, & fraud detection.
But here’s the kicker: it also identified all the places in the codebase that would need to be updated to use these new services. It understood the cross-repository dependencies & even pointed out a few potential race conditions in the old code that I had never noticed.
This is the kind of task that would have taken me weeks of careful planning & testing. GPT-5 did it in about 15 minutes. It's a total game-changer for dealing with legacy code.
Where it Still Stumbles (A Little Bit)
Now, it wasn't all perfect. There were a few times when GPT-5 got a little too enthusiastic. In one instance, I asked it to fix a small bug, & it decided to refactor the entire file with a completely new design pattern. The new code was probably better, but it was a bit more than I had asked for.
I also noticed that you still have to be pretty specific with your instructions, especially on complex tasks. If you give it a vague prompt, you might get a result that’s technically correct but not what you actually wanted. It’s less of a mind-reader & more of an incredibly capable assistant that needs clear direction.
But here's the thing about working inside an IDE like Cursor: the feedback loop is incredibly tight. When it does something unexpected, you can see the diff immediately, make a quick correction in the chat, & it will adjust. It feels less like a one-shot command & more like a conversation.
The Bigger Picture: How This Changes Everything
After a full day of this, I can honestly say that my workflow has fundamentally changed. The old way of coding—staring at a screen, slowly piecing together logic, constantly switching over to a browser to look up documentation—feels ancient.
With GPT-5 in Cursor, I feel more like a conductor than a musician. My job is shifting from writing every single line of code to providing high-level direction, reviewing the AI's work, & focusing on the creative, architectural parts of software development. It's handling the boring, repetitive stuff, which frees me up to think about the bigger picture.
This kind of power isn't just for individual developers, either. Imagine a business being able to prototype & launch new features at this speed. The implications are HUGE.
It reminds me a bit of what's happening in the customer service space. A few years ago, chatbots were a joke. Now, with platforms like Arsturn, businesses can build custom AI chatbots trained on their own data. These bots can provide instant, personalized support 24/7, answer complex questions, & even help with lead generation. Arsturn helps companies build these no-code AI chatbots that can have meaningful conversations with customers, boosting engagement & conversions. It’s all about using AI to automate the repetitive tasks & free up humans to focus on what they do best.
That's exactly what GPT-5 in Cursor feels like for developers. It's an automation engine for code, a conversational partner that helps you build better software, faster.
The Verdict After 24 Hours
So, is Cursor with GPT-5 the new ultimate coding setup? For me, it's a resounding yes. It’s not just an incremental improvement; it feels like a paradigm shift. The ability to generate entire applications from a "vibe," refactor complex legacy code with confidence, & iterate on ideas at lightning speed is something I never thought I’d see.
It's not perfect, & you still need to be a good developer to guide it. But it's a tool that amplifies your abilities in a way that’s hard to comprehend until you try it. It handles the "how," so you can focus on the "what" & "why."
Going back to a regular IDE with just basic autocomplete feels like trying to write a novel with a chisel & stone. The world has changed, & I think I have too.
I hope this was helpful. I'm really curious to hear what you all think. Have you tried GPT-5 yet? What's your experience been like? Let me know