That might sound bold, but hear me out. Most developers I know are at least dabbling with AI—using it for autocompleting functions, generating snippets, or creating small, simple programs. But stories of things going off the rails when trying to rely on AI for anything more significant are all too common. It’s not that AI isn’t capable—success depends on using the right tools and providing the detailed context AI needs to truly deliver. With the right approach, AI isn’t just something to supercharge your code editor—it’s capable of doing far more than I think most developers realize, even handling the entire implementation.

My premise here isn’t that software development is going away or that highly technical skills aren’t needed to build real world software. Rather, it’s that with the right methods, it’s no longer necessary to do the heavy lifting yourself. AI has reached a point where, if you engage with it effectively, it can transform the way you approach software development. Too often, developers give AI vague instructions, only to be disappointed when it falls short. But when you stop treating AI like a magic wand and start treating it like a collaborator—feeding it detailed requirements and having real conversations with it—it becomes a powerhouse.

To be clear, I’m not talking about tools like Replit, which are great for less technical users who just want to describe what they need and let the system build it. Credit where it’s due—Replit is amazing. But what I’m referring to is “real” software development, where scale, performance, and architecture are critical, and where developers are deeply opinionated about their tech stack, architecture, and design decisions. It’s an approach for developers who value precision and control.

I’ve redefined my workflow to the point where I write less than 5% of the code myself. By focusing on designing, specifying, and guiding the AI, I’ve found a way to build software faster, more efficiently, and with less manual effort than ever before.

Writing requirements is the new “coding”

For most of my career, being a developer meant jumping into code as quickly as possible. We’d rush through requirements, sketch out just enough to get started, and dive headfirst into writing functions and building features. Coding felt like the real work, and everything else was just prep to get there.

Now, that’s flipped. Instead of racing through the requirements phase, I focus almost entirely on detailed specifications.  What are we building? What are the requirements? I define the interface—the inputs, outputs, naming conventions, and functionality—and map out the data model in advance.  This isn’t just a change in philosophy—it’s a necessity. When AI is doing 95% of the coding, the outcome depends entirely on how well you’ve defined the problem. The better your specifications, the better the results.

I think the “co-pilot” analogy has flipped, too. Traditionally, tools like GitHub Copilot have treated AI as a helpful assistant sitting to your side—you’re still the primary pilot, doing the flying, and the AI pitches in to help. What I’m describing is different: now the AI is driving the plane, and you’re the one in the other seat, directing where it goes. You’re still the one with the grand plan—designing, specifying, and guiding the process—but the AI handles the heavy lifting of implementation.

With AI handling the coding, I no longer feel the pressure to rush into writing code to feel productive. Spending time upfront on requirements is the real work—it ensures that once I hand it off to the AI, the process is fast, smooth, and accurate.

AI Thrives on Context

AI is only as effective as the context you give it. When I start planning a major feature or functionality—what Agile practitioners might call an “epic”—I start by uploading key documents into the ChatGPT desktop app to give it the background it needs. These include a description of the app’s purpose, goals, and audience, along with functionality outlines that include design concepts and visuals. By grounding the AI in this context, I ensure it understands the big picture before diving into specifics.

This process is conversational and iterative, leveraging voice input to speed up communication. I describe the functionality’s purpose, scope, and how it fits into the app, as well as the target state and acceptance criteria. ChatGPT drafts the epic based on this input, and I iterate on it using voice to request changes or clarifications until it’s complete.

Once the epic is finalized, I ask ChatGPT to break it into smaller, actionable pieces. Each story is then refined through the same process, ensuring detailed requirements for interfaces (like endpoints, payloads, and responses), data models (schemas or objects), and naming conventions. The goal is to make every story clear, actionable, and ready for implementation.

If it sounds like a lot of writing, you’re right, but don’t worry, you don’t have to do it all yourself! I mostly use my voice to think out loud, give the AI some initial thoughts, review a draft, and then iterate by telling it what to change or improve. Beyond just preparing detailed instructions for the AI to implement, this process forces you to think critically about what you’re building, anticipate edge cases, and consider the long term implications of your designs.

How Cursor’s Agentic Automation Handles the Heavy Lifting

I use Cursor, a VS Code based editor with enhanced AI tools, to turn detailed requirements into working code. Once you hand off your finalized story to Cursor’s Composer and tell it to implement, the code gets written almost instantaneously. If there are missing details, the AI will make assumptions and fill in the blanks, just as a person might, which is where things can go off track. I think people often mislabel this as the AI hallucinating, but it’s not always the case, it’s simply doing its best with the information it was given.

Before moving to coding, I paste the finalized story into Cursor’s Chat tab for review. I’ll prompt: “Don’t make any code changes yet. Review this story and let me know if there are any gaps or questions I should address.” This step helps ensure the story is complete and avoids issues later.

Finally, implementation happens in Cursor’s Composer tool, which is an agentic editor. Cursor doesn’t require you to manually provide every piece of context—it discovers your codebase on its own, analyzes the relevant sections, and generates a plan for implementation. From there, it handles writing the code and tests across multiple files, running the tests, reviewing the test output, and iterating until the errors are fixed. The process feels like reviewing a pull request (PR). Cursor shows a diff of the changes, and my role is to review, approve or reject, and request adjustments if needed.

If something isn’t right, you don’t just take over and start fixing the code yourself—you chat with the AI to adjust it. It’s an iterative, conversational process that feels more like collaborating with another developer. Code review at each step is crucial because the AI will sometimes start down the wrong path and need guidance and redirection. You’re definitely not blindly accepting the generated code; you’re actively steering the process to ensure it stays aligned with your vision. Treat the AI like a person you’re actually having a conversation with, and you’ll get the best results. And just like working with another person, there shouldn’t be an expectation of perfection.

Welcome to your new job as a developer – you’re now a spec writer and a code reviewer. Like it or not, this is a glimpse at where things are going. The productivity gains are just too high to ignore, and the tools and underlying models are just going to keep getting better from here.

Cursor is what GitHub Copilot should have been. Both tools are essentially VS Code enhanced with AI features, but Cursor took the concept further in ways that truly stand out. While Copilot offers helpful autocomplete suggestions and small scale edits, it, at the time of writing, lacks the contextual awareness and agentic capabilities needed to analyze your entire codebase or apply coordinated changes across multiple files. Similarly, ChatGPT, while a fantastic tool that I use throughout my workflow, isn’t designed for integrated development. It can only work with the limited code you provide and often leaves you stuck in a tedious cycle of copying and pasting between the chat interface and your editor, adding unnecessary friction. These tools are great for specific tasks, but Cursor is setting a new standard for AI assisted development by delivering the seamless integration, intelligent automation, and efficiency that developers truly need.

The Power of Voice: Redefining How We Work with AI

When working with AI, the way you communicate with it makes all the difference. Treating AI like a collaborator—not just a tool—requires rich, detailed input and feedback. This is where voice becomes a game changer.

Most people interact with AI by typing short, vague instructions, expecting it to deliver perfect results. But effective collaboration with AI requires far more context and nuance. You need to think out loud, explain your reasoning, and provide comprehensive feedback to guide the AI. Voice input allows you to do this in a way that typing simply can’t.

Thinking Out Loud – Voice allows you to start speaking without overthinking sentence structure or presentation. It feels natural to pause mid-thought, switch topics, or explore tangents as needed. This kind of free flowing input is something we’re used to when speaking, but it’s not how we typically communicate when typing.

Sharing More Context – With voice, you’re likely to share more information, more nuance, and more context than you ever would typing. When preparing requirements for an epic, for example, I might spend 4-5 minutes just talking through my thoughts, explaining details, and giving background before sending it off for the AI to generate a first draft. Typing that out would not only take significantly longer, but I also wouldn’t even attempt to share that much detail—it’s just too exhausting.

At first, you’ll feel a little silly talking out loud to your computer—but you’ll get over it. Voice opens the door to a new level of quality and speed in working with AI. Speaking is far faster than typing, even for fast typists, but more importantly, it encourages depth and clarity. It allows you to give the AI the kind of detail that dramatically increases its understanding of your needs. The payoff? Faster iterations, better outcomes, and a more seamless collaboration with AI.

Most people are skeptical of voice to text, and it’s no surprise why. We’ve been trained to distrust voice recognition from a lifetime of frustrating experiences like automated phone customer service systems and even the transcription tools built into our devices like iPhones or Macs, which often deliver mediocre results, forcing users to constantly review and correct errors. When you’re distracted from your thoughts to babysit the transcription, the process can be more frustrating than helpful.

The tools I use, like the ChatGPT desktop application and Wispr Flow, have changed that entirely. The ChatGPT desktop app’s built-in voice-to-text feature is accurate enough that I can speak naturally and quickly without worrying about errors. For tools like Cursor, which don’t yet support voice input natively, Wispr Flow steps in. It lets you hold down a key, speak, and instantly converts your voice to text in any application as soon as you release the key. While I use it most often with Cursor, it’s handy for many other applications as well.

Making It Work: Practical Tips

The tools are improving quickly, but to succeed with a strategy like this, you need to spend time providing the right level of detail and follow some key practices.  Here’s what I’ve learned to avoid frustration and maximize results.

Tests Are Critical – When the code is written almost instantly, testing isn’t optional—it’s your safety net. Even though we review AI-generated changes, we can only assess them to a certain degree. Sometimes those changes can introduce issues that affect other parts of the codebase, breaking functionality that was already working. Since AI can produce rapid, sweeping updates, strong test coverage is essential to catch regressions or bugs that might slip through. The speed of AI demands an equally strong emphasis on tests to keep your codebase stable.

Commit Often and Reset When Needed – AI is powerful, but sometimes it can go off the rails, making changes so extensive that fixing them becomes impractical. That’s why frequent commits are vital—every time you have a working state, commit it. If things break badly, resetting to the last reliable commit is often faster and less frustrating than troubleshooting a tangled web of issues. With AI’s ability to quickly rewrite large portions of your codebase, effective use of Git is non-negotiable.

Split Stories When Necessary – If the AI starts to go off the rails, getting stuck in a loop of failed attempts to implement a change, the issue might be that the story is too large or complex. Breaking it into smaller, more focused pieces can often resolve the problem. This approach reduces the cognitive load for the AI, making it easier to implement changes successfully. The good news? AI can help with this too. Instead of manually rewriting and dividing the story, you can use ChatGPT to split it for you—it’s a quick and efficient way to regain momentum.

Stick to Mainstream Frameworks – AI models perform best with widely used frameworks, libraries, and tools that have abundant documentation and examples. When you insist on using niche or custom built libraries, the AI struggles due to limited training on those tools. Staying within the mainstream ensures the AI can generate better, more reliable code with less friction.

Works Best for Microservices – AI performs best within a well defined, limited context, such as a smaller, self contained microservice. Microservices make it easier for both humans and AI to understand the scope, navigate the codebase, and make meaningful changes. Larger monolithic codebases, however, present greater challenges—understanding their structure and dependencies requires significantly more effort. While it’s possible to apply AI driven workflows to monoliths, the complexity makes it far more difficult. As tools evolve, they’ll likely improve at handling larger codebases, but for now, the modular nature of microservices aligns best with AI’s current capabilities.

Measure Twice, Cut Once – Skipping or rushing through the requirements phase—whether defining the epic, refining stories, or reviewing context—almost always leads to trouble. Taking the time upfront to get it right prevents the AI from spiraling into a frustrating loop of fixes and new bugs, where every solution introduces another problem. By giving the AI a clear picture of the target state, you avoid the endless back and forth and save a huge amount of time in the long run.

The New Era of Software Development

The story of Instagram has always inspired me. A small team—fewer than 15 people—built an app that scaled to millions of users and sold for over a billion dollars. It showed that a small, focused group could create something massive and impactful without following the traditional model of scaling into a giant organization.

Now, with AI, stories like Instagram’s feel more achievable than ever. AI multiplies what small teams can accomplish, making it possible to build and scale ambitious projects with far fewer resources. Organizations can stay smaller and more focused, relying on AI to amplify their efforts across every step of the process.

For years, the vision of a thriving tech company meant scaling into a massive organization, raising round after round of venture capital, and hiring a huge team to get the job done. But that picture is shifting, and I expect stories like Instagram’s to become far more common. Smaller teams—and even solo developers—now have the tools to punch far above their weight, creating innovative, impactful products with fewer resources than ever before.

I think that future looks more like this:

And less like this:

The result? A future where lean, nimble startups become the norm, creating impactful, high quality products without the overhead of yesterday’s model. It’s never been a more exciting time to build. With AI amplifying our abilities, the tools we have today let us move faster, think bigger, and accomplish more than ever before.