Same App, Five AI Workflows: We Built It Every Way So You Don't Have To

Here's the thing about AI-assisted development in 2025: everyone has an opinion, but not everyone has sat down and actually built something with each of the major approaches back-to-back. We did. Over the course of a week, we constructed the same project five different ways—a simple but non-trivial web app that pulls data from a public API, displays it in a filterable table, and lets users export results as a CSV. Nothing fancy, but enough complexity to expose where each workflow shines and where it quietly falls apart.

The five approaches: ChatGPT (in the browser, no plugins), GitHub Copilot inside VS Code, Cursor (the AI-native IDE), a terminal-based workflow using Claude via CLI, and Replit's AI-assisted environment. Same spec. Same developer. Five very different experiences.

The Setup and the Ground Rules

To keep this honest, we used the same rough spec document for all five runs. No copy-pasting code between sessions. We tracked time from first prompt to a working, deployable build, logged how many back-and-forth exchanges were needed to fix bugs, and noted how much the final code felt like something we'd actually want to maintain.

The developer doing the building has about four years of experience—comfortable with JavaScript and Python, not a 10x engineer, but not a beginner either. That context matters, because the "best" AI workflow for a senior engineer is not necessarily the best one for someone learning to code.

ChatGPT in the Browser: Still Surprisingly Capable, Still Surprisingly Manual

Starting with the most familiar setup. Browser tab open, paste in the spec, start prompting.

ChatGPT generated a solid initial scaffold in one shot—HTML, a fetch call to the API, basic table rendering. Genuinely impressive as a starting point. The problems started when we needed to iterate. Every change meant copying code out of the chat, pasting it into an editor, running it, finding the error, copying the error back into the chat, and repeating.

That context-switching is brutal. We spent probably 40% of our total time on this approach just moving code between windows. The output quality was good. The workflow felt like 2022.

Time to working build: 2 hours, 14 minutes. Bug-fix exchanges: 11.

GitHub Copilot in VS Code: The Comfortable Middle Ground

This one felt like the baseline that everything else should be measured against. Copilot's inline suggestions inside VS Code are genuinely useful—it's not magic, but it removes a lot of the boilerplate tedium that slows down early-stage development.

The standout moment came when we were writing the CSV export function. Copilot suggested a complete, correct implementation before we'd finished typing the function name. That kind of autocomplete-on-steroids experience still feels a little uncanny, even when you're used to it.

Where Copilot falls short is in the bigger-picture stuff. It's great at completing lines and blocks, less great at helping you rethink an approach when something isn't working architecturally. The chat sidebar helps, but it still feels like a separate tool bolted onto the editor rather than something native to the workflow.

Time to working build: 1 hour, 41 minutes. Bug-fix exchanges: 7.

Cursor: The One That Actually Felt Different

Cursor is an AI-native IDE built on VS Code's foundation, and using it back-to-back with regular Copilot makes the difference obvious pretty fast. The key feature is Composer—a mode where you describe what you want to build and Cursor generates or modifies multiple files simultaneously, with full awareness of your existing codebase.

When our filter logic wasn't working correctly, we described the bug in plain English and Cursor identified the issue, explained why it was happening, and offered a fix—all in the same interface, without breaking our flow. That felt genuinely different from anything else in this comparison.

The codebase awareness is the real differentiator. By the second hour, Cursor seemed to "know" our project well enough that its suggestions were contextually relevant in a way that ChatGPT in a browser simply can't match.

Time to working build: 1 hour, 22 minutes. Bug-fix exchanges: 4.

Claude via Terminal: Powerful, Nerdy, Not for Everyone

Running Claude through a CLI tool (we used a simple wrapper that piped prompts and responses) was the most interesting experiment in the group—and the hardest to recommend broadly.

The quality of Claude's reasoning about code is genuinely excellent. When we described a tricky edge case with the API pagination, it walked through the problem methodically and landed on a clean solution. But the workflow requires you to be comfortable living in the terminal, managing context manually, and essentially acting as the glue between the AI's output and your actual codebase.

For developers who are already terminal-native, this approach has a certain elegance. For everyone else, it's a lot of overhead. It's also the approach most likely to produce code you actually understand, because you're forced to engage with every piece of it.

Time to working build: 1 hour, 58 minutes. Bug-fix exchanges: 6.

Replit with AI: The Fastest Ramp, the Most Constraints

Replit's AI-assisted environment is built for accessibility, and it shows. Setup was the fastest of any approach—no local environment, no configuration, just describe what you want and watch it scaffold a project in seconds.

For the first 30 minutes, this felt like the future. Then the constraints started showing up. Replit's environment doesn't always play nicely with external APIs in the way a local dev setup does, and some of the AI's suggestions were clearly optimized for Replit's own ecosystem rather than portable, production-ready code.

This is the right tool for prototyping, teaching, or getting something on screen fast. It's probably not where you want to build anything you're planning to maintain long-term.

Time to working build: 1 hour, 17 minutes. Bug-fix exchanges: 9 (many environment-specific).

Which One Actually Feels Like 2025?

Honest answer: Cursor, and it's not particularly close. The combination of codebase awareness, in-editor AI conversation, and multi-file editing creates a workflow that feels genuinely different from what came before—not just faster autocomplete, but a different relationship between the developer and the code.

GitHub Copilot is the safe, stable choice if you're already in the VS Code ecosystem and don't want to change your setup. The terminal/Claude approach is worth exploring if you're the kind of developer who likes understanding every layer of what you're building.

And ChatGPT in the browser? Still useful. Still the first place a lot of people reach. But as a primary development workflow in 2025, it's showing its age.

The broader takeaway from this exercise: the gap between these tools is bigger than the marketing suggests, and the only way to really know which one fits your brain is to build something real with each of them. Which is, conveniently, exactly what Verilo is here for.