AI Development: Research, Plan, Implement

Michael Aguilar
Page content

Let’s say you have a problem, and you’re pretty sure that writing an app is the solution. Maybe you want a basic inventory system for your small business. Or maybe you have a small piece of a large legacy system that needs upgrading. It doesn’t matter what it is.

You have a problem, you want software, and you want to make the most of agentic development.

The Problem with “Vibe-Planning”

The impulse is to just start chatting with an AI. You describe your problem, the AI suggests something, you correct it, it suggests something else, and you keep going back and forth until you have what seems like a solid plan.

This is “vibe-planning.” It feels productive, but it has a major flaw. The result is what you think is a good plan, which may or may not actually be a good plan. An AI will happily follow you down a bad path if you lead it there.

There’s a better way. The cool kids are calling it “Research, Plan, and Implement”.

Research: Ask for Questions, Not Solutions

This first step feels a little backward, but it’s the most important one. You start by giving the agent a rough idea of what you want to do.

“I’m trying to keep track of the widgets I have in stock, and I haven’t found anything that really fits my needs.”

Here’s the key: don’t ask for solutions, ask for questions. Your goal is to force the AI to think about the problem space and help you uncover things you haven’t considered.

For example: “I need to write a simple inventory system. What are things I should consider? Please don’t offer solutions, just keep asking questions until you have enough information to develop a good plan.”

This can take awhile, with a lot of back and forth. You’ll update your prompt with answers to its questions, and it will ask more questions based on your answers.

  • You may not have answers to all of the questions. That’s fine. Open up a new conversation with the AI and work on getting answers to those specific points.
  • Be sure to include your priorities. Do you need to start adding things to your inventory now, but querying them can wait a bit? Then say so.
  • Your goal is to create a comprehensive overview of everything that will be involved with making your app. You mostly want bullet points. Avoid getting into the weeds; you’ll dig deeper during the “plan” part.

Your final “research” prompt will likely be many paragraphs long, including details like:

  • Programming language
  • Frameworks and libraries
  • Infrastructure (Where will this run?)
  • Deployment process
  • User roles and permissions
  • …and more!

Keep at this step until the agent doesn’t have any more significant questions. Save the final, detailed prompt in a text file. You’ll be using it a lot.

Plan: Create the Blueprint

Now you take your big research document and start a new session.

Give the agent the full overview you created. Then, ask it to create a series of high-level steps that build on each other to reach the final goal.

Once you have that list, copy it into a text file. For each major step, start another conversation. Ask the agent to expand on that single step, breaking it down into smaller, more detailed instructions.

Specifically tell it not to write any code, only to plan. You are separating the “what” from the “how”. You’re creating a detailed blueprint before anyone picks up a hammer. Do that for every high-level step.

Implement: Build It, Piece by Piece

This is much like creating the detailed plan, only now you’re finally asking for code. You take each small, detailed step from your blueprint and feed it to the agent.

For example:

We are creating an inventory application. We have a step-by-step plan for writing this application.

Our current requirement is to <plan step goes here>.

Develop a detailed, step-by-step plan for satisfying this requirement. It should be broken into small, individual coding tasks.

When all tasks are completed, the application should be runnable and testable by the end-users and/or `curl`. Steps should build on one another, leading towards completion.

Perform only what is needed to satisfy the immediate requirements.

Then you just do that, over and over again. My little resume-writing front-end had almost 200 of these implementation steps, just to give you an idea of the scale.

The implementation phase is a mix of repetitive boredom and moments of intense troubleshooting. The better your plan, the more boring and predictable the implementation is. That’s a good thing.

Re-planning: Plans Change

You don’t have to follow the plan exactly. Sometimes you’ll get halfway through a step and realize it’s not going the way you want.

That’s not a failure. It’s part of the process.

Go back to the “plan” stage. Start a new chat, tell the agent what has been completed, what the remaining plan is, and what you don’t like about it. Then, get a new, revised plan and carry on from there.

Tips and Tricks

  • Keep a detailed “completed” list. As you finish each small implementation task, add it to a running list.
  • Use the completed list. This list comes in very handy if you need to re-plan. You can give it to the agent as context for what’s already done.
  • Use git, a lot. Commit your code after every small, successful step. Add a tag after every successful step. This lets you easily roll back to a “last known good” state if the AI generates something that breaks the whole application.