July 27, 2026
Perhaps the key feature of AI is the way answers are obtained by virtue of a conversation with the AI. Contrast this with using a search engine where each “ask” is an independent request with a response.
An AI conversation has context while search engine interactions do not. More and more, we use AI to create applications through the contextual, iterative, conversational process. As we have ideas we add these to the conversation and our application changes accordingly. Our customers are getting in on the action too. They are providing us with AI generated prototypes for new software or new software features and jump-starting development efforts.
It’s great! Or is it? We’re creating applications via conversations with AI but those conversations can get quite long and often represent a sort of trial and error approach. Adding and removing features and tweaking functionality as the conversation goes on (sometimes called “vibe coding”). There is a solution in summarization and regeneration. After that back and forth conversation has yielded the application of your dreams, ask the AI to summarize the conversation in a way that the end result can be regenerated from a single prompt.
We are setting out to show you how this can be done and to prove the viability of such an approach. It is important to say up front that our examples are based on a simple design and conversational prompts. We are not creating external guardrails or establishing any agentic artifacts to guide development (see “Agentic AI”). That said, we have chosen the agentic-leaning code generation tool Claude Code, which is exactly where we see customers and many developers starting their AI-based application development journey.
Agentic AI takes application development to the next level with the ability to allow for prompts such as “build an inventory management system” with the results being a whole dang software solution in one whack. Can such a thing be accomplished with the state of AI today? Yes. But you’ll need to employ advanced techniques to establish guardrails for the application feature set, to influence the look and feel of the product, and to use an enterprise database such as DB2. Agentic AI is also about the way an application or system is generated through management of the workflow. Execution of multi-step strategies are one of the hallmarks of agentic AI and this requires something different; short term context (the task at hand) and long-term memory (the overall project goals and where the project stands in the software development lifecycle).
To clarify our methodology, we want to generate an application and then take the summarized conversation and run it back through the AI to see if we get the same application. If we do, then the summarized conversation can be thought of as a reproducible encapsulation of our application, with early prototypes and rejected features essentially filtered out. This is important for a number of reasons. One is that we feel it is important to have an artifact that represents an application as finished product. In our traditional world this would be source code. In the AI world it is a regeneration prompt (more later on how this prompt is represented as a file in Markdown format). Another reason for having an artifact that represents an application is that it gives us more visibility into the ultimate cost of the development effort in terms of tokens (or Bobcoin) spent as an application reaches a final, reproducible form.
Enough prelude! Let’s dive in with Claude Code and make something happen! We’re going to simulate a conversational development effort by feeding Claude Code the following prompts one at a time:
- The task is to pull a list of Kafka’s quotes from Goodreads. Limit to 20 quotes.
- Create a UI based on JavaScript and Bootstrap to display the quotes in a list. Limit page size to 5 items and include a scrollbar.
- Add a random selection button to pick a quote at random and display it.
- Summarize this entire conversation in such a way that the standalone app can be generated from a single prompt.
- Save the summary into a file.
As we enter each prompt, Claude Code responds with a result and usually with questions or suggestions. For example, after step #1, Claude Code usually notes that more quotes are available and asks if we want to fetch them. Assume that for this example we are taking the path of least resistance (or the path of least assistance if you prefer).
Cutting to the chase here, the conversation with Claude Code led to the creation of the following functional user interface (see Figure 1). You can run it yourself! All of the examples in this article are hosted online at dandarnellonline.com/aiGen.html.
Figure 1. Conversational Application Generation (Claude Code). Regenerated version was the same in look, feel, and function.
Now on to clearing the cache and establishing a new Claude session to run the summarized regeneration script. The results from Claude Code were an application with the same look, feel, and functionality. Claude Code was impressively aware of what we were attempting to do, reiterating to us at step #4 that it was creating output that we could use to regenerate our application. Then, at step #5, we were given a file in Markdown format. Markdown is the de-facto standard for agentic-leaning AI engines since it is a simple standard that is both human readable and easily consumed by the AI engines. A short excerpt of the Markdown file looks like this:
# Kafka Quotes App — Regeneration Prompt
Create a single-file HTML app (`index.html`) that displays 20 quotes by Franz Kafka sourced from Goodreads. Use Bootstrap 5.3.3 (CDN) and vanilla JavaScript.
**Layout & Theme:**
– Dark color scheme: page background `#1a1a2e`, card background `#16213e`, nav/header background `#0f3460`, accent color `#e94560` (red-pink), text `#ccd6f6`
– Centered card (max-width 680px) with rounded corners and a drop shadow
– Card header shows “Franz Kafka — Quotes” (bold white) with subtitle “Goodreads Collection”
…
We found that Claude Code provided significantly more detail for regeneration than we gave it in our brief conversation. An application regeneration prompt with deterministic generated output seems far more useful as a prototype or a finished application than a long and winding road of conversational “vibe coding.” The regeneration approach is clearly in Claude Code’s wheelhouse. Upon regeneration we were given a summary of features generated with a red light/green light indication of success as Claude Code ran unit tests over the features in a preview window.
Out of curiosity we attempted the same effort using the same methodology on Gemini AntiGravity and ChatGPT Codex. You can compare results for all the AI’s online at dandarnellonline.com/aigen.html.
On the minds of many in the IBM i community may be the question: “What about Bob?” Most of the positioning we see where Bob is concerned centers around Bob being more than just another code generating AI. Bob is a fully agentic AI with the features one expects from a player in the large enterprise space like IBM. Modernization of legacy software is a key focus point but we think that Bob is ready to go toe to toe with other solutions in the application development space.
Bob sets out to go far beyond code generation and to answer the bigger questions about how to approach modernization of large projects along with the development of new software applications. We have only just glimpsed what this means in reality and time will tell whether IBM has been successful this time at creating a tool set that they can and will stand behind in a meaningful way.
How did Bob do given our research goals? Results were a bit more mixed than with Claude Code.
Figure 2. Conversational Application Generation (Bob).
The regenerated AI had some noticeable difference although functionality was still identical and complete. You can see the two version of the application in Figures 2 and 3 and the runnable versions are on the same web site as the other prototypes.
Figure 3. Regenerated Application (Bob).
While we feel that our simple application coding and regeneration effort was a success, proving that summarized regeneration prompts can be used to provide something akin to source code for an application developed in the typical “AI way,” we aren’t going to be happy until we’re creating scalable business applications in a predicable, cost-effective manner.
Dan Darnell is a co-owner and vice president at Arkansas Data Services. Dan loves to write code, talk about code, design things, and, most of all, to work with other people to solve problems and create solutions. Dan has worked successfully as a consultant, managed companies large and small, and has written for international publications (including two books on Java for the IBM i). You can reach Dan at ddarnell@ark-data-services.com.
Eric Whitcomb is a freelance author, software developer, and thinker. Eric loves to dissect problems in realms across disciplines and dimensions. He excels at taking these thought experiments and turning them into real-world applications, wherein the application might be everything from software to a screenplay. Eric has extensive experience with all-things-AI. If you Grok, Claude, Gemini, ChatGPT, or slide into the Wild West of open source AI, Eric has been there too. You can reach Eric at eric@rootmedium.com.