How I Use AI to Build Software Faster

ChatGPT, Cursor, Warp, and the New AI assisted Stack for Developers

---

There’s More Software to build than people to build it

There’s always been more software to build than people to build it. More ideas than roadmaps. More features than time. And now, with AI tools, that imbalance is beginning to change.

Imagine trying to count every feature shipped in a sprint. It’d be overwhelming. The pace of development is ramping up fast—not because we’re grinding harder, but because AI has leveled up the individual contributor to the point where they can do more than ever before.

With tools like ChatGPT, Cursor, and Warp, engineers are starting to look less like single players and more like mini-teams. You’re no longer just coding—you’re managing an entourage of AI assistants who can plan, build, debug, and even clean up after you.

This doesn’t mean your job is going away. It means the expectations are changing. If you know how to work with these new tools, not against them, you’ll be way ahead of the curve.

We’re entering a time of high volatility in software engineering. Over the next decade, everything is shifting — not just the pace, but the process. We’ll prototype faster, test user flows more aggressively, ship more experiments, and ultimately create better user experiences. That’s the exciting part.

In the sections that follow, I’ll walk you through the three AI tools I use in my development workflow, how they fit together, where they shine, where they struggle, and why I think learning to orchestrate them is the key to being a high-output developer in the next wave of software.

---

The Stack: Three Tools That Changed How I Work

1. ChatGPT: From Riff to Roadmap

One of the most powerful ways I use ChatGPT is as a riff-to-structure engine.

I’ll start with a mess — voice dictation, half-formed thoughts, jumbled feature ideas, internal monologue that’s halfway between product strategy and personal journaling — and ChatGPT turns it into something clean, legible, and actionable.

This is where it shines:

• Capturing the raw, unstructured input.
• Organizing it into structured outlines, to-do lists, component breakdowns, or technical specs.
• Polishing it just enough to feed it into other tools.

I think of this part of my workflow as a Product Manager-level abstraction. It’s as if I’m the visionary/strategist, ChatGPT is the ops-minded project manager, and the rest of my tools — Cursor and Warp — are the engineers executing against the spec.

The loop looks something like this:

1. Riff with ChatGPT → voice or typed stream-of-consciousness.
2. Organize into a plan → feature outlines, component trees, acceptance criteria.
3. Feed into Cursor → start implementing the front end.
4. Use Warp → to script out backend logic, CLI automation, server configs, etc.
5. (Optionally) Use image generation tools → to generate placeholder assets, icons, or visual reference for UI/UX.

This gives me an incredibly tight solo workflow that mimics the structure of a small team:

• I’m the founder/product visionary.
• ChatGPT is the Product Manager.
• Cursor is the frontend engineering team.
• Warp is the DevOps/backend/generalist team.

Once you start thinking this way, these tools stop being “assistants” and start acting like an AI team.

💡 Pro Tip: Save Often When Dictating

If you’re using dictation to riff long-form thoughts into ChatGPT, save frequently.

There’s nothing worse than losing an uninterrupted flow of ideas because of a crash, network blip, or refresh. Dictation can feel effortless, but the tools aren’t perfect — especially in a browser context.

Get in the habit of:

• Sending smaller chunks.
• Using copy-paste backups if you’re on a long roll.
• Writing in a separate editor (like Notion, Notes, or even Cursor) before pasting into ChatGPT.

Your future self will thank you.

2. Cursor: My Frontend Engineering Team

Once I’ve used ChatGPT to outline a project — whether that’s scaffolding a file structure, describing core functionality, or drafting pseudocode — I move over to Cursor to start the build.

Cursor’s real power shows up when you work in a tight, intentional loop:

🔁 Prompt → Test → Refine

This is the development cadence I fall into almost every time:

1. Prompt — Start with a clear instruction inline, even something from the project plan you created with ChatGPT like:

   • “Write a React component that displays a list of tasks.”
   • “Add a function that formats a date like July 7, 2025.”
   • “Break up this component into smaller components in a new file.”

2. Test — Immediately check for correctness. Run the code and see if it works in your browser or terminal. Cursor often suggests test scaffolding if you ask for it so be sure to add unit tests as you go as well.

3. Refine — Tweak the logic, styling, or edge cases right in context. Cursor keeps the conversation scoped to your codebase, which means feedback is fast and usually relevant. Cursor can often fix its own mistakes as long as you’re clear about pointing out the issue.

What I love is that you can stay in flow — no jumping tabs, no copy/pasting between tools. Cursor lets me treat the editor like a collaborative space, where the AI isn’t in the way — it’s a knowledgeable pair programming partner sitting next to me, ready to help.

You can do things like:

• Generate unit tests from a function you just wrote.
• Ask for type inference in a TypeScript file.
• Refactor a file to break out reusable hooks or components.

It’s not just about “write code for me.” It’s about accelerating the development loop.

3. Warp: My Backend Dev + DevOps + Terminal Wizard

Warp  is an AI-enhanced terminal that feels like working with a backend engineer who knows your local environment. It turns shell commands into something approachable—even for someone like me, a frontend focused developer who doesn’t live in the terminal every day.

You can also pair Warp with Claude Code, another AI-powered terminal assistant that works across shells — but even then, I recommend running it inside Warp. The ergonomics alone make it worth it.

What Warp Excels At

• Running local environments – I once cloned a Go project I’d never touched, and within minutes, Warp had walked me through:

  • Setting up the environment.
  • Installing missing dependencies.
  • Running the service.
  • Making a code change.
  • Submitting a PR.

• Debugging – Warp can interpret error messages, suggest fixes, and re-run commands with modified arguments.

• GitHub workflows – Using the gh CLI, Warp can:

  • Read pull request comments.
  • Parse the feedback.
  • Suggest code changes to address it.
  • Even walk you through pushing the fix and updating the PR.

All of this makes Warp a serious productivity multiplier for developers who:

• Don’t spend all day in the terminal.
• Need to touch backend code but aren’t backend experts.
• Want to get in, fix something, and move on with confidence.

Warp turns what used to be a friction point — running servers, managing environments, scripting fixes — into something smooth, fast, and accessible.

---

How I Orchestrate the Stack

Even though these tools can do a lot of the same things — code generation, refactoring, even debugging — I like to keep them mentally separated.

Tool	Mental Role	Primary Use Case
ChatGPT	PM / Strategist	Planning, brainstorming, dictation
Cursor	Frontend Engineer	Scaffolding, refactoring, testing
Warp	Backend / DevOps Team	Running environments, scripting, Git workflows

It’s not about capability. It’s about clarity of purpose.

• ChatGPT is where I think, plan, and structure. It’s my ideation space, my second brain. It’s also a great way to get feedback and iterate on your ideas before you start building.
• Cursor is where I implement. Once I know what I want, I jump in and start coding. It’s my main builder.
• Warp is where I execute scripts, spin up environments, and do CLI-level thinking.

By keeping those roles distinct in my head, I avoid muddying my mental state. I stay in flow. I don’t waste time wondering, “Which tool should I use?” I already know based on what kind of problem I’m solving.

And yeah — there’s overlap. A lot of it. But drawing clean boundaries keeps me from context-switching too hard or letting one tool try to do too much.

---

Final Thoughts

The way we build software is changing. You no longer need to be an expert in everything—because now you have tools that specialize alongside you.

But these tools don’t work in isolation. You have to learn how to manage them. You’re not just coding anymore. You’re:

• Scoping with ChatGPT.
• Building with Cursor.
• Executing with Warp.
• And shipping with clarity and speed.

You’re the lead. They’re your team.

This is the new stack and if you get comfortable working this way, you’re going to be incredibly well-positioned for the coming years of engineering.

So fire up a chat. Open a terminal. Start building.