AI in the Product Development Cycle

AI in the Product Development Cycle

Evaluating AI Contributions at Each Stage

Evaluating AI Contributions at Each Stage

JUL 15, 2026

JUL 15, 2026

AI in the Product Development Cycle hero image

Meta Note: I used Framer's AI to create this page's structure. I wrote the article manually.

TL;DR

Currently, in the Product Development cycle (define the problem, define personas/ICP, research and validate, scope, sketch and iterate, refine, deliver), AI seems to be most valuable in the research, scoping, and delivery phases. It affords the lowest utility in the design iteration phase itself, where in the best case a purely-AI design flow incurs a 3-6x time-cost increase, with an unsustainable token burn rate. One outlier is Figma's in-canvas AI tool which allows automation and paralellization. Conclusions drawn from both overall experience, and from the process of creating a new project for iOS store release, which I will detail below.

TL;DR image

Field Notes: Building an ios app

Special Project: An RSVP App for Practice Groups

I am writing this article within the context of creating a niche app for release into the iOS store, and using the project to test the efficacy of AI assistance at each stage. The project happens to be for my West Coast Swing dance community, to set up practice sessions. I am using Claude Cowork for research and market evaluation, and testing the design capability of four currently-leading models, benchmarked against a human designer using Figma. In this article I will include general evaluations alongside "Field Notes" sections like this one, which detail specific experiences in building with these tools.

My Project: An RSVP App for Practice Groups image

Research: AI as a Pattern-Finding Copilot

For defining the problem and the personas, and validating hypotheses through research, AI is a powerful accelerant. These phases depend on compressible language, the specialty of LLMs. A model can quickly gather, summarize (and in many cases synthesize) information, identify patterns in data, and collate sources for human due diligence. Team members may still choose to acquire data independently, but they can spend more of their time identifying patterns in available data, and validating the veracity of AI’s pattern recognition, rather than digging for information.

Field Notes: Building an ios app

Ideation: With the goal of creating an app to explore the potential of AI assistance at each stage of Product Development, I asked Claude to list 20 suggestions that were a good fit. It provided several ideas for inspiration, among them a bird-migration app, and an "isochrone" map that shows you everything reachable within X minutes. It thankfully shot down a few of my ideas as well. Still bitter that it didn't like my "Earth Sandwich" geolocation concept. Who wouldn't want to meet someone on the exact opposite side of the globe? What could possibly go wrong?

Research: I then asked Claude help me explore the feasibility of our top concepts. It scraped forums and publicly available data for incumbents in each space, compiling a dossier that included user sentiment, market demand (TAM/SAM/SOM) and potential revenue. Ultimately, I decided to scratch an itch in one of my own communities, West Coast Swing dance. I did this because the idea's scope is perfect for a solo project, and I have ready access to expert users in the space.

Problem: The logistics of organizing dance practice groups are difficult using current tools. Organizers must remember to send out reminders, update minor details, send out payment requests, and allow RSVP's based on role. Current solutions make heavy use of messaging apps, but some people have cobbled together AI-coded browser scripts with poor design.

Ideal Customer Profile: Claude constructed three personas. To limit scope for the initial phase of the project, I am working purely with a West Coast Swing practice-group organizer in mind.

Solution: A niche RSVP app specifically for practice groups can solve all of the issues above. It can send out reminders, update key details, provide payment links, and allow role-based RSVPs to ensure balanced practice sessions.

Having landed on the key idea, I asked Claude to present additional use cases based on its findings (i.e. who else might need a role-based RSVP app?). It proposed that the same app could be useful for roller derby leagues, climbing groups, choirs, tabletop gaming groups, and more. Some of those may be truly valid (roller derby groups, choirs), while others likely are not (climbing and table top gaming groups).

My Project: An RSVP App for Practice Groups image

Scoping: Context as a Coefficient of AI-Generated PRDs

Scoping utility has low-to-moderate dropoff, as a leading model can create a mostly-accurate PRD in proportion to the quality of its available context. With a greenfield project like the one I am creating, that context requires considerable initial effort to produce. However, a PM who used pre-existing context files could dramatically reduce the effort required for AI-assisted scoping.

Field Notes: Building an ios app

Claude helped resolve the initial scope into finer detail after I nailed down the vision for the app, though it obviously needed me to know what I wanted first. At this phase, it functioned as a useful thought companion, helping me to mercilessly cut features by highlighted resource expenditures likely required for each. It helped me to create a list of what was above and below the line.

My Project: An RSVP App for Practice Groups image

Design: Seeking Efficiency in Time and Tokens

So far AI has provided considerable assistance. Researching and scoping a project all involve heavily compressible linguistic vectors. Design itself is different in that it requires a rapidly-iterative loop of modification and evaluation. Of course, a perfect model would intake a project's requirements and constraints, then output a flawless solution in one attempt. The next-best (and likely most realistic) model would iteratively loop through option trees, self-evaluating their respective merits and tradeoffs in rapid succession, until a beautiful and functional solution resolved. Greater efficiency will thus result from requiring fewer iterations (ideally 1), and iterating faster. However, current models are incapable of reliably evaluating iterations relative to project specs, each iteration carries high time and token costs, and unguided attempts are subpar by most metrics. A human is still far more capable in this phase, although that may not always be the case.

Field Notes: Building an ios app

Experiment: Before creating the first drafts of the project, I experimented heavily with Claude to create a starter design library. Paired with the Figma and Firecrawl MCPs, I created skills that allowed it to scrape the design features of any given site and distill it into a library. As part of that starter library, it would create all brand color primitives and link them to semantic variables, as well as establish styles for all fonts, shadows, spacing and corner radii. Finally, it would create 4 simple starter components, including a suite of buttons.

Result: I ran the brand scraping skillset on 5 sites (Stripe, Apple, Firecrawl, Clickup, and Vercel). The first run (on Apple) was extremely slow, taking around 40 minutes. I asked it to troubleshoot, and it suggested a change that would filter out 95% of the returned data. After making that change, it took around 10 minutes per attempt to scrape and build a library. The outputs were superficially useful, but turned out to be more troublesome than they appeared. Each attempt included too many color primitives, and displayed them alongside the semantic variables in style menus. Additionally it failed to produce components accurately, and assigned nonsensical sizes to heading variables (desktop H1 was often a minuscule 26pt). No amount of troubleshooting could solve those issues. It also did not set up the component pages with a clean visual structure, opting instead to place components in a haphazard grid. Yet I found that even after redoing much of the work, I did still save some time. The key advantage was that it created a scaffolding, and all I needed to do was swap and modify the variables. So a library builder can function as a useful starting point to build from. With further experimentation I am confident that the system could be much more accurate.

My Project: An RSVP App for Practice Groups image

Shallow Idea Pool: Low Hit Rate for AI-Generated Starting Points

Iteration is one of the most resource-intensive phases in the design process. This is where good designers shine, embroiling themselves in branches of ideas, restarting, combining, and transforming patterns, until they arrive at aesthetically beautiful solutions that satisfy the overlapping requirements of the business and the user. I have found that models are most useful in brainstorming a pool of visual ideas to start from. Well-crafted context files asymptotically improve successes, with rates plateauing at 10-20%. Currently, one-shot design quality is at approximately entry level aesthetically, and below entry level in usability, producing outputs are often visually pleasant yet largely dysfunctional.

Field Notes: Building an ios app

After creating a library that I liked well enough to move forward, I used Claude to create a prompt and a design.md file. I fed those into Figma Make, Claude Design, Lovable, and Bolt44, which all returned a series of starting points at the level I described above (aesthetically at entry level, functionally below that). Bolt44 created the most pleasing one-shot versions. After using Gemini to further refine my design.md file and sending further prompts to each model, I was able to coax satisfactory outputs from Claude and Bolt44, with the best being from Claude.

My Project: An RSVP App for Practice Groups image

Time Per Iteration: Massive Increases Per Attempt

Good design requires a long series of fast tiny moves, not yet achievable in one prompt. When iterating after a given starting point, I found precise edits to be cumbersome using purely AI design tools. The feedback loop (make a change ↔ evaluate the change, repeat) is slow. Here, I will approximate the time requirements that I have experienced, in order to compare effective speeds and costs when using purely-AI vs. traditional tools to iterate a design.

For a human in Figma, a new iteration can take anywhere from a few seconds to a few minutes. Small tweaks take seconds, while structural iterations can take 10 minutes or more. Let’s pin the mean at ~5 minutes, with the mode (most common change) at ~2 seconds per iteration.

At the time of writing, all the AI models I tested (except Figma Make) offer an “Edit” feature for limited real-time adjustments without AI assistance. In all models, a pseudo-prompted “tweak” feature allows small changes in a little under 2 minutes, by selecting an object and typing instructions. A full iteration attempt in the prompt window triggers a 6-12 minute process regardless of the depth of change required. We can pin the mean here at ~6 minutes, with the mode (using a "tweak” most often) being ~1:30. This constitutes around a 1.2x increase in the average time per iteration attempt, with a roughly 45x increase in the most common type of change (small tweaks).

Number of Iterations: Massive Increases in Attempts Required

In the quest for greater design efficiency through AI, we just ruled out time-per-iteration as a possible avenue for greater efficiency (for the present). Now we turn to the second possibility: reducing the number of iterations required.

A little philosophical deep dive will be helpful here. To start, not every a change to a design can be considered an "iteration". We can think of iteration as exploring a finite, unbounded volume of "solution space", a dense probability cloud with many dimensions. Like an elaborate game of Minesweeper, there are several points within a given space that constitute viable solutions, they give clues when they are nearby, and the final design needs to converge on at least one of them. We explore this search volume through iteratively stepping through it and evaluating what we find. Any viable iteration either converges on a solution or at least a clue (inherently productive), or reveals a given volume of solution space to be empty, thus reducing the required search space and (slightly) increasing the likelihood of finding a solution thereafter.

Inversely, non-productive attempts are those which explore outside of the search volume, where the probability of a viable solution is nearly zero. The most extreme version of this would be randomly scrambling all of a design's visual elements. That would not be an “iteration” because it explores an infinitely large space, almost guaranteed to be outside of the relevant search volume, and carrying an astronomically low chance of converging on a viable solution. Infinite monkeys banging on keyboards will produce Hamlet, but nothing short of infinity will do.

So for successful iteration we need to confine our search to a certain space, and we need to detect when we are onto something good. In this sense, nearly all changes that even a moderately-trained human designer makes are productive. Without much experience, they will likely interpret project requirements in a way that produces a large space to explore. And they will struggle to converge on all of the required dimensions of a solution. They don't quite know where to go, and they don't quite know when they have arrived. But crucially, they are still exploring a relevant space. With greater experience, they reduce the initial search volume and search it faster, and they more accurately detect and follow the clues to a solution.

This stands in contrast to the majority of AI models (in their current state). Despite essentially operating as massively multi-dimensional reference libraries, they are currently unable to interpret project specs to produce a reasonable probability volume. If potential solutions are grains of sand, they are including the tops of trees in their search area. Much better than clouds, but it needs work. Additionally, they are unable to detect many of the clues that lead to solutions.

Human interaction with AI design tools, at the time of writing, comes down to constraining the search volume (with context documents) and directing it toward solutions (prompting). Currently, both goals can be achieved much more quickly by a human mind alone.

Even using Anthropic’s Opus 4.8 and Fable 5 (Fable being the leader in all benchmarks at the time of writing), results were inconsistent. I found that a given model would produce output far outside the relevant probability space 80-90% of the time. Using the (optimistic) average of 6-minutes per attempt that we established above, each productive step in this phase thus took 30-60 minutes and costs 5-10x the tokens of a single shot. By contrast, productive human-made Figma iterations take a pessimistic average of around 10 minutes. Comparing the current state of iteration with a pure-AI design stack versus using Figma, and shifting all numbers toward a best-case scenario in favor of AI, my conclusion is that AI-only iterations currently incur a 3-6x increase in time cost, and a token burn rate that would be unsustainable for all but the largest organizations (and maybe not even then). A more realistic evaluation would put that time cost at closer to 7-8x.

field Notes: Building an ios app

To overcome the above limitations, I had Claude Desktop design initial drafts in HTML/CSS. Once I arrived at a solution, I imported the artifacts into Figma, then pulled apart pieces, modifying them and using them in a design that I am creating manually. Consistent with the rest of AI's contributions in the design phase, the most useful artifacts have been starting points to build from. Periodically I am running design components through Claude to see if it can expand on ideas. For example, I fed it several screenshots of a special CTA I am creating for this project, asking it to expand it into a full button set. The result was moderately useful. Next I plan to experiment with different models for protoyping based on existing designs, i.e. “Link these screens together into a functional prototype.”

My Project: An RSVP App for Practice Groups image

A Powerful Outlier: Figma’s In-Canvas Editor, Editable Outputs and Parallelized Workflow

One exception to the currently dismal state of AI-iteration is Figma’s in-canvas tool. It can perform simple tasks like auto-filling FPO information and images that would previously have required multiple plugins, as well as more complex tasks like iterating on a given frame, or reproducing screenshots in wireframe or high fidelity. It has a similar hit rate to other models, with full iterations being useful around 10-20% of the time. But there are two key differences. First, all outputs are fully editable, with auto-layout accurately applied most of the time. I can take a useful iteration and run with it immediately. The second difference, and the most most crucial, is parallelization of the workflow. I can make a request, and then work on another part of the project while the AI chews on what I asked. It is no faster than other tools, but I do not have to wait for output. We are both working at the same time, with AI automating the tedium that would otherwise take up my time as I focus on the bigger tasks. It is truly a breath of fresh air to work like that. I can enter a flow state, avoid massive token burn rates, and make efficient use of time while leveraging the additional capacity of AI in a resource-intensive phase of the design flow. The total utility is low right now, improving workflow speed by around 10-15%, but with increases in AI speed this should move up disproportionately.

field Notes: Building an ios app

I am actively using Figma’s canvas AI editor to automate tedious tasks, and in some cases, to iterate on designs. So far, the success rate is low in creating useful iterations. The greatest time saver is in the inspiration-to-iteration pipeline. I can import screenshots of an inspirational app, have AI reproduce a component in high fidelity, and then modify that component for my own purposes. This is the current phase of the project, so project notes end here!

My Project: An RSVP App for Practice Groups image

Refinement: No Substitute Yet

The refinement phase involves identifying which designs truly solve the problem, and finalizing their patterns to satisfy all requirements. This is the phase where the team decides what will ship. I have not identified any leverage point within AI that can accelerate this process. A human product team still needs to evaluate the requirements against the designs, and sign off on what will make its way into users’ hands.

Delivery: Starter-Pack Deliverables

AI can improve hand-off by breaking down specific designs into boilerplate files for engineers to complete. It can do this in all required languages for front- and back-end, allowing delivery to consist of not just a Figma file, but a starter pack of everything an engineer will need to complete the requirements. This could accelerate execution and improve fidelity between execution and design, reducing overall debt and QA-oriented follow-up from designers.

Conclusion

The dream of AI in the design iteration phase is that of a faithful companion who is always around and always helpful. The reality is more like a drunken fairy-godmother: she occasionally pops off with a miracle, but her biggest trick is making money disappear. Our best option currently is Figma’s in-canvas tool, which has been quite useful so far. I am excited to see where that goes.

Outside of design iteration, a product team should lean heavily on AI to accelerate the discovery, research and scoping phases of the project. Deliverables can also be super-charged with boiler plate files and any text-based accelerants an engineer may find useful.