AI software prototypes promise faster software development, but how much faster can they actually be built?

Most discussions focus on generating code. In our experience, the real gains come from something else: using AI throughout the entire development workflow. Planning, architecture, implementation, validation, and iteration all play a role.

To test this approach, we built a Grafana-based IoT monitoring prototype using AI-assisted development techniques. The result was a working prototype delivered in two days, along with several lessons about where AI excels and where human oversight remains essential.

Can AI build software prototypes faster?

Yes, but not simply because it writes code faster.

The biggest productivity gains came from accelerating planning, reducing repetitive implementation work, and creating feedback loops that allowed AI to validate and improve its own output.

Instead of spending days defining architecture, generating mock data, configuring dashboards, and solving integration issues manually, we used AI throughout the process to move from idea to prototype significantly faster.

The experiment also revealed an important distinction: successful AI software prototypes depend far more on planning and validation than on prompting alone.

Why we decided to test AI-assisted prototyping

At Hotovo, we work on IoT solutions that collect telemetry from sensors and provide operators with visibility into complex systems.

One of our projects focuses on wastewater treatment monitoring and control. The platform processes sensor data, visualizes system behavior, and helps operators understand what is happening across the infrastructure.

A potential customer approached us with a simpler requirement.

Unlike our existing solution, they were interested only in observability. They wanted dashboards and monitoring capabilities but did not need device control or process automation.

Instead of building another custom frontend application, we explored whether a Grafana-based solution could provide a faster and more cost-effective alternative.

The question quickly became:

Can AI help us build a convincing prototype in days rather than weeks?

Planning AI software prototypes before implementation

One of the biggest misconceptions about AI-assisted software development is that coding should start immediately.

In this project, most of the early work focused on planning.

Before writing implementation code, we used AI to discuss:

1. architecture decisions
2. infrastructure options
3. data generation strategies
4. dashboard requirements
5. deployment approaches

Several iterations were necessary before arriving at a workable solution.

For example, an early approach assumed we could import historical telemetry data directly into Grafana Cloud. During planning, AI identified limitations that would have become blockers later in development.

By discovering these issues upfront, we avoided wasting implementation time on an approach that would eventually fail.

This planning phase resulted in detailed implementation documents, architecture guidelines, and user stories that later served as inputs for development.

The lesson was simple: the more context and structure AI receives before implementation starts, the better the outcome.

Generating realistic IoT data

A prototype is only as convincing as the data behind it.

One of the requirements was to avoid the typical problem of mock data: values that look random and have no relationship to reality.

To solve this, we provided AI with examples of actual customer telemetry. The goal was not simply to generate numbers but to generate data that behaved like a real monitoring system.

The generated dataset included multiple device types, correlated events, and sensor-specific behaviour. Events affecting one device also appeared in related devices, creating realistic dependencies across the system.

This mattered because the prototype would eventually be shown to people familiar with the domain. Unrealistic telemetry would immediately reduce confidence in the solution.

The resulting data was detailed enough that the dashboards felt connected to a real system rather than a collection of unrelated charts.

Using AI as an implementation partner

Once planning was complete, implementation became surprisingly straightforward.

Detailed specifications were broken down into smaller stories, and each story followed a similar process:

1. Create an implementation plan.
2. Review the proposed approach.
3. Implement the solution.
4. Validate the result.

Rather than manually designing every component, AI handled much of the repetitive work while maintaining consistency with the overall architecture.

One interesting observation was that AI frequently went beyond the requested scope.

It often suggested tests, validation mechanisms, and supporting utilities that improved confidence in the generated solution.

Instead of acting purely as a code generator, it behaved more like a development partner participating in the implementation process.

Why feedback loops matter more than prompts

The most valuable lesson from the project was that feedback loops matter far more than prompt quality.

Most AI-assisted development workflows look something like this:

Prompt → Generate Code → Review

Our workflow looked very different:

Prompt → Deploy → Validate → Improve → Repeat

Instead of asking AI to generate an entire dashboard and hoping for the best, we built mechanisms that allowed it to evaluate its own output.

To achieve this, we created custom skills that enabled AI to:

1. deploy Grafana dashboards through the Grafana API
2. capture screenshots using Playwright
3. inspect visual output
4. iterate automatically when something looked wrong

One dashboard went through 48 deployment iterations before reaching its final form.

The AI would deploy a version, capture screenshots, identify issues, adjust the implementation, and deploy again.

This process continued until the dashboard matched the intended design.

The result was a workflow that resembled a junior developer repeatedly checking their work rather than a one-shot code generator.

That distinction turned out to be critical.

Solving real engineering problems

The project was not simply a matter of generating dashboards.

Several architectural decisions emerged during development.

One example involved data storage.

An early proposal relied on storing historical telemetry directly in Grafana Cloud. During planning, we discovered limitations around importing older data that would have prevented the approach from working as intended.

The solution was to switch to a different architecture.

Instead of storing historical data inside Grafana, we generated CSV datasets and exposed them through a hosted source. Grafana then consumed the data through the Infinity plugin, which allowed dashboards to read CSV files directly.

This approach was simpler, cheaper, and worked within the constraints of the prototype.

Another decision involved infrastructure.

Rather than introducing additional cloud services, Bitbucket was used not only for source control but also for data generation and automation. Scheduled pipelines regenerated telemetry data and published updated datasets automatically.

The result was a surprisingly lightweight architecture that fulfilled the prototype requirements without unnecessary complexity.

Custom skills accelerated development

As the project evolved, we noticed that AI repeatedly performed the same tasks.

Instead of describing these tasks in prompts over and over again, we converted them into reusable skills.

Examples included:

1. deploying dashboards to Grafana Cloud
2. capturing dashboard screenshots
3. validating dashboard output
4. generating structured implementation plans

These skills became building blocks that AI could reuse throughout development.

The impact was significant.

Once deployment and validation became reusable operations, AI could focus on solving the actual problem rather than repeatedly figuring out how to perform routine tasks.

This also reduced prompt complexity and made development more predictable.

What worked well

Several aspects of the workflow exceeded expectations.

Detailed planning

Investing time in planning reduced implementation friction later.

The more complete the specification became, the fewer issues appeared during development.

Structured documentation

Using markdown files as the interface between planning and implementation proved highly effective.

Instead of relying on long conversations, important decisions were captured in reusable artifacts.

Incremental development

Breaking work into smaller stories made the process more predictable and easier to validate.

Automated validation

Providing AI with mechanisms to verify its own output significantly improved results.

Validation became an active part of the workflow rather than a final step.

What slowed us down

Not everything worked perfectly.

One challenge involved dashboard performance.

Initially, telemetry data was generated at a high frequency. While technically correct, the resulting dashboards loaded more slowly than expected.

Reducing the sampling rate improved performance while maintaining the visual quality of the data.

Another challenge was context management.

Large projects generate a significant amount of information. Without careful organization, conversations become difficult to manage and important details can get lost.

Structured documentation helped mitigate this issue, but context management remains one of the most important aspects of working with AI at scale.

What we would do differently next time

If we repeated the project, we would invest even more effort into automation.

Several tasks still required manual intervention:

1. moving specifications between systems
2. triggering implementation steps
3. performing reviews
4. coordinating workflows

Many of these activities could be further automated through orchestration.

We would also formalize the specification process.

The quality of implementation was directly related to the quality of the planning artifacts. Better specifications consistently produced better outcomes.

So, can AI build software prototypes faster?

Yes.

But not because AI writes code faster than humans.

The biggest gains came from using AI throughout the entire workflow:

1. planning
2. architecture design
3. implementation
4. validation
5. iteration

The most important lesson was that feedback loops matter more than prompts.

When AI can deploy, inspect, validate, and improve its own work, the quality of the results increases dramatically.

For this project, that approach enabled us to move from concept to a working Grafana-based IoT monitoring prototype in two days.

More importantly, it demonstrated that AI can contribute far beyond writing code when given the right tools, context, and feedback mechanisms.

The future of AI software prototyping is not code generation alone.

The real opportunity lies in combining planning, implementation, deployment, validation, and iteration into a single workflow.

As AI-assisted software development continues to evolve, the teams that benefit most will likely be those that focus less on prompts and more on building systems that help AI learn from its own output.