Nate B Jones presents a six-stage Prompt Lifecycle framework with 19 tools and a demo of his own tool, Hey Presto
Nate B Jones walks through the full lifecycle of a prompt, from fuzzy intent to production deployment, naming tools at each stage and introducing his own tool, Hey Presto.
Summary
Nate B Jones argues that the prompting space lacks a coherent framework, and that most people — and most tools — skip the most important first stage: intent formation. He lays out a six-stage Prompt Lifecycle covering intent formation, authoring and drafting, versioning, evaluation and testing, workflow and automation construction, and deployment. He maps roughly 19 tools across these stages, noting that most existing tooling clusters around stages two and three, leaving stage one — the fuzzy ideation phase — largely unserved. To address this gap, he introduces Hey Presto, a tool he built specifically to help users move from rough notes to a structured, high-quality prompt, with demos showing it used for both a React app build and a PowerPoint deck based on Andrej Karpathy's Software 3.0 talk.
Key Takeaways
FULL TRANSCRIPT
The Wild West of Prompting and Why a Framework Is Needed
Nate B Jones: Prompting is really weird because it's the most wild west software space I've ever seen, but it's also a highly leveraged, critical part of AI workflows. There are dozens and dozens of prompt tools. And as far as I can tell, very few people have laid out or thought through the overall lifecycle of a prompt and how we think about prompting systematically. That is what this video is for. I'm going to lay out how I think about prompting in a lifecycle, and I'm going to lay out the tools that I think are relevant at each stage. So let's jump into it.
Stage One (Reframed as Stage Two): Authoring and Drafting
Let's start where most people begin — authoring and drafting. You're writing, you're rewriting, you're testing prompt text. A lot of people are in Claude or in ChatGPT for this, and they're saying, "Make it better. Make it better." Or people are using tools like Prompt Perfect. Some people are in Cursor if they're in code. This is all about hands-on experimentation and wording refinement. We're not testing the value of the prompt — we're just trying to figure out the mental model we have of the perfect prompt, and whether it's right or not, we're trying to make the prompt we write fit that model. That's the authoring and drafting stage. What we find in this situation is that the LLMs help us to organize our thoughts and help us to take these messy thoughts and clean them up.
Stage Two: Versioning
The next stage in prompting is really around getting serious about versioning. Teams — or individuals — will start to say, "This is a prompt I use often. How do I keep track of it when it needs to change?" Teams will store their prompts, name them v1, v1.1, describe the differentiation between them, diff them, and name them. Prompts are then almost treated like code — they become artifacts in the business because they get reused so much.
Prompt Layer definitely offers tooling capability here. PromptMetheus does this. There are Git-based approaches that do this, and a lot of other approaches as well. LangChain does this too. The idea is you are trying to solve for the persistence of the prompt — so there's one record for it, it's auditable, and you can enable team-level coordination on it.
Stage Three: Evaluation and Testing
The next stage after versioning is making sure that the prompt is regularly tested. This is especially true if it's a production-grade prompt that will be used in an LLM production system. You need a solution where you can compare multiple prompts, evaluate outputs for accuracy, evaluate cost and hallucinations, and so on. Tools for this include Hegel's prompt tools, Prompt Flow eval components, and PromptMetheus again. There are also custom eval frameworks — a lot of people are writing their own eval solutions and finding those are more flexible and more effective because they allow them to write to the detailed setups they have.
One of the places where we start to differentiate between individual builders and teams is right here at evaluation and testing. Before this point, if you were a serious individual, you might still have your own versioning system — a little Notion database where you keep track of your prompts, and it works for you. When it gets to eval, though, teams using production-grade prompts will build entire suites of tests — 50 tests, 100 tests — that they run in an automated fashion in a pipeline against a new version of a prompt. Individuals are very unlikely to do that. We will probably test in an ad hoc way, or if we are super organized, we'll have a library of 10 or 15 queries that we run with the prompt to see if it works better. But it's rare to get super serious.
As we move forward in this flow, we see that these prompt tools start to become more team-oriented. This is one of the things that makes prompting really complicated — it is both an individual productivity choice and something that supports teams. Dealing with that duality makes it hard to write good software.
Stage Four: Workflow and Automation Construction
But we're not done with evaluation. After evaluation comes constructing workflows or automation. This is when prompts become mere steps in workflows. The prompt becomes a guidepost for an agent that might have tools, might have memory it calls, might have conditional logic. You then begin to need to build with tools like Google's Agent Kit, LangChain, LangSmith, Hegel and Prompt Tools, Prompt Flow, and React agent frameworks. This is all about multi-step automation and agentic behavior in prompting.
This is part of why it's a tricky subject — it bleeds into this area. If you're trying to build an agent, you have to consider the prompt as the beating heart of the agent. The prompt is what helps you to predictably guide the agent.
Stage Five: Deployment
Finally, you have deployment tools. Prompts are embedded in real applications and they need to be tracked, they need to be up all the time, they need to run correctly. Prompt Layer comes back through here. LangSmith comes through here. There are model APIs directly available from OpenAI and Anthropic. You have to have production robustness, safety, traceability, and governance.
You can see, as we've gone through this overall flow, that we have gone heavily into the teams and companies world — where prompting is a piece of code that companies need to maintain, and they need production tooling for that system.
The Missing Stage: Intent Formation and Discovery
I am here to tell you that you are missing a stage in the prompting lifecycle. Let's go back through. What if we thought of our first piece — authoring and drafting — as stage two, not stage one? Because it is. When you think about where you want to go with prompting, it's actually intent formation and discovery that has to happen first, and then you get into authoring.
What I have found, sitting down with people over the last few months, is that intent formation for individuals is really hard. I'll be honest — this is definitely more true the earlier you are in your AI journey, when you're still trying to figure out how prompting actually works. But it remains true the farther you go in your journey if you need help to trade time for expertise. If you're trying to write a prompt quickly and formulate your intent quickly and you don't have the time to do it — and you may be an advanced prompter — you still run into the same issue because you have a fuzzy goal.
You want to summarize something, draft a plan, analyze a sentiment. And now you need to get to a structured, unambiguous, high-leverage prompt that clarifies the objective, the constraints, and the steps. And you know that you should — it's like eating your vegetables.
There are not great tools at this stage, and most people use ChatGPT. I'll be really honest — most people use ChatGPT or Claude for this, and that's fine. But what I have found is that those tools by themselves aren't super well suited to the kind of intent formation we're doing at this stage. And there's a really simple reason why. When you're crafting a prompt in Claude or ChatGPT or Gemini, you are crafting it and implicitly assuming the prompt will work in that particular LLM. There's not a cross-LLM compatibility check going on. You are also typically not getting the LLM to help you think through what the output format for this prompt and artifact should be.
That sounds really abstract, so let me make it concrete. If you have a fuzzy intent, you typically know the output needs to be a deck at the end of the process. But what you don't often do is say, "Please tune this prompt in such a way that it's specific for writing a deck," because you're at the fuzzy stage — you're trying to think through the content first. And content comes before format.
What I'm picturing for you is the real-world complexity that I feel, and that others feel, when they're trying to craft prompts. And to be honest, there hasn't been a great tool for that. That's why I built one.
Introducing Hey Presto: A Demo
I built Hey Presto to solve specifically this ideation and intent formation piece. And if you come back to me and say, "Nate, I'm using ChatGPT," I will say, "Bless you. Have a wonderful time. This tool is not for everyone." Let me show you how it works.
Here we are in the prompt tab on Hey Presto. I have just pasted in some very rough notes for an app I keep trying to build — my family travel app, where it shows me different destinations around the world — and I say, "Please help me craft a prompt to build code for my app." All I do is say, "I want to build code," and it gives me an expanded prompt. It's going to give me lots and lots of detail on the travel app — a suggested file structure, a suggested data model. And keep in mind, all of this is editable. I have made no commitments. Nothing is running. I can go back through and edit all of this. I don't have to believe or buy any of this.
And I can also change it. If I want to change the stack — this is a Python stack for those of you who are engineers — if I want to change it and say, "I'm not writing this in Flask, I'm writing this in React," all I have to do is append that note and regenerate. It runs pretty quickly.
While we're letting it generate, you have different tones you can get with this. You can select different output formats — JSON, email, table, numbered list, step by step, structured sections. And there it is. It's getting into React, it's getting into Tailwind, and it just rewrites the prompt. It takes the detail you give it — and in this case I gave it a fair bit — and turns it into a high-grade prompt.
And if you're wondering whether this actually works, I will show you what I've been working on in Lovable. The answer is yes. Here we are in Lovable, crafting a cute little app. We can add a destination, add a family member, set energy levels for the family member — whether they're an adventurer or a relaxer. The app isn't done yet, but it's coming together. And I was able to use the prompt to craft the initial piece of the app.
This is not just for Lovable — I could have put this into Google's AI Studio, used it for any other vibe-coded application, or even used it in Cursor or other spaces to get started. It is designed to be agnostic of the tool but focused on the outcome you want. That's a space that's been missing strategically, because when we're forming intent — when we're at that fuzzy initial stage — we need the flexibility to go anywhere.
Demo: PowerPoint Deck from Andrej Karpathy's Software 3.0 Talk
Let me give you one more example. This one is around PowerPoint text. Here we are with a PowerPoint deck summary of Andrej Karpathy's famous early 2025 Software 3.0 talk. It's gorgeous. It looks great. "Software is changing again." I just love the look of this. All generated by one prompt from Hey Presto. Super easy. I got around 20 slides out of it. "Embrace the Iron Man suit." I love this. What a finish. It makes sense. It's ready to share.
How did I do this? Very simple. All I did was say, "I want to make a deck about this article," put in my notes, said I want it to be a deck, and I got a prompt that had everything — the slides laid out, all of it. And you can change this, you can adjust it.
And by the way, if you're wondering why you would go to Hey Presto rather than just doing it directly — we've made buttons so it's really easy to go into Claude or into ChatGPT directly. You can open it up and it will just pop the prompt open right in Claude. Super easy.
On the Prompt Lifecycle Framework and the Role of Hey Presto
Now, this is the part where people usually roll their eyes because they think, "Oh, Nate has sold out. He's trying to shill his product." I'll be honest — I could be the person who does that, and I'm not going to, because I'm not interested in saying this is the best product for everything. That is why I spent 15 minutes going through all the stages of the prompt tool chain and talking about all the other great tools available for prompting. I do not believe in a world where there is one prompt tool for everything.
If you remember, we have these multiple stages in the prompt tool chain. These are the six stages of the prompt lifecycle. We have spent almost all of our tooling and thinking time around stage two and stage three — writing, rewriting, testing prompt text; storage and versioning. This is where individuals are really seeing prompt tools. And then there are a lot of team-level prompt tools as we get into the more advanced stages — evaluations, workflow construction, deployment, and production integration.
I really think this is important. If you want to get from casual ideation to clean intent, there needs to be a good tool for that. I just haven't found a tool that more easily helps me name what I want to build — whether it's a deck, a doc, communications, Slack messages, code, whatever it is. That's why I built Hey Presto.
If it's not for you, if you want to hack around in ChatGPT, bless you — it may work well. I've certainly done it before. And if you disagree with me and think intent formulation is not the correct first stage for prompting, I would love to hear what you think the correct initial stage is — because I do not believe the correct initial stage is writing or authoring.
Either way, I had fun making Hey Presto. I think a lot of the future of tooling development is talking with communities, hearing what's going on, and trying something. I'm offering Hey Presto in that spirit. My goal is to make it useful. I don't need to make it super big — I just want to serve the community around a need that I found.
I also think it's good to actually build things and launch them if you talk about AI all the time. It's important to have AI tools that solve problems if you talk about AI tools a lot. That's part of why I've been involved in building this and digging in and constructing it.
If you're interested, I'm happy to do a deeper dive on how I built the tool. I wanted to start with a prompting structure first because I think we have missed a framework for prompting. I felt like I had trouble understanding my own thinking until I could name the different stages of the prompt tool chain and talk about the tools. No shade on all the other tools — they're great, and that's part of why I took the time to introduce them. You need multiple tools for these different stages, and my goal is just to help with that intent and initial piece that I think hasn't been as clean as it needs to be.
Hope you enjoyed it. If nothing else, now you have some vocabulary to talk about the stages of the prompt lifecycle, and I think that will be helpful. And maybe you got some good tool tips for some of the other later stages — that's another reason I made this video. There are a lot of great prompting tools out there.